Time value of money: PV, FV and annuities

₹5,00,000 needed in five years is worth ₹3,56,493 today, if money can earn 7 % a year in between. And a ₹5,000 monthly SIPsystematic investment plan (SIP): The same amount invested at regular intervals, usually every month. Its value at the end is the future value of an annuity due, because each instalment goes in at the start of its month. projected at an assumed 12 % for 20 years ends at ₹45,99,287 under one monthly-rate convention and at ₹49,95,740 under the other, from the same three inputs.

Both facts come from one idea: a rupee is worth more the sooner you have it, because it can earn in the meantime. This lesson carries single sums forward and back, values a series of equal payments, derives the EMIequated monthly instalment (EMI): The same amount paid every month to repay a loan, partly interest and partly repayment of the amount borrowed. It is the payment whose instalments, discounted at the loan's monthly rate, equal the loan. of a loan and the corpus of a SIP from the same annuity, and finds the ₹3,96,453 between the two conventions. It is education only: the loan and the 12 % are examples for the arithmetic, not offers or forecasts.

A rupee today and a rupee later differ by the interest between them

₹1,00,000 today, at 7 % a year, becomes ₹1,07,000 in a year and ₹1,40,255.17 in five: that is its future valuefuture value: What a sum is worth at a later date once it has earned interest: present value × (1 + i)^n. ₹1,00,000 at 7 % a year is worth ₹1,40,255 in five years.. Run the other way, a sum due later is worth less today, because a smaller sum put aside now would grow into it. That smaller sum is its present valuepresent value: What a sum due later is worth today at a chosen rate: future value ÷ (1 + i)^n. ₹5,00,000 due in five years is worth ₹3,56,493 today at 7 % a year., and working it out is called discountingdiscounting: Bringing a later sum back to today by dividing by one plus the rate once for each period: the reverse of compounding.. Step forward through five years, then back from a sum due in year 5:

Forward, ₹1,00,000 became ₹1,40,255.17; back, ₹5,00,000 due in year 5 became ₹3,56,493 today. Both moves are one formula, read in two directions:

In words: multiply by one plus the rate once for each period to go forward, divide to come back. The rate i and the count n must use the same period: a monthly rate with months, a yearly rate with years. The program carries ₹1,00,000 forward, brings ₹5,00,000 back and checks the result by carrying it forward again:

"""Future and present values of a single sum.

Future value: FV = PV x (1 + i)^n, a sum today carried forward n periods at rate i.
Present value: PV = FV / (1 + i)^n, a sum due in n periods brought back to today, which is called discounting.
Part 1 carries Rs 1,00,000 forward at 7 % a year; Part 2 asks what Rs 5,00,000 needed in 5 years is worth today;
Part 3 prices Rs 1,00,000 received later at three rates. Every rate is an example. Decimal module, rounded half up.
"""

from decimal import ROUND_HALF_UP, Decimal


def inr(amount, places="1"):
    """Rupees with Indian digit grouping: 140255.17 -> "₹1,40,255"; places="0.01" keeps paise."""
    value = Decimal(amount).quantize(Decimal(places), rounding=ROUND_HALF_UP)
    whole, _, paise = str(abs(value)).partition(".")
    head, tail = whole[:-3], whole[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    text = ",".join(groups + [tail]) if groups else tail
    return "₹" + text + ("." + paise if paise else "")


def years(n):
    return f"{n} year" if n == 1 else f"{n} years"


def fv(pv, i, n):
    return Decimal(pv) * (1 + Decimal(i)) ** n


def pv(fv_, i, n):
    return Decimal(fv_) / (1 + Decimal(i)) ** n


print("Part 1: ₹1,00,000 today, carried forward at 7 % a year")
for n in range(0, 6):
    print(f"  after {years(n)}: {inr(fv(100000, '0.07', n), '0.01')}")

print()
need = 500000
today = pv(need, "0.07", 5)
print(f"Part 2: {inr(need)} needed in 5 years, at 7 % a year, is worth {inr(today)} today.")
print(f"  Check: {inr(today, '0.01')} carried forward 5 years is {inr(fv(today, '0.07', 5), '0.01')}.")

print()
print("Part 3: what ₹1,00,000 received later is worth today")
rates = ("0.04", "0.07", "0.10")
print(f"{'Received in':<13}" + "".join(f"{'at ' + str(int(Decimal(i) * 100)) + ' %':>11}" for i in rates))
for n in (1, 5, 10, 20):
    print(f"{years(n):<13}" + "".join(f"{inr(pv(100000, i, n)):>11}" for i in rates))

Part 1: ₹1,00,000 today, carried forward at 7 % a year
  after 0 years: ₹1,00,000.00
  after 1 year: ₹1,07,000.00
  after 2 years: ₹1,14,490.00
  after 3 years: ₹1,22,504.30
  after 4 years: ₹1,31,079.60
  after 5 years: ₹1,40,255.17

Part 2: ₹5,00,000 needed in 5 years, at 7 % a year, is worth ₹3,56,493 today.
  Check: ₹3,56,493.09 carried forward 5 years is ₹5,00,000.00.

Part 3: what ₹1,00,000 received later is worth today
Received in       at 4 %     at 7 %    at 10 %
1 year           ₹96,154    ₹93,458    ₹90,909
5 years          ₹82,193    ₹71,299    ₹62,092
10 years         ₹67,556    ₹50,835    ₹38,554
20 years         ₹45,639    ₹25,842    ₹14,864

The last table is the one to remember: ₹1,00,000 received in 20 years is worth ₹45,639 today at 4 %, ₹25,842 at 7 % and ₹14,864 at 10 %. The further away a sum is, and the higher the rate, the less it is worth now, which is why a later payment can only be compared with an earlier one once both are carried to the same date.

A series of equal payments is a sum of single sums

An annuityannuity: A series of equal payments at equal intervals, such as loan instalments or SIP instalments. Its value on any date is the sum of each payment's value on that date. is a series of equal payments at equal intervals: an EMI, a SIP instalment, a yearly premium. Its value on any date is the sum of each payment’s single-sum value on that date. When each payment comes at the end of its period, as a loan’s instalments do, it is an ordinary annuityordinary annuity: An annuity whose payments come at the end of each period, as a loan's instalments do, so the last payment earns nothing before the series ends.; when each comes at the start, an annuity dueannuity due: An annuity whose payments come at the start of each period, as SIP instalments usually do. Each payment earns one period more, so it is worth (1 + i) times the ordinary annuity.. Step through ₹10,000 a year for five years at 7 %:

Adding the five single sums gave ₹57,507.39, and moving every payment a year earlier multiplied the total by 1.07. The additions collapse into closed formulas, for payment P, rate i a period and n periods:

In words: the future value is the payment times the growth of all the periods minus one, divided by the rate; the present value is the payment times one minus the discount over all the periods, divided by the rate. For an annuity due, multiply either by (1 + i). The program adds up the single sums one by one and checks every formula against them:

"""A series of equal payments is a sum of single sums: ordinary annuities and annuities due.

Rs 10,000 a year for 5 years at 7 % a year. In an ordinary annuity each payment comes at the END of its year, so the
last one earns nothing; in an annuity due each comes at the START, one year earlier, so every payment earns one year
more. The program adds up the single sums one by one, then checks the closed formulas:
  FV (ordinary) = P x ((1 + i)^n - 1) / i          FV (due) = FV (ordinary) x (1 + i)
  PV (ordinary) = P x (1 - (1 + i)^-n) / i          PV (due) = PV (ordinary) x (1 + i)
Every rate is an example. Decimal module, rounded half up to the paisa.
"""

from decimal import ROUND_HALF_UP, Decimal


def inr(amount):
    """Rupees and paise with Indian digit grouping: 57507.3901 -> "₹57,507.39"."""
    whole, _, paise = str(Decimal(amount).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)).partition(".")
    head, tail = whole[:-3], whole[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    return "₹" + (",".join(groups + [tail]) if groups else tail) + "." + paise


P, I, N = Decimal(10000), Decimal("0.07"), 5

print("Each payment carried forward to the end of year 5")
print(f"{'Payment':<9}{'Ordinary: grows':>17}{'Value':>13}{'Due: grows':>13}{'Value':>13}")
fv_ord = fv_due = Decimal(0)
for k in range(1, N + 1):
    grow_ord = N - k  # paid at the end of year k, so it earns for the years after it
    grow_due = N - k + 1  # paid at the start of year k: one year more
    v_ord = P * (1 + I) ** grow_ord
    v_due = P * (1 + I) ** grow_due
    fv_ord += v_ord
    fv_due += v_due
    print(f"{k:<9}{str(grow_ord) + ' y':>17}{inr(v_ord):>13}{str(grow_due) + ' y':>13}{inr(v_due):>13}")
print(f"{'Total':<26}{inr(fv_ord):>13}{'':>13}{inr(fv_due):>13}")

formula_ord = P * ((1 + I) ** N - 1) / I
pv_ord = P * (1 - (1 + I) ** -N) / I
pv_sum = sum(P / (1 + I) ** k for k in range(1, N + 1))
agree = abs(formula_ord - fv_ord) < Decimal("0.000001") and abs(formula_ord * (1 + I) - fv_due) < Decimal("0.000001")
print()
print(f"Future value by the formulas: ordinary {inr(formula_ord)}, due {inr(formula_ord * (1 + I))} (ordinary × 1.07).")
print(f"The formulas agree with the sums: {'yes' if agree else 'no'}.")
print(f"Present value: ordinary {inr(pv_ord)} (added up: {inr(pv_sum)}), due {inr(pv_ord * (1 + I))}.")

Each payment carried forward to the end of year 5
Payment    Ordinary: grows        Value   Due: grows        Value
1                      4 y   ₹13,107.96          5 y   ₹14,025.52
2                      3 y   ₹12,250.43          4 y   ₹13,107.96
3                      2 y   ₹11,449.00          3 y   ₹12,250.43
4                      1 y   ₹10,700.00          2 y   ₹11,449.00
5                      0 y   ₹10,000.00          1 y   ₹10,700.00
Total                        ₹57,507.39                ₹61,532.91

Future value by the formulas: ordinary ₹57,507.39, due ₹61,532.91 (ordinary × 1.07).
The formulas agree with the sums: yes.
Present value: ordinary ₹41,001.97 (added up: ₹41,001.97), due ₹43,872.11.

The formulas agree with the sums to the paisa: ₹57,507.39 and ₹61,532.91 in year 5, ₹41,001.97 and ₹43,872.11 today. Spreadsheets hold the same two cases in one argument, type: 0 for payments at the end of each period, 1 for the start, as Microsoft’s documentation of FV and PV describes.

The EMI and the SIP are the same annuity, run two ways

A loan is an ordinary annuity seen from the lender’s side. The lender hands over the principal today, and the EMIs, paid at the end of each month, must be worth exactly that principal today. Set the loan equal to the present value of its instalments and solve for the instalment:

In words: the EMI is the principal times the monthly rate times the growth over the term, divided by that growth minus one. A loan of ₹10,00,000 at 9.5 % a year for 60 months, with i = 9.5 % ÷ 12, costs ₹21,001.86 a month. Set the same loan in the model below, then shorten the term or change the rate and watch the instalment and the interest move:

The model rounds the instalment to ₹21,002 and shows that 38 % of the first one is interest; by the last instalment almost all of it repays the loan.

A SIP runs the same annuity forward. Instalments are usually invested at the start of each month, so the corpus is the future value of an annuity due, FV = S × ((1 + i)^n − 1) ÷ i × (1 + i). The program works out both, and repays the loan month by month to show that the EMI clears it exactly:

"""The EMI and the SIP formulas, both from the annuity of equal payments.

EMI: a loan is the present value of its instalments, paid at the end of each month, so
    P = EMI x (1 - (1 + i)^-n) / i,  which gives  EMI = P x i x (1 + i)^n / ((1 + i)^n - 1).
SIP: the corpus is the future value of instalments paid at the start of each month (an annuity due), so
    FV = S x ((1 + i)^n - 1) / i x (1 + i).
The monthly rate i depends on a convention: r / 12, or (1 + r)^(1/12) - 1 when r is an effective yearly rate.
Part 3 solves the same sums with the equation spreadsheet functions use, with their sign convention (money paid
out is negative) and their type argument (0: end of period, 1: start):
    pv x (1 + rate)^nper + pmt x (1 + rate x type) x ((1 + rate)^nper - 1) / rate + fv = 0.
The loan and the 12 % are examples for the arithmetic, not offers or forecasts. Decimal module, half up.
"""

from decimal import ROUND_HALF_UP, Decimal, getcontext

getcontext().prec = 40


def inr(amount, places="1"):
    """Rupees with Indian digit grouping: 4599287.4 -> "₹45,99,287"; places="0.01" keeps paise."""
    value = Decimal(amount).quantize(Decimal(places), rounding=ROUND_HALF_UP)
    whole, _, paise = str(abs(value)).partition(".")
    head, tail = whole[:-3], whole[-3:]
    groups = []
    while len(head) > 2:
        groups.insert(0, head[-2:])
        head = head[:-2]
    if head:
        groups.insert(0, head)
    text = ",".join(groups + [tail]) if groups else tail
    return ("−" if value < 0 else "") + "₹" + text + ("." + paise if paise else "")


def pct(fraction, places="0.01"):
    return f"{(fraction * 100).quantize(Decimal(places), rounding=ROUND_HALF_UP)} %"


# Part 1: the EMI of a loan of Rs 10,00,000 at 9.5 % a year for 60 months, interest monthly at r / 12.
P, R, N = Decimal(1000000), Decimal("0.095"), 60
i = R / 12
emi = P * i * (1 + i) ** N / ((1 + i) ** N - 1)
emi_paise = emi.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
print(f"Part 1: a loan of {inr(P)} at 9.5 % a year for {N} months")
print(f"  EMI = {inr(emi, '0.01')} a month; paid {N} times that is {inr(emi_paise * N, '0.01')}, of which {inr(emi_paise * N - P, '0.01')} is interest.")
balance = P
for month in range(1, N + 1):
    interest = balance * i  # the month's interest on what is still owed
    balance = balance + interest - emi
    if month in (1, 12, 59, 60):
        print(f"  after instalment {month:>2}: interest that month {inr(interest, '0.01')}, still owed {inr(balance, '0.01')}")
check = sum(emi / (1 + i) ** k for k in range(1, N + 1))
print(f"  The 60 instalments, each brought back to today at i = 9.5 % / 12, add up to {inr(check, '0.01')}: the loan.")

# Part 2: Rs 5,000 at the start of every month for 20 years, at an assumed 12 % a year, under two conventions.
S, R2, M = Decimal(5000), Decimal("0.12"), 240
print()
print(f"Part 2: {inr(S)} at the start of every month for 20 years ({inr(S * M)} paid in), assumed 12 % a year")
print(f"  {'Monthly rate':<28}{'Per month':>10}{'A year':>9}{'Start of month':>16}{'End of month':>14}")
results = {}
for name, monthly in (("effective, 1.12^(1/12) − 1", (1 + R2) ** (Decimal(1) / 12) - 1), ("r / 12", R2 / 12)):
    due = S * ((1 + monthly) ** M - 1) / monthly * (1 + monthly)  # annuity due: paid at the start of each month
    ordinary = due / (1 + monthly)  # the same instalments paid at the end of each month
    results[name] = due
    print(f"  {name:<28}{pct(monthly, '0.0001'):>10}{pct((1 + monthly) ** 12 - 1):>9}{inr(due):>16}{inr(ordinary):>14}")
first, second = results.values()
print(f"  The same 12 % gives two corpora {inr(second - first)} apart, because r / 12 compounds to 12.68 % a year.")

# Part 3: the same answers from the spreadsheet functions' equation.


def sheet_fv(rate, nper, pmt, pv=0, type_=0):
    rate, pmt, pv = Decimal(rate), Decimal(pmt), Decimal(pv)
    return -(pv * (1 + rate) ** nper + pmt * (1 + rate * type_) * ((1 + rate) ** nper - 1) / rate)


def sheet_pmt(rate, nper, pv, fv=0, type_=0):
    rate, pv, fv = Decimal(rate), Decimal(pv), Decimal(fv)
    return -(pv * (1 + rate) ** nper + fv) * rate / ((1 + rate * type_) * ((1 + rate) ** nper - 1))


def sheet_pv(rate, nper, pmt, fv=0, type_=0):
    rate, pmt, fv = Decimal(rate), Decimal(pmt), Decimal(fv)
    return -(fv + pmt * (1 + rate * type_) * ((1 + rate) ** nper - 1) / rate) / (1 + rate) ** nper


effective = (1 + R2) ** (Decimal(1) / 12) - 1
print()
print("Part 3: the same sums as spreadsheet functions would solve them (money paid out is negative)")
rows = [
    ("PMT(9.5%/12, 60, 1000000)", sheet_pmt(R / 12, 60, 1000000)),
    ("FV(1%, 240, -5000, 0, 1)", sheet_fv("0.01", 240, -5000, 0, 1)),
    ("FV(1.12^(1/12)-1, 240, -5000, 0, 1)", sheet_fv(effective, 240, -5000, 0, 1)),
    ("PV(7%, 5, 0, 500000)", sheet_pv("0.07", 5, 0, 500000)),
]
for formula, value in rows:
    print(f"  ={formula:<37} {inr(value, '0.01'):>15}")

Part 1: a loan of ₹10,00,000 at 9.5 % a year for 60 months
  EMI = ₹21,001.86 a month; paid 60 times that is ₹12,60,111.60, of which ₹2,60,111.60 is interest.
  after instalment  1: interest that month ₹7,916.67, still owed ₹9,86,914.81
  after instalment 12: interest that month ₹6,730.97, still owed ₹8,35,956.97
  after instalment 59: interest that month ₹328.62, still owed ₹20,836.90
  after instalment 60: interest that month ₹164.96, still owed ₹0.00
  The 60 instalments, each brought back to today at i = 9.5 % / 12, add up to ₹10,00,000.00: the loan.

Part 2: ₹5,000 at the start of every month for 20 years (₹12,00,000 paid in), assumed 12 % a year
  Monthly rate                 Per month   A year  Start of month  End of month
  effective, 1.12^(1/12) − 1    0.9489 %  12.00 %      ₹45,99,287    ₹45,56,055
  r / 12                        1.0000 %  12.68 %      ₹49,95,740    ₹49,46,277
  The same 12 % gives two corpora ₹3,96,453 apart, because r / 12 compounds to 12.68 % a year.

Part 3: the same sums as spreadsheet functions would solve them (money paid out is negative)
  =PMT(9.5%/12, 60, 1000000)                 −₹21,001.86
  =FV(1%, 240, -5000, 0, 1)                ₹49,95,739.60
  =FV(1.12^(1/12)-1, 240, -5000, 0, 1)     ₹45,99,286.78
  =PV(7%, 5, 0, 500000)                    −₹3,56,493.09

The first instalment is ₹7,916.67 of interest and ₹13,085.19 of repayment; the 60th is ₹164.96 of interest and leaves nothing owed. In all the loan costs ₹2,60,111.60 of interest. The second part of the output shows the SIP twice, and that is the next section.

One yearly rate, two monthly rates: say which you used

Every monthly projection needs a monthly rate, and “12 % a year” does not say which one. There are two conventions. Spreadsheet documentation works its examples with the yearly rate divided by 12: Microsoft’s pages on PMT and FV say to use 12%/12 for monthly payments at 12 % a year. MySmartCoPilot’s SIP calculator treats the expected return as an effective annual rateeffective annual rate: What a quoted rate earns in one year once compounding is counted: (1 + rate ÷ m)^m − 1 for m additions a year. 7 % compounded quarterly is 7.1859 % a year. More in “Simple and compound interest, done right”, the way fund returns are reported, and uses (1 + 0.12)^(1/12) − 1 = 0.9489 % a month, so that twelve months multiply to exactly 1.12. One per cent a month compounds to 12.68 % a year, which is the whole gap:

The two corpora are ₹3,96,453 apart on ₹12,00,000 paid in. The model below adds ₹5,000 at the end of each month. With “Interest added” monthly it uses 12 % ÷ 12; switch it to yearly and the same 12 % becomes an effective rate, 0.9489 % a month:

The model shows ₹49,46,277 and ₹45,56,055, the end-of-month values of the program’s two rows: paying at the start of each month adds one more month of growth, 1 % or 0.9489 %, to every instalment. Both conventions are arithmetic done right. What makes a projection wrong is not saying which one it used.

Spreadsheets solve the same equation. Money paid out is entered as a negative number, as Microsoft’s pages on FV and PV say, and the type argument of FV, PV and PMT picks the end (0) or the start (1) of each period. The third part of the program solves the equation the same way, so a spreadsheet given these formulas should show these values:

For payments on uneven dates, the spreadsheet’s XNPV does the present-value sum one dated payment at a time, on a 365-day year; the next lesson finds the rate at which that sum is zero.

Practise: single sums, annuities and conventions

This session mixes single sums, annuities, EMIs, SIPs and conventions, beginning with the concept you have answered least well. Amounts are in whole rupees unless paise are asked for:

Interview questions

Warm-up (fresher): What is the difference between an ordinary annuity and an annuity due?

Both are series of equal payments at equal intervals. In an ordinary annuity each payment comes at the end of its period, as a loan’s EMIs do; in an annuity due it comes at the start, as SIP instalments usually do. Every payment of an annuity due is made one period earlier, so it earns one period more, and the whole annuity is worth (1 + i) times the ordinary one, today or at the end. ₹10,000 a year for five years at 7 % is worth ₹57,507.39 at the end as an ordinary annuity and ₹61,532.91 as an annuity due. In a spreadsheet the difference is the type argument, 0 or 1.

Warm-up (fresher): Why can two SIP calculators show different values for the same inputs?

Because “12 % a year” needs a monthly rate, and there are two conventions. Dividing by 12 gives 1 % a month, which compounds to 12.68 % a year; treating 12 % as an effective rate gives 0.9489 % a month, exactly 12 % a year. For ₹5,000 a month for 20 years, paid at the start of each month, that is ₹49,95,740 against ₹45,99,287, ₹3,96,453 apart. Timing adds a second difference: start-of-month instalments earn one month more than end-of-month ones. Neither calculator is wrong; a projection should state both choices and that the rate is an assumption.

Key takeaways

• A sum moves forward in time by multiplying by (1 + i) each period and back by dividing: ₹5,00,000 in five years is worth ₹3,56,493 today at 7 %.
• An annuity is worth the sum of its payments’ single-sum values; an annuity due, paid at the start of each period, is worth (1 + i) times the ordinary annuity paid at the end.
• The EMI is the payment whose ordinary annuity is worth the loan today, and a SIP’s corpus is the future value of an annuity due: one idea, run two ways.
• “12 % a year” gives ₹49,95,740 or ₹45,99,287 for the same SIP, depending on whether the monthly rate is 12 % ÷ 12 or 1.12^(1/12) − 1, so every projection must say which it used.