Memory layout (C-order vs Fortran-order) in NumPy - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of array flattening with different memory orders

What is the output of the following code?

import numpy as np
arr = np.array([[1, 2], [3, 4]])
flat_c = arr.flatten(order='C')
flat_f = arr.flatten(order='F')
print(flat_c)
print(flat_f)

NumPy

import numpy as np
arr = np.array([[1, 2], [3, 4]])
flat_c = arr.flatten(order='C')
flat_f = arr.flatten(order='F')
print(flat_c)
print(flat_f)

A

[1 2 3 4]
[1 3 2 4]

B

[1 3 2 4]
[1 2 3 4]

C

[1 2 3 4]
[4 3 2 1]

D

[4 3 2 1]
[1 2 3 4]

💡 Hint

Remember that C-order flattens row-wise, Fortran-order flattens column-wise.

In C-order, flattening reads rows first: [1, 2, 3, 4]. In Fortran-order, flattening reads columns first: [1, 3, 2, 4].

❓ data_output

intermediate

Shape and strides of arrays with different memory orders

Given the code below, what are the strides of the arrays arr_c and arr_f?

import numpy as np
arr_c = np.array([[1, 2], [3, 4]], order='C')
arr_f = np.array([[1, 2], [3, 4]], order='F')
print(arr_c.strides)
print(arr_f.strides)

NumPy

import numpy as np
arr_c = np.array([[1, 2], [3, 4]], order='C')
arr_f = np.array([[1, 2], [3, 4]], order='F')
print(arr_c.strides)
print(arr_f.strides)

A

(8, 8)
(8, 8)

B

(8, 16)
(16, 8)

C

(16, 16)
(16, 16)

D

(16, 8)
(8, 16)

💡 Hint

Strides show how many bytes to jump to get to the next element in each dimension.

In C-order, the last axis changes fastest, so strides are (row_stride, col_stride) = (16, 8) for int64 (8 bytes per element). In Fortran-order, the first axis changes fastest, so strides are (8, 16).

🔧 Debug

advanced

Why does this reshape cause an error with Fortran order?

Consider the code below. Which option correctly explains why the reshape fails?

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]], order='F')
arr_reshaped = arr.reshape((3, 2), order='C')

NumPy

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]], order='F')
arr_reshaped = arr.reshape((3, 2), order='C')

A Runs successfully and returns a reshaped array with shape (3, 2).

B Raises ValueError because the memory layout order of the original array does not match the reshape order.

C Raises TypeError because reshape does not accept the order parameter.

D Raises IndexError because the new shape is incompatible with the original shape.

💡 Hint

Reshape with order='C' expects the array to be C-contiguous.

The original array is Fortran-contiguous, but reshape with order='C' requires C-contiguous memory. This mismatch causes a ValueError.

🚀 Application

advanced

Choosing memory layout for performance in matrix multiplication

You want to multiply two large matrices using NumPy. Which memory layout choice is generally better for performance and why?

A Use C-order arrays because NumPy's dot product is optimized for row-major contiguous data.

B Use Fortran-order arrays because NumPy's dot product is optimized for column-major contiguous data.

C Memory layout does not affect matrix multiplication performance in NumPy.

D Use a mix of C-order and Fortran-order arrays for best performance.

💡 Hint

Think about how NumPy stores arrays by default and how BLAS libraries expect data.

NumPy stores arrays in C-order by default, and its underlying BLAS libraries are optimized for row-major contiguous data, so using C-order arrays usually gives better performance.

🧠 Conceptual

expert

Effect of memory layout on slicing and views

Which statement about slicing a Fortran-order NumPy array is true?

A Slicing a Fortran-order array along any axis returns a view with contiguous memory in C order.

B Slicing a Fortran-order array always returns a copy, never a view.

C Slicing a Fortran-order array along the first axis returns a view with contiguous memory in Fortran order.

D Slicing a Fortran-order array along the last axis returns a view with contiguous memory in C order.

💡 Hint

Consider how Fortran-order arrays store data column-wise and how slicing affects contiguity.

Fortran-order arrays store data column-wise, so slicing along the first axis (rows) preserves Fortran-contiguous views. Slicing along other axes may break contiguity or return non-contiguous views.

Practice

1. What does C-order memory layout mean in NumPy arrays?

easy

A. Rows are stored one after another in memory.

B. Columns are stored one after another in memory.

C. Data is stored randomly in memory.

D. Memory layout depends on the array shape only.

Solution

1. Step 1: Understand C-order layout

   C-order means the array stores data row by row, so all elements of the first row come first, then the second row, and so on.

2. Step 2: Compare with other layouts

   Fortran-order stores columns one after another, not rows. Random or shape-based storage is incorrect.

3. Final Answer:

   Rows are stored one after another in memory. -> Option A

4. Quick Check:

   C-order = rows stored sequentially [OK]

Hint: C-order means row-wise storage in memory [OK]

Common Mistakes:

• Confusing C-order with Fortran-order
• Thinking memory layout depends only on shape
• Assuming random storage order

2. Which of the following is the correct way to create a NumPy array with Fortran-order memory layout?

easy

A. np.array([[1, 2], [3, 4]], order='C')

B. np.array([[1, 2], [3, 4]], order='F')

C. np.array([[1, 2], [3, 4]], layout='F')

D. np.array([[1, 2], [3, 4]], memory='Fortran')

Solution

1. Step 1: Recall NumPy array creation syntax

   NumPy uses the parameter 'order' to specify memory layout, with 'C' for C-order and 'F' for Fortran-order.

2. Step 2: Identify correct parameter and value

   np.array([[1, 2], [3, 4]], order='F') uses order='F', which is the correct way to request Fortran-order layout.

3. Final Answer:

   np.array([[1, 2], [3, 4]], order='F') -> Option B

4. Quick Check:

   Use order='F' for Fortran-order arrays [OK]

Hint: Use order='F' to create Fortran-order arrays [OK]

Common Mistakes:

• Using wrong parameter name like 'layout' or 'memory'
• Confusing order='C' with Fortran-order
• Omitting the order parameter

3. What will be the output of the following code?

import numpy as np
arr = np.array([[1, 2], [3, 4]], order='F')
print(arr.flags.f_contiguous)

medium

A. True

B. False

C. Raises an error

D. None

Solution

1. Step 1: Understand the array creation

   The array is created with order='F', so it uses Fortran-order memory layout.

2. Step 2: Check the f_contiguous flag

   The f_contiguous flag is True if the array is stored in Fortran-contiguous order, which matches order='F'.

3. Final Answer:

   True -> Option A

4. Quick Check:

   Fortran-order array has f_contiguous = True [OK]

Hint: f_contiguous is True for Fortran-order arrays [OK]

Common Mistakes:

• Confusing f_contiguous with c_contiguous
• Expecting False for order='F'
• Thinking flags attribute raises error

4. The following code is intended to create a Fortran-order array, but it does not. What is the error?

import numpy as np
arr = np.array([[1, 2], [3, 4]])
arr = np.asfortranarray(arr, order='C')

medium

A. np.array must have order='F' to create Fortran array.

B. order='C' forces C-order, not Fortran-order.

C. np.asfortranarray does not accept 'order' parameter.

D. arr is immutable and cannot change order.

Solution

1. Step 1: Understand np.asfortranarray usage

   np.asfortranarray converts an array to Fortran-order. It does not take an 'order' parameter.

2. Step 2: Analyze the incorrect parameter

   Passing order='C' is an unexpected keyword argument, causing a TypeError that prevents creating the Fortran-order array.

3. Final Answer:

   np.asfortranarray does not accept 'order' parameter. -> Option C

4. Quick Check:

   np.asfortranarray rejects 'order' parameter [OK]

Hint: np.asfortranarray does not accept 'order' parameter [OK]

Common Mistakes:

• Assuming np.asfortranarray accepts order parameter
• Thinking order='C' overrides Fortran layout
• Thinking arrays are immutable in this context

5. You have a large 2D NumPy array representing image data. You want to speed up column-wise operations. Which memory layout should you choose and why?

hard

A. C-order, because rows are stored consecutively, speeding up column access.

B. Either layout works the same for column-wise operations.

C. Use random memory layout for better cache usage.

D. Fortran-order, because columns are stored consecutively, speeding up column access.

Solution

1. Step 1: Understand memory layout impact on access

   For column-wise operations, accessing consecutive memory locations improves speed due to cache efficiency.

2. Step 2: Identify layout matching column-wise access

   Fortran-order stores columns consecutively, so column-wise operations are faster with Fortran-order.

3. Step 3: Evaluate other options

   C-order stores rows consecutively, so column access is slower. Random layout is not a valid option.

4. Final Answer:

   Fortran-order, because columns are stored consecutively, speeding up column access. -> Option D

5. Quick Check:

   For column speed, use Fortran-order [OK]

Hint: For column operations, choose Fortran-order layout [OK]

Common Mistakes:

• Choosing C-order for column-wise speed
• Thinking layout does not affect speed
• Believing random layout improves cache