Declaring Multidimensional Arrays
Fortran arrays can have up to 15 dimensions (rank), declared with DIMENSION or inline as REAL :: grid(10,20) or REAL :: cube(0:9, 1:20, -5:5). Each dimension can carry its own lower and upper bound, and the total number of elements is the product of the extents of every dimension. This makes Fortran a natural fit for representing matrices, 3-D physical grids, and tensors used in scientific computing without any indirection through pointers.
Cricket analogy: A scorecard grid indexed by (innings, over, ball) is exactly a rank-3 array, letting you look up Kohli's runs in the 14th over of the second innings with three coordinates instead of scanning a flat list.
Memory Layout: Column-Major Order
Fortran stores multidimensional arrays in column-major order: the leftmost (first) subscript varies fastest in memory. For a 2-D array A(3,4), the elements are laid out as A(1,1), A(2,1), A(3,1), A(1,2), A(2,2), ... This is the opposite of C's row-major order, and it matters enormously for performance -- loops should always iterate the leftmost index in the innermost loop to access memory sequentially and get good cache behavior.
Cricket analogy: Stacking a team's scorecards by innings first and over second down a shelf means grabbing every innings-1 card is a quick sequential pull, but jumping across overs first would mean reaching across separate stacks, just like a badly ordered Fortran loop thrashing the cache.
Array Bounds and Indexing
Unlike languages that force zero-based indexing, Fortran lets you declare arbitrary lower bounds per dimension, such as REAL :: temps(1901:2026) for a year-indexed array or REAL :: grid(-50:50, -50:50) for a grid centered on the origin. This eliminates a whole class of off-by-one translation errors when the problem domain already has a natural indexing scheme, since the code can mirror the domain directly instead of subtracting an offset everywhere.
Cricket analogy: A career-runs array indexed temps(1877:2026) by year lets a statistician write temps(2023) directly for Sachin-era comparisons without subtracting 1877 every time, just as a custom-bound Fortran array avoids offset arithmetic.
Allocatable Multidimensional Arrays
When array sizes aren't known at compile time, declare them ALLOCATABLE and size them at run time with ALLOCATE, for example REAL, ALLOCATABLE :: matrix(:,:) followed by ALLOCATE(matrix(n,m)). Modern Fortran also supports automatic reallocation on assignment for allocatable arrays and array-valued intrinsic functions like RESHAPE to build a multidimensional array from a flat list of values in one statement, which is useful when reading data whose dimensions are only known after parsing a file header.
Cricket analogy: A stadium that builds temporary stands sized to the exact expected attendance for a World Cup final, rather than fixed permanent seating, mirrors ALLOCATE(matrix(n,m)) sizing memory to the exact problem at hand.
program grid_demo
implicit none
integer, parameter :: nrows = 4, ncols = 3
real :: grid(nrows, ncols)
real, allocatable :: dynamic_grid(:,:)
integer :: i, j, n, m
! Fill column-major: inner loop over the leftmost (fastest) index
do j = 1, ncols
do i = 1, nrows
grid(i, j) = real(i * 10 + j)
end do
end do
print *, 'grid(3,2) =', grid(3, 2)
! Allocatable array sized at run time
n = 5
m = 5
allocate(dynamic_grid(n, m))
dynamic_grid = 0.0
dynamic_grid(3, 3) = 99.0
print *, 'center element =', dynamic_grid(3, 3)
deallocate(dynamic_grid)
end program grid_demoRule of thumb for performance: in nested loops over a multidimensional Fortran array, the loop over the leftmost subscript should always be the innermost loop. This keeps memory access sequential and dramatically improves cache hit rates on large arrays.
- Fortran arrays support up to 15 dimensions, declared via DIMENSION or inline syntax like REAL :: A(10,20).
- Storage is column-major: the leftmost subscript varies fastest in memory, opposite of C's row-major layout.
- For performance, always make the innermost loop iterate over the leftmost array subscript.
- Custom lower bounds (e.g., A(1901:2026)) let array indices mirror the problem domain directly.
- ALLOCATABLE arrays are sized at run time with ALLOCATE and freed with DEALLOCATE.
- RESHAPE can build a multidimensional array from a flat list of values in one statement.
- Modern Fortran supports automatic reallocation of allocatable arrays on assignment.
Practice what you learned
1. In Fortran, for a 2-D array A(3,4), which storage order is used?
2. Which declaration creates an array with custom, non-default bounds?
3. What is the correct sequence for a run-time sized array?
4. For best cache performance looping over A(nrows, ncols), which loop nesting is correct?
5. What does the RESHAPE intrinsic function do?
Was this page helpful?
You May Also Like
Array Operations and Slicing
Whole-array arithmetic, array sections, and the WHERE/FORALL constructs that let Fortran express vectorized operations without explicit loops.
Intrinsic Functions
The built-in numeric, array, and character functions Fortran provides out of the box, from SQRT and MOD to SUM, MAXVAL, and TRIM.
Formatted I/O
How Fortran's FORMAT edit descriptors give precise, column-aligned control over how numbers and text are printed and read.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics