Numpy

Numpy is a Python library for numerical computing. It provides support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays. Numpy is the foundation of many other Python libraries for scientific computing, such as Pandas, Scipy, and Matplotlib.

In this section, we will cover the basics of Numpy, including how to create arrays, perform mathematical operations, and manipulate array data.

Creating Arrays

Array Properties

Indexing and Slicing

Modifying Arrays

Mathematical Operations

Matrix Operations

Aggregation Functions

Reshaping and Stacking

Boolean Masking

Broadcasting

Exercise

Exercise 1

Complete the following tasks using NumPy based on what you’ve learned:

  1. Create a 4x4 NumPy array with random integers between 1 and 100.
  2. Replace all even numbers in the array with -1.
  3. Compute the sum of each row and store it in a new array.
  4. Reshape the original 4x4 array into a 2x8 array.
  5. Find the maximum value in the reshaped array.
import numpy as np

# Step 1: Create a 4x4 array with random integers between 1 and 100
arr = np.random.randint(1, 101, (4, 4))
print("Original Array:\n", arr)

# Step 2: Replace even numbers with -1
arr[arr % 2 == 0] = -1
print("Modified Array:\n", arr)

# Step 3: Compute row-wise sum
row_sums = np.sum(arr, axis=1)
print("Row sums:", row_sums)

# Step 4: Reshape into 2x8
reshaped_arr = arr.reshape(2, 8)
print("Reshaped Array:\n", reshaped_arr)

# Step 5: Find maximum value in reshaped array
max_value = np.max(reshaped_arr)
print("Maximum value:", max_value)

Exercise 2

The Mini Snakes and Ladders game we discussed in the last section can be solved mathematically using a Markov chain. We can setup a transition matrix to represent the probabilities of moving from one state to another. The states are the squares on the board, and the transitions are determined by the roll of a die and the presence of snakes and ladders. The formula to solve the expected number of rolls to finish the game is the sum of the first row of the following matrix \(P\).

\[ P = (I - Q)^{-1}, \]

where \(I\) is the identity matrix and \(Q\) is the transition matrix. Therefore \(P\) is the inverse of \(I - Q\).

In Markov chain theory, \(P\) is called the fundamental matrix. An entry \(P_{ij}\) is the expected number of times the process is in state \(j\) given that it started in state \(i\). Therefore, the sum of the first row of \(P\) represents the expected number of steps before absorption (i.e., end of game), starting from the first state (i.e., the number 0 square.)

Find the expected number of rolls to finish the game using Numpy.

import numpy as np

# Transition matrix
Q = np.array([
    # each row or col corresponds to the
    # a number square on the board (no need for 4, 8 and 9)
    #0,   1,   2,   3,   5,   6,   7
    [0, 1/6, 1/6, 1/6, 1/6, 1/6, 1/6], #0
    [0,   0, 1/6, 1/6, 1/6, 1/6, 2/6], #1
    [0,   0, 1/6, 1/6, 1/6, 1/6, 2/6], #2
    [0,   0, 1/6,   0, 1/6, 1/6, 2/6], #3
    [0,   0, 2/6,   0,   0, 1/6, 2/6], #5
    [0,   0, 2/6,   0,   0, 1/6, 2/6], #6
    [0,   0, 2/6,   0, 1/6, 1/6, 1/6]  #7
])

# Create identity matrix
I = np.eye(7)

# solve for P
P = np.linalg.inv(I - Q)

# Calculate expected number of rolls
expected_rolls = np.sum(P[0, :])

# Print the expected number of rolls
print("Expected number of rolls to finish the game:", expected_rolls)