§2024-12-04

First, let's recall that we are working with a 3D array, which has dimensions defined by dim(my_array). Suppose we have the following 3D array:

Create a 3x3x3 array

my_array <- array(1:27, dim = c(3, 3, 3))

This array will have the following shape:

3 rows
3 columns
3 layers

If we flatten this array into a single vector (ignoring its 3D structure), it will look like this:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]

This is essentially the 3D array reshaped into a 1D vector.

Using arrayInd()

The arrayInd() function helps you retrieve the multi-dimensional indices (row, column, layer, etc.) for a given position (i.e., the index in a flattened version of the array).

Syntax:

arrayInd(flat_index, dim)

flat_index is the index in the flattened array (1-based index).
dim is the dimension of the array (e.g., dim(my_array)).

Example:

Let's calculate the multi-dimensional indices for the 10th element of the flattened array.

Get the multi-dimensional indices for the 10th element

- arrayInd(10, dim(my_array))

Now, let's go through the calculation manually.

Step 1: Flattening the Array

The array is 3x3x3. To find the 10th element, we treat it as a flattened vector:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]

In this vector, the 10th element is 10.

Step 2: Converting the Flat Index to Multi-Dimensional Indices

To find the multi-dimensional index (row, column, layer) for the 10th element:

Dimension Sizes: The array has dimensions 3x3x3, i.e., 3 rows, 3 columns, and 3 layers.

Calculate Indices:
    The 10th element is at index 10 in the flattened array.
    We need to map this index back to the 3-dimensional array structure.

The formula for converting the flattened index to multi-dimensional indices is based on the array’s layout in memory (column-major order in R):
    The first index (row) corresponds to how the array is split by its first dimension.
    The second index (column) corresponds to how the array is split by its second dimension.
    The third index (layer) corresponds to how the array is split by its third dimension.

Conversion Process for Index 10:

To derive the multi-dimensional indices for index 10:

Calculate the layer (3rd dimension):
    
    - Total number of elements per layer = 3 * 3 = 9 (3 rows * 3 columns).
    - Layer = floor((10 - 1) / 9) + 1 = floor(9 / 9) + 1 = 1 + 1 = 2nd layer.

Calculate the column (2nd dimension) in the second layer:
    The remaining elements after layer calculation are 10 - 9 = 1 (we are looking at the 1st element in the 2nd layer).
    Column = 1 (because it's the first element of the second layer).

Calculate the row (1st dimension):
    Row = 1 (since we’re looking at the 1st element in this layer).

Thus, the 10th element corresponds to row 1, column 1, and layer 2.

Step 3: Verifying with arrayInd()

Now, you can verify this using the arrayInd() function:

arrayInd(10, dim(my_array))

The result will be:

 [,1] [,2] [,3]

[1,] 1 1 2

This corresponds to:

Row 1
Column 1
Layer 2

Summary:

The arrayInd() function converts a flat index (1D position) to multi-dimensional indices (2D or 3D positions).
In this case, for the 10th element, the function returns row 1, column 1, and layer 2.

Let me know if you need further clarification!