Introduction
In PHP, matrices are represented as arrays of arrays (nested arrays). Common arrangement issues include transposing rows and columns, rotating matrices, reshaping flat arrays into 2D grids, and dealing with PHP's associative array behavior where numeric keys may not start at 0. PHP does not have a dedicated matrix type, so operations that are single function calls in NumPy or MATLAB require explicit loops or clever use of array_map, array_column, and array_chunk. Understanding these patterns solves most matrix arrangement issues.
Creating a Matrix in PHP
1// Numeric-indexed 2D array (3x3 matrix)
2$matrix = [
3 [1, 2, 3],
4 [4, 5, 6],
5 [7, 8, 9],
6];
7
8// Access element at row 1, column 2
9echo $matrix[1][2]; // 6
10
11// Create a matrix dynamically
12$rows = 3;
13$cols = 4;
14$matrix = array_fill(0, $rows, array_fill(0, $cols, 0));
15// [[0,0,0,0], [0,0,0,0], [0,0,0,0]]
Transposing a Matrix
1// Transpose: swap rows and columns
2$matrix = [
3 [1, 2, 3],
4 [4, 5, 6],
5];
6// Expected: [[1,4], [2,5], [3,6]]
7
8// Method 1: array_map with spread operator
9$transposed = array_map(null, ...$matrix);
10// [[1,4], [2,5], [3,6]]
11
12// Method 2: Manual loop
13function transpose(array $matrix): array {
14 $result = [];
15 foreach ($matrix as $row => $columns) {
16 foreach ($columns as $col => $value) {
17 $result[$col][$row] = $value;
18 }
19 }
20 return $result;
21}
22
23// Method 3: Using array_column (PHP 7+)
24$transposed = [];
25$colCount = count($matrix[0]);
26for ($i = 0; $i < $colCount; $i++) {
27 $transposed[] = array_column($matrix, $i);
28}
The array_map(null, ...$matrix) trick applies null as the callback across all rows simultaneously, effectively zipping them into columns.
Rotating a Matrix
1// Rotate 90 degrees clockwise
2function rotateClockwise(array $matrix): array {
3 $transposed = array_map(null, ...$matrix);
4 return array_map('array_reverse', $transposed);
5}
6
7// Rotate 90 degrees counter-clockwise
8function rotateCounterClockwise(array $matrix): array {
9 $transposed = array_map(null, ...$matrix);
10 return array_reverse($transposed);
11}
12
13// Rotate 180 degrees
14function rotate180(array $matrix): array {
15 return array_reverse(array_map('array_reverse', $matrix));
16}
17
18$matrix = [[1,2,3], [4,5,6], [7,8,9]];
19
20print_r(rotateClockwise($matrix));
21// [[7,4,1], [8,5,2], [9,6,3]]
22
23print_r(rotateCounterClockwise($matrix));
24// [[3,6,9], [2,5,8], [1,4,7]]
Reshaping Arrays to Matrices
1// Flat array to matrix (reshape)
2$flat = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
3
4// Reshape to 3x4 matrix
5$matrix = array_chunk($flat, 4);
6// [[1,2,3,4], [5,6,7,8], [9,10,11,12]]
7
8// Reshape to 4x3 matrix
9$matrix = array_chunk($flat, 3);
10// [[1,2,3], [4,5,6], [7,8,9], [10,11,12]]
11
12// Flatten a matrix back to 1D
13$flattened = array_merge(...$matrix);
14// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
array_chunk splits a flat array into equal-sized subarrays, effectively creating rows of a matrix. array_merge(...$matrix) flattens it back using the spread operator.
Matrix Multiplication
1function matrixMultiply(array $a, array $b): array {
2 $rowsA = count($a);
3 $colsA = count($a[0]);
4 $colsB = count($b[0]);
5
6 $result = array_fill(0, $rowsA, array_fill(0, $colsB, 0));
7
8 for ($i = 0; $i < $rowsA; $i++) {
9 for ($j = 0; $j < $colsB; $j++) {
10 for ($k = 0; $k < $colsA; $k++) {
11 $result[$i][$j] += $a[$i][$k] * $b[$k][$j];
12 }
13 }
14 }
15 return $result;
16}
17
18$a = [[1, 2], [3, 4]];
19$b = [[5, 6], [7, 8]];
20$result = matrixMultiply($a, $b);
21// [[19, 22], [43, 50]]
Associative Array Key Issues
1// PHP arrays can have non-sequential keys after manipulation
2$matrix = [[1,2,3], [4,5,6], [7,8,9]];
3unset($matrix[1]); // Remove row at index 1
4
5// Keys are now 0, 2 — not 0, 1
6print_r(array_keys($matrix)); // [0, 2]
7
8// Fix: re-index with array_values
9$matrix = array_values($matrix);
10// Keys are now 0, 1
11// [[1,2,3], [7,8,9]]
12
13// Column extraction with non-sequential keys
14$column = array_column($matrix, 0); // Works regardless of row keys
Spiral Matrix Traversal
1function spiralOrder(array $matrix): array {
2 $result = [];
3 $top = 0;
4 $bottom = count($matrix) - 1;
5 $left = 0;
6 $right = count($matrix[0]) - 1;
7
8 while ($top <= $bottom && $left <= $right) {
9 for ($i = $left; $i <= $right; $i++) $result[] = $matrix[$top][$i];
10 $top++;
11 for ($i = $top; $i <= $bottom; $i++) $result[] = $matrix[$i][$right];
12 $right--;
13 if ($top <= $bottom) {
14 for ($i = $right; $i >= $left; $i--) $result[] = $matrix[$bottom][$i];
15 $bottom--;
16 }
17 if ($left <= $right) {
18 for ($i = $bottom; $i >= $top; $i--) $result[] = $matrix[$i][$left];
19 $left++;
20 }
21 }
22 return $result;
23}
24
25$matrix = [[1,2,3], [4,5,6], [7,8,9]];
26print_r(spiralOrder($matrix)); // [1,2,3,6,9,8,7,4,5]
Common Pitfalls
Using array_map(null, ...$matrix) on an empty matrix: Spreading an empty array produces no arguments to array_map, causing a warning. Check if (empty($matrix)) before transposing.
Assuming numeric keys are sequential after array operations: Functions like unset(), array_filter(), and array_splice() can leave gaps in numeric keys. Always use array_values() to re-index after removing rows or filtering.
Modifying a matrix during iteration: foreach ($matrix as &$row) with nested references can cause unexpected behavior due to PHP's reference semantics. Unset the reference variable after the loop: unset($row).
Memory issues with large matrices: PHP arrays have high memory overhead (each element uses approximately 100 bytes due to hash table internals). For large numeric matrices, consider the SplFixedArray class or the ds extension for more memory-efficient storage.
Mixing associative and numeric arrays in a matrix: PHP does not distinguish between associative and numeric arrays. A matrix with string keys (['a' => 1, 'b' => 2] as rows) breaks array_column index lookups and produces unexpected results in array_map(null, ...) transposition.
Summary
Represent matrices as arrays of arrays in PHP — $matrix[$row][$col]
Transpose with array_map(null, ...$matrix) for concise column-row swaps
Use array_chunk() to reshape flat arrays into matrices and array_merge(...) to flatten
Re-index after array operations with array_values() to maintain sequential numeric keys
For rotation, combine transpose with array_reverse (clockwise) or reverse the transposed array (counter-clockwise)
Consider SplFixedArray or external libraries for large numerical matrices to reduce memory overhead
