Index notation

From Free net encyclopedia

Index notation is used in mathematics to refer to the elements of matrices or the components of a vector. The formalism of how indices are used varies according to the discipline. In particular, there are different methods for referring to the elements of a list, a vector, or a matrix, depending on whether one is writing a formal mathematical paper for publication, or when one is writing a computer program.

It is quite common in some mathematical proofs to refer to the elements of an array using subscripts, and in some cases superscripts. The use of superscripts is frequently encountered in the theory of general relativity. The following line states in effect that the each of the elements of a vector c are equal to the sum of the elements of vectors a and b

<math>\mathbf{c}_j = \mathbf{a}_j + \mathbf{b}_j</math>

so

<math>\mathbf{c}_0 = \mathbf{a}_0 + \mathbf{b}_0</math>

<math>\mathbf{c}_1 = \mathbf{a}_1 + \mathbf{b}_1</math>

and so on.

See also: Summation convention

---

In several programming languages, index notation is a way of addressing elements of an array. This method is used since it is closest to how it is implemented in assembly language whereby the first element of the address is used as a base and a multiple (the index) of the element size is used to address inside the array.

For example, a block of memory at location 0x3000 is the base address, and if we are storing 4 byte integers, then elements in this block of memory are at memory locations 0x3000, 0x3004, 0x3008, 0x300c, ..., 0x3000 + 4n. In general, the memory location of the ith element with base address b and element size s is b+is.

Contents 1 C implementation details 1.1 Multidimensional arrays 1.2 Example 2 In other languages

C implementation details

In the C programming language, we can write the above as *(base + i) (pointer form) or base[i] (array indexing form), which is exactly equivalent because the C standard defines the array indexing form as a transformation to pointer form. Coincidentally, since pointer addition is commutative, this allows for obscure expressions such as 3[base] which is equivalent to base[3].

Multidimensional arrays

Things become more interesting when we consider arrays with more than one index, for example, a two-dimensional table. We can either do two things:

• make the two-dimensional array one-dimensional
• consider a one-dimensional array of each element in a one-dimensional array

In C, the second approach is used. To represent a two-dimensional array, we consider a one-dimensional array of memory addresses to the start of other one-dimensional arrays. The first index then is used for the first array, to get a memory address of the second array, where we use the second index for the element. For example, if we have an array called table, then, we have two base addresses - the base address of the array, which in C, is just called table (the variable name itself), and the base address of table[i]. To index an element we can use table[i][j] which gets transformed to the pointer form *(*(base + i) + j).

Example

This function multiplies two 3x3 floating point matrices together.

void mult3x3f(float result[][3], const float A[][3], const float B[][3])
{
  int i, j, k;
  for (i = 0; i < 3; ++i) {
    for (j = 0; j < 3; ++j) {
      result[i][j] = 0;
      for (k = 0; k < 3; ++k)
        result[i][j] += A[i][k] * B[k][j];
    }
  }
}

In other languages

In other programming languages such as Pascal, indices may start at 1, so indexing in a block of memory can be changed to fit a start-at-1 addressing scheme by a simple linear transformation - in this scheme, the memory location of the ith element with base address b and element size s is b+(i-1)s.