It does so through something called **just in time (JIT) compilation**,

which can generate extremely fast and efficient code.

Please also make sure that you have the latest version of Anaconda, since old

Let's start with some imports:

Vectorization involves sending array processing

operations in batch to efficient low-level code.

One is that it is highly memory-intensive when working with large amounts of data.

It does this by inferring type information on the fly.

The basic idea is this:

In practice this would typically be done using an alternative *decorator* syntax.

Let's see how this is done.

functions.

To give one example, let's consider the class for analyzing the Solow growth model we

To compile this class we use the `@jitclass` decorator:

As was the case with Numba, a key problem is the fact that Python is dynamically typed.

Monte Carlo.

Use the same idea here, but make the code efficient using Numba.

What's happened is that we have changed `a` by changing `b`.

The name `b` is bound to `a` and becomes just another reference to the

Hence, it has equal rights to make changes to that array.

Much of this functionality is also available in [SciPy](http://www.scipy.org/), a collection of modules that are built on top of NumPy.

For a comprehensive list of what's available in NumPy see [this documentation](https://docs.scipy.org/doc/numpy/reference/routines.html).

Now write a new function that does the same job, but uses NumPy arrays and array operations for its computations, rather than any form of Python loop.

Your task is to

```{code-block} python3

```{code-block} python3

Over the last few years, NumPy has managed to push this kind of multithreading

out to more and more operations.

```{code-block} python3

thing with Numba.

In fact there is an easy way to do this, since Numba can also be used to

```{code-block} python3

effort to compute the constant $\pi$ by Monte Carlo.

Now try adding parallelization and see if you get further speed gains.

Now let's look more closely at how it all works, focusing in Python's implementation of the `for` loop.

For example, file objects are iterators .

which is written to the present working directory in the following cell

```{code-block} ipython

Deeper concepts will be covered in later lectures.

The first two lines of the program import functionality from external code

libraries.

* working with arrays (vectors and matrices)

* common mathematical functions like `cos` and `sqrt`

The programs below are less efficient than the original one, and hence

somewhat artificial.

```{code-block} python3

The `for` loop is the most common technique for iteration in Python.

```{code-block} python3

Python has several basic types for storing collections of (possibly heterogeneous) data.

Tuple unpacking is convenient and we'll use it often.

In particular

* Any object can be passed to a function as an argument, including other functions.

* A function can return any kind of object, including functions.

a function.

Note that a function can have arbitrarily many `return` statements (including zero).

```{code-block} python3

Try to use `enumerate()` in your loop.

The objectives of this lecture are

An example is a Python list, which not only stores data but also knows how to sort itself, etc.

In this section, we look at some more formal details related to classes and `self`

* You can return to these details after you've familiarized yourself with more examples.

Methods actually live inside a class object formed when the interpreter reads

* $n$ is the population growth rate

* $\delta$ is the depreciation rate

Here's a class that implements this model.

Some points of interest in the code are

* Notice how inside `update` the reference to the local method `h` is `self.h`.

The methods `steady_state` and `generate_sequence` are fairly self-explanatory

The vertical axis is the state space $[0, 1]$.

This exercise is an extension, where the task is to build a simple class called `Polynomial` for representing and manipulating polynomial functions such as

Provide methods that

1. Differentiate the polynomial, replacing the original coefficients with those of its derivative $p'$.

Avoid using any `import` statements.