```
In [1]:
```# Configure Jupyter so figures appear in the notebook
%matplotlib inline
# Configure Jupyter to display the assigned value after an assignment
%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'
# import functions from the modsim.py module
from modsim import *
from pandas import read_html

```
In [2]:
```filename = 'data/World_population_estimates.html'
tables = read_html(filename, header=0, index_col=0, decimal='M')
table2 = tables[2]
table2.columns = ['census', 'prb', 'un', 'maddison',
'hyde', 'tanton', 'biraben', 'mj',
'thomlinson', 'durand', 'clark']

```
In [3]:
```un = table2.un / 1e9
un.head()

```
In [4]:
```census = table2.census / 1e9
census.head()

```
In [5]:
```def plot_results(census, un, timeseries, title):
"""Plot the estimates and the model.
census: TimeSeries of population estimates
un: TimeSeries of population estimates
timeseries: TimeSeries of simulation results
title: string
"""
plot(census, ':', label='US Census')
plot(un, '--', label='UN DESA')
plot(timeseries, color='gray', label='model')
decorate(xlabel='Year',
ylabel='World population (billion)',
title=title)

```
In [6]:
```def run_simulation(system, update_func):
"""Simulate the system using any update function.
system: System object
update_func: function that computes the population next year
returns: TimeSeries
"""
results = TimeSeries()
results[system.t_0] = system.p_0
for t in linrange(system.t_0, system.t_end):
results[t+1] = update_func(results[t], t, system)
return results

Here's the implementation of the quadratic growth model.

```
In [7]:
```def update_func_quad(pop, t, system):
"""Compute the population next year with a quadratic model.
pop: current population
t: current year
system: system object containing parameters of the model
returns: population next year
"""
net_growth = system.alpha * pop + system.beta * pop**2
return pop + net_growth

Here's a `System`

object with the parameters `alpha`

and `beta`

:

```
In [8]:
```t_0 = get_first_label(census)
t_end = get_last_label(census)
p_0 = census[t_0]
system = System(t_0=t_0,
t_end=t_end,
p_0=p_0,
alpha=0.025,
beta=-0.0018)

And here are the results.

```
In [9]:
```results = run_simulation(system, update_func_quad)
plot_results(census, un, results, 'Quadratic model')
savefig('figs/chap07-fig01.pdf')

**Exercise:** Can you find values for the parameters that make the model fit better?

```
In [10]:
```pop_array = linspace(0, 15, 100)
net_growth_array = system.alpha * pop_array + system.beta * pop_array**2
None

Here's what it looks like.

```
In [11]:
```sns.set_style('whitegrid')
plot(pop_array, net_growth_array)
decorate(xlabel='Population (billions)',
ylabel='Net growth (billions)')
sns.set_style('white')
savefig('figs/chap07-fig02.pdf')

Here's what it looks like. Remember that the x axis is population now, not time.

It looks like the growth rate passes through 0 when the population is a little less than 14 billion.

In the book we found that the net growth is 0 when the population is $-\alpha/\beta$:

```
In [12]:
```-system.alpha / system.beta

This is the equilibrium the population tends toward.

`sns`

is a library called Seaborn which provides functions that control the appearance of plots. In this case I want a grid to make it easier to estimate the population where the growth rate crosses through 0.

When people first learn about functions, there are a few things they often find confusing. In this section I present and explain some common problems with functions.

As an example, suppose you want a function that takes a `System`

object, with variables `alpha`

and `beta`

, as a parameter and computes the carrying capacity, `-alpha/beta`

. Here's a good solution:

```
In [13]:
```def carrying_capacity(system):
K = -system.alpha / system.beta
return K
sys1 = System(alpha=0.025, beta=-0.0018)
pop = carrying_capacity(sys1)
print(pop)

Now let's see all the ways that can go wrong.

**Dysfunction #1:** Not using parameters. In the following version, the function doesn't take any parameters; when `sys1`

appears inside the function, it refers to the object we created outside the function.

```
In [14]:
```def carrying_capacity():
K = -sys1.alpha / sys1.beta
return K
sys1 = System(alpha=0.025, beta=-0.0018)
pop = carrying_capacity()
print(pop)

This version actually works, but it is not as versatile as it could be. If there are several `System`

objects, this function can only work with one of them, and only if it is named `system`

.

**Dysfunction #2:** Clobbering the parameters. When people first learn about parameters, they often write functions like this:

```
In [15]:
```def carrying_capacity(system):
system = System(alpha=0.025, beta=-0.0018)
K = -system.alpha / system.beta
return K
sys1 = System(alpha=0.025, beta=-0.0018)
pop = carrying_capacity(sys1)
print(pop)

In this example, we have a `System`

object named `sys1`

that gets passed as an argument to `carrying_capacity`

. But when the function runs, it ignores the argument and immediately replaces it with a new `System`

object. As a result, this function always returns the same value, no matter what argument is passed.

When you write a function, you generally don't know what the values of the parameters will be. Your job is to write a function that works for any valid values. If you assign your own values to the parameters, you defeat the whole purpose of functions.

**Dysfunction #3:** No return value. Here's a version that computes the value of `K`

but doesn't return it.

```
In [16]:
```def carrying_capacity(system):
K = -system.alpha / system.beta
sys1 = System(alpha=0.025, beta=-0.0018)
pop = carrying_capacity(sys1)
print(pop)

A function that doesn't have a return statement always returns a special value called `None`

, so in this example the value of `pop`

is `None`

. If you are debugging a program and find that the value of a variable is `None`

when it shouldn't be, a function without a return statement is a likely cause.

**Dysfunction #4:** Ignoring the return value. Finally, here's a version where the function is correct, but the way it's used is not.

```
In [17]:
```def carrying_capacity(system):
K = -system.alpha / system.beta
return K
sys2 = System(alpha=0.025, beta=-0.0018)
carrying_capacity(sys2)
# print(K) This line won't work because K only exists inside the function.

In this example, `carrying_capacity`

runs and returns `K`

, but the return value is dropped.

When you call a function that returns a value, you should do something with the result. Often you assign it to a variable, as in the previous examples, but you can also use it as part of an expression.

For example, you could eliminate the temporary variable `pop`

like this:

```
In [18]:
```print(carrying_capacity(sys1))

Or if you had more than one system, you could compute the total carrying capacity like this:

```
In [19]:
```total = carrying_capacity(sys1) + carrying_capacity(sys2)
total

**Exercise:** In the book, I present a different way to parameterize the quadratic model:

$ \Delta p = r p (1 - p / K) $

where $r=\alpha$ and $K=-\alpha/\beta$. Write a version of `update_func`

that implements this version of the model. Test it by computing the values of `r`

and `K`

that correspond to `alpha=0.025, beta=-0.0018`

, and confirm that you get the same results.

```
In [20]:
``````
# Solution goes here
```

```
In [21]:
``````
# Solution goes here
```

```
In [22]:
``````
# Solution goes here
```

```
In [ ]:
```