Row-major array index calculator

The row-major array index calculator converts coordinates in a multidimensional array into the single linear position used by C-style contiguous memory layouts. Provide each dimension from outermost to innermost, the matching zero-based index for every axis, an element size in bytes, and an optional base address. The result shows the stride of every axis, each index contribution, the final element offset, its byte offset, and the resulting byte address. It is useful for checking pointer arithmetic, debugging flattened buffers, and explaining how nested array coordinates map onto memory.

Enter dimensions and indices in matching axis order

List the dimension sizes from the outermost axis to the innermost axis, exactly as they appear in a declaration or shape. For an array shaped as three planes, four rows, and five columns, enter dimensions of 3, 4, and 5. Then provide one zero-based index for each dimension in the same order.

The coordinate for the second plane, third row, and fourth column is therefore 1, 2, and 3. Dimension sizes must be positive integers, while every index must be at least zero and strictly smaller than its corresponding dimension. The calculator rejects mismatched ranks and out-of-bounds coordinates instead of silently producing an address outside the array.

Element size is also required because an element index alone does not identify a byte location. Use the actual storage width of one element, such as four bytes for a typical 32-bit integer or eight bytes for a typical double. If you know where the array begins in memory, provide that nonnegative base address; otherwise leave it at the default of zero and interpret the result as an offset from the array start.

Understand the row-major stride calculation

Row-major ordering stores the last axis contiguously, so moving one position along that axis advances by exactly one element. Its stride is therefore one. The stride of every earlier axis is the product of all dimension sizes to its right.

With dimensions 3 by 4 by 5, the strides are 20, 5, and 1: advancing one plane skips four rows of five elements, advancing one row skips five elements, and advancing one column skips one. The calculator multiplies each index by the stride for its axis and exposes those products as contributions. Adding the contributions produces the zero-based linear index.

For coordinates 1, 2, and 3, the calculation is 1 times 20, plus 2 times 5, plus 3 times 1, giving element index 33. Showing intermediate values makes the result auditable and helps reveal a common mistake: using column-major multipliers or reversing the dimensions. The algorithm performs checked integer arithmetic throughout.

If a product or sum would exceed JavaScript's safe integer range, it returns an input error rather than presenting a rounded memory location as exact.

Turn the element index into a byte address

A linear index counts elements, not bytes. To obtain the byte offset, multiply the linear index by the element size. An element index of 33 with eight-byte elements begins 264 bytes after the start of the array.

The final byte address is that offset added to the supplied base address. If the base address is 4096, the element begins at byte address 4360. The response keeps the linear index, byte offset, base address, and byte address separate so each stage can be compared with source code, a debugger, a binary format specification, or a GPU buffer calculation.

The address is returned as an ordinary decimal integer and is intended for exact arithmetic within the safe integer range; it does not dereference memory or inspect a running process. The calculation assumes a dense contiguous array with no padding between elements or rows. If a library uses pitched rows, explicit leading dimensions, sliced views, or custom strides, its physical layout is not described solely by shape and this calculator should not replace those stride values.