Array creation - use Technical Quotient

Intrinsic NumPy array creation functions

1. Understand

What is the difference between np.arange(0, 5) and np.linspace(0, 4, 5)?

np.arange needs step, np.linspace specifies end value inclusively.

Incorrect; Both specify end values, but np.linspace includes end value by default.

np.arange uses step size, np.linspace uses count of evenly spaced values.

Correct; np.arange specifies step size, np.linspace specifies total number of values.

np.arange for integers, np.linspace for floats.
np.linspace is faster for generating sequences.

2. Analyze

While generating an array with the command np.arange(2, 3, 0.1) for plotting a graph, you observe the array ends at 2.9 instead of the expected 3.0. What might explain this discrepancy?

np.arange may exclude stop value due to floating-point roundoff error.
The step value of 0.1 is too small for np.arange to handle accurately.
The function incorrectly calculates the number of steps.
np.arange is designed to exclude the stop value in its output.

4. Apply

You need to create a visualization that requires exactly 100 points between 0 and 2*pi inclusive. Which function and parameters should you use?

np.arange(0, 2*np.pi, 0.01)

Incorrect; np.arange(0, 2*np.pi, 0.01) might not produce exactly 100 points due to the nature of floating-point arithmetic and how the step size divides the interval.

np.zeros(100)

Incorrect; np.zeros(100) simply creates an array of 100 zeros, which is not suitable for generating a sequence of points between 0 and 2*pi.

np.arange(0, 2*np.pi, 100)

Incorrect; np.arange(0, 2*np.pi, 100) does not use the third parameter as the number of points but as the step size, making this usage incorrect.

np.linspace(0, 2*np.pi, 100)

Correct; np.linspace(0, 2*np.pi, 100) generates exactly 100 evenly spaced points between 0 and 2*pi, including both endpoints.

5. Understand

What is the difference between np.eye(3) and np.eye(3, 5) in terms of their output arrays?

np.eye(3) creates a 3D array, whereas np.eye(3, 5) creates a 2D array.
np.eye(3) makes square identity matrix; np.eye(3, 5) makes rectangular.

Correct; np.eye(3) results in a 3x3 identity matrix, and np.eye(3, 5) results in a 3x5 matrix with ones on the diagonal and zeros elsewhere.

np.eye(3) creates a matrix filled with zeros, while np.eye(3, 5) creates one with ones.
Both create square matrices, but np.eye(3, 5) has more columns.

Incorrect; np.eye(3, 5) does not create a square matrix but a rectangular one.

6. Understand

How does np.diag behave differently when given a 1D array compared to a 2D array?

It creates a 3D array from both 1D and 2D input arrays.
The function fails when given a 1D array but works with a 2D array.
Given a 1D array, it creates a square 2D array with that array on the diagonal; with a 2D array, it extracts the diagonal elements.

Correct; np.diag with a 1D array creates a 2D diagonal matrix, and with a 2D array, it extracts the diagonal elements into a 1D array.

It returns a 1D array when given a 2D array and a 2D array when given a 1D array, with elements in reverse order.

7. Analyze

In creating a matrix for a linear algebra class project using np.diag([1, 2, 3], 1), the elements 1, 2, 3 end up above the main diagonal. Why is that?

This is a misuse of np.diag; elements should always be on the main diagonal.

Incorrect; using np.diag with a second parameter is valid for creating diagonals above or below the main diagonal.

It indicates the number of elements to skip before starting the diagonal.
The second parameter specifies the diagonal above the main diagonal where elements are placed.

Correct; the second parameter in np.diag specifies the k-th diagonal offset from the main diagonal where the elements are to be placed.

The array is rotated, placing elements above the main diagonal.

9. Apply

How can you create a 2D array with 1, 2, 3 on the diagonal and zeros everywhere else?

np.diag([1, 2, 3])

Correct; np.diag([1, 2, 3]) creates a square 2D array with 1, 2, 3 on the diagonal.

np.eye([1, 2, 3])

Incorrect; np.eye() cannot take a list to generate a diagonal matrix.

np.vander([1, 2, 3])

Incorrect; np.vander([1, 2, 3]) generates a Vandermonde matrix, not a diagonal matrix with zeros elsewhere.

np.array([1, 2, 3])

Incorrect; np.array([1, 2, 3]) creates a 1D array, not a 2D diagonal matrix.

10. Apply

To create a matrix where each column is a decreasing power of [1, 2, 3, 4], ending with the n-1 power, which function and parameters should you use?

np.linspace([1, 2, 3, 4], 4)

Incorrect; np.linspace([1, 2, 3, 4], 4) misuses np.linspace, which generates evenly spaced numbers over a specified interval, not powers of an array.

np.vander([1, 2, 3, 4], 4)

Correct; np.vander([1, 2, 3, 4], 4) creates a Vandermonde matrix with columns as decreasing powers of the input array.

np.eye(4, 3)

Incorrect; np.eye(4, 3) creates an identity matrix, not related to powers of an array.

np.diag([1, 2, 3, 4], -1)

Incorrect; np.diag([1, 2, 3, 4], -1) attempts to use np.diag incorrectly for creating off-diagonal elements.

11. Understand

If np.zeros((3, 4)) creates an array filled with zeros, what would be the shape and content of an array created by np.ones((3, 4))?

A 3D array filled with zeros.
A 3D array filled with ones.
An array of shape (4, 3) filled with zeros.
An array of shape (3, 4) filled with ones.

Correct; np.ones((3, 4)) mirrors np.zeros((3, 4)) in shape but fills the array with ones instead of zeros.

12. Understand

How does setting the seed affect the output of default_rng(42).random((2,3))?

Changes the shape of the output array.
Ensures reproducibility of the random values generated.
Increases the randomness of the values generated.
Decreases the range of random values generated.

13. Analyze

Given an array created with np.zeros((3,3,3)), if you wanted to replace the central sub-array with ones using np.ones(), which indexing operation would correctly accomplish this?

array[:,1,:] = np.ones((3))

array[:,:,1] = np.zeros((3))

array[1,1,1] = np.ones((1))

array[1,:,:] = np.ones((3,3))

Correct; array[1,:,:] targets the central sub-array of a 3x3x3 array, and replacing it with np.ones((3,3)) fills it with ones.

14. Remember

What function creates an array where each dimension varies from 0 to n-1, useful for evaluating multi-dimensional functions?

np.arange(3)

Incorrect; np.arange(3) creates a 1D array from 0 to 2.

np.meshgrid(np.arange(3), np.arange(3))

Incorrect; while np.meshgrid() can be used for similar purposes, np.indices is the direct answer.

np.linspace(0, 2, 3)

Incorrect; np.linspace(0, 2, 3) generates linearly spaced numbers in a specified interval, not indices per dimension.

np.indices((3,3))

Correct; np.indices((3,3)) creates a set of arrays representing indices for each dimension in a (3,3) shape.

15. Apply

You need to create a 4x4 array where all elements are set to a random number between 0 and 1 using the default_rng method. How would you do this?

import numpy as np\narray = np.indices((4,4))

import numpy as np\narray = np.zeros((4,4))

from numpy.random import default_rng\nrng = default_rng(42)\narray = rng.random((4,4))

Correct; uses default_rng().random() to create an array of the specified shape filled with random values.

import numpy as np\narray = np.ones((4,4))

16. Apply

To simulate a digital image of 256x256 pixels with three color channels (RGB), which function and shape would correctly create an array filled with zeros to represent this image?

rng = default_rng(42)\nimage = rng.random((256, 256, 3))

image = np.ones((256, 256, 3))

image = np.zeros((256, 256, 3))

image = np.indices((256, 256, 3))