0.2.4 Case study: net present value from formula to code

A dollar later is worth less than a dollar now

If you can earn 8% a year, $100 today becomes $108 in a year. So $108 promised in a year is worth $100 today. To find today's value of money that arrives later, divide by 1.08 once for each year you wait.

Rule: Present value of one payment

PV = \frac{C_t}{(1 + r)^t}

$C_t$ is a payment at the end of year $t$ , and $r$ is the yearly rate as a decimal (8% is 0.08), compounded once a year. $PV$ is its present value: what it is worth today.

(1.08)^0 = 1

r = 0.08 cf = [-1000, 300, 300, 300, 300] print("year cash flow factor present value") for t in range(len(cf)): factor = 1 / (1 + r) ** t print(f"{t:>4} {cf[t]:>9} {factor:.4f} {cf[t] * factor:>13.2f}")

⌘/Ctrl + Enter runs the cell

Net present value is a sum

The net present value (NPV) adds up the present value of every cash flow, with money paid out counted as negative:

\text{NPV} = \sum_{t=0}^{T} \frac{C_t}{(1 + r)^t}

Read it as in lesson 0.2.1: "NPV is the sum, for $t$ from 0 to $T$ , of the cash flow at time $t$ divided by $1 + r$ to the power $t$ ." Here $T = 4$ and $C_0 = -1000$ is the price. A positive NPV means the cash flows are worth more than they cost.

Each symbol has a direct translation into code:

Maths	Python
$C_t$	`cf[t]`. The list starts at year 0, so there is no shift by one
$t$ from 0 to $T$	`range(len(cf))`
$(1 + r)^t$	`(1 + r) ** t`
$\sum$	a loop, or `sum(...)`, or `np.sum`

-6.36

import numpy as np r = 0.08 cf = [-1000, 300, 300, 300, 300] total = 0 for t in range(len(cf)): total += cf[t] / (1 + r) ** t print(total) print(sum(cf[t] / (1 + r) ** t for t in range(len(cf)))) c = np.array(cf, dtype=float) t = np.arange(len(c)) print(np.sum(c / (1 + r) ** t))

⌘/Ctrl + Enter runs the cell

Check yourself

The cash flows are stored as cf = [-1000, 300, 300, 300, 300], with cf[0] paid today. Which line computes the NPV at rate r?

sum(cf[t] / (1 + r) ** t for t in range(1, len(cf)))sum(cf[t] / (1 + r) ** t for t in range(len(cf)))sum(cf) / (1 + r) ** len(cf)

How the rate changes the answer

At a 0% rate nothing is discounted, so the NPV is the plain total: $-1000 + 4 \times 300 = 200$ . A higher rate shrinks every future payment, so the NPV falls.

= 0

import numpy as np import matplotlib.pyplot as plt cf = np.array([-1000, 300, 300, 300, 300], dtype=float) t = np.arange(len(cf)) def npv(r): return np.sum(cf / (1 + r) ** t) for r in [0.00, 0.04, 0.08, 0.12, 0.16]: print(f"{r:.0%}: {npv(r):8.2f}") rates = np.linspace(0, 0.16, 100) plt.plot(rates * 100, [npv(r) for r in rates]) plt.axhline(0, color="gray", linewidth=0.8) plt.xlabel("rate (%)") plt.ylabel("NPV ($)") plt.show()

⌘/Ctrl + Enter runs the cell

Check yourself

At a 4% rate the machine's NPV is $88.97. What does that tell you?

If money costs 4% a year, the machine is worth buyingThe machine pays back $88.97 in totalThe machine earns exactly 4% a year

Exercise

Net present value

Write npv(rate, cashflows). cashflows[0] happens today, cashflows[1] in one year, and so on. Return $\sum_t C_t / (1 + r)^t$ .

The tests use lists and NumPy arrays, a zero rate, payments in later years, and an empty list. An empty sum is 0, as in lesson 0.2.2.

See the tests

import numpy as np

MACHINE = [-1000, 300, 300, 300, 300]


def test_zero_rate():
    """At a 0% rate nothing is discounted: the machine's NPV is the plain total, 200"""
    expect_close(npv(0.0, MACHINE), 200.0, what="npv(0, [-1000, 300, 300, 300, 300])")


def test_machine():
    """At 8% the machine's NPV is about −6.36"""
    expected = -1000 + 300 / 1.08 + 300 / 1.08**2 + 300 / 1.08**3 + 300 / 1.08**4
    expect_close(npv(0.08, MACHINE), expected, what="npv(0.08, [-1000, 300, 300, 300, 300])")


def test_today_not_discounted():
    """A single cash flow today is worth its face value"""
    expect_close(npv(0.05, [250]), 250.0, what="npv(0.05, [250])")


def test_later_year():
    """121 received in 2 years at 10% is worth 100 today"""
    expect_close(npv(0.10, [0, 0, 121]), 100.0, what="npv(0.10, [0, 0, 121])")


def test_higher_rate_lower_npv():
    """A higher rate gives a lower NPV"""
    low, high = npv(0.04, MACHINE), npv(0.12, MACHINE)
    assert high < low, f"expected npv at 12% ({high}) to be below npv at 4% ({low})"


def test_numpy_input():
    """A NumPy array of cash flows gives the same answer as a list"""
    expect_close(npv(0.08, np.array(MACHINE, dtype=float)), npv(0.08, MACHINE), what="npv with a NumPy array")


def test_empty():
    """No cash flows at all: an empty sum is 0"""
    expect_close(npv(0.08, []), 0.0, what="npv(0.08, [])")

A portfolio's return is a weighted sum

The same $\Sigma$ adds up a portfolio. Put $6,000 in a stock, $3,000 in a bond and $1,000 in cash. Write $V_i$ for the dollars in asset $i$ and $V = \sum_j V_j$ for the total, $10,000. Each asset's weight is its share of the total:

\begin{gathered} w_i = \frac{V_i}{V} \\[6pt] R_p = \sum_{i=1}^{n} w_i R_i \end{gathered}

Here $R_i$ is the return on asset $i$ and $R_p$ is the portfolio's return. The weights always add up to 1: by the constant-multiple rule, $\sum_i V_i / V = \frac{1}{V} \sum_i V_i = 1$ .

R_p = 0.06 + 0.006 + 0 = 6.6\%

import numpy as np values = np.array([6000, 3000, 1000], dtype=float) returns = np.array([0.10, 0.02, 0.00]) w = values / values.sum() print("weights:", w, "sum:", w.sum()) print("portfolio return:", w @ returns) print("from end values: ", (values * (1 + returns)).sum() / values.sum() - 1)

⌘/Ctrl + Enter runs the cell

Lesson 1.4.7 explains why this weighted sum works for simple returns but not for log returns.

Exercise

Portfolio return from dollar holdings

Write portfolio_return(values, returns). values holds the dollars in each asset and returns holds each asset's return over the period. Work out the weights from the values, then return $\sum w_i R_i$ .

The tests pass lists or NumPy arrays. One test doubles every holding: the weights, and so the answer, should not change.

See the tests

import numpy as np


def test_example():
    """$6,000, $3,000 and $1,000 returning 10%, 2% and 0% give 6.6%"""
    expect_close(portfolio_return([6000, 3000, 1000], [0.10, 0.02, 0.00]), 0.066, what="portfolio_return([6000, 3000, 1000], [0.10, 0.02, 0.00])")


def test_equal_holdings():
    """Equal holdings give the plain average of the returns"""
    expect_close(portfolio_return([500, 500], [0.10, 0.30]), 0.20, what="portfolio_return([500, 500], [0.10, 0.30])")


def test_scale_does_not_matter():
    """Doubling every holding leaves the return unchanged"""
    one = portfolio_return(np.array([6000, 3000, 1000]), np.array([0.10, 0.02, 0.00]))
    two = portfolio_return(np.array([12000, 6000, 2000]), np.array([0.10, 0.02, 0.00]))
    expect_close(two, one, what="return with every holding doubled")


def test_single_asset():
    """A portfolio of one asset has that asset's return"""
    expect_close(portfolio_return([2500], [0.07]), 0.07, what="portfolio_return([2500], [0.07])")


def test_losses():
    """$500 losing 20% and $1,500 gaining 4% give −2%"""
    expect_close(portfolio_return([500, 1500], [-0.20, 0.04]), -0.02, what="portfolio_return([500, 1500], [-0.20, 0.04])")

C_t

Case study: net present value from formula to code

A dollar later is worth less than a dollar now

Rule: Present value of one payment

Net present value is a sum

How the rate changes the answer

Net present value

A portfolio's return is a weighted sum

Portfolio return from dollar holdings

Summary card

Free further reading