| 
```
```{code-block} text
:caption: Output[^gfortran-version]
0.225
0.398
```
[^gfortran-version]: Compiled using `GNU Fortran (Ubuntu 11.3.0-1ubuntu1~22.04) 11.3.0` with no flags
Another way to think about this is to say that
the first (leftmost) index ($i$) varies fastest when considering all elements of the array in storage order,
as illustrated [here](https://en.wikipedia.org/wiki/File:Row_and_column_major_order.svg),
so you want that to be the innermost loop.
The last (rightmost) index ($j$ in 2-D), varies slowest, so we want this to be our outermost loop.
```{tip}
Different languages use different storage.
For example, C is row-major, and this is what NumPy uses by default.
Want NumPy arrays to be stored Fortran-style (column-major) instead?
Specify `order='F'` when creating arrays!
```
```{note}
Although Fortran's array *storage* order is column-*major*,
semantically we still refer to the first dimension
(`dim=1` in the above program, first index (`i`) in the `array(i, j)` indexing)
as the row dimension (with index $i$).
```
```{note}
This idea extends to arrays with more than two dimensions.
In general, the loop nesting order for fastest access will be
*last dimension* $\to \ldots \to$ *first dimension*,
as shown [here](https://fortran-lang.org/en/learn/best_practices/multidim_arrays/).
Also, the 1-D slice `arr(:, 1, 1, ..., 1)` is contiguous,
like the column slice `arr(:, 1)` is for 2-D arrays.
```
Some further references:
* The order you loop through multidimensional arrays can have a big impact on speed. Fortran is column-major, meaning consecutive elements of a column are stored next to each other in memory, and you should loop through arrays in this order. pic.twitter.com/oEtrOaMbzC
— FortranTip (@fortrantip) December 26, 2021