Home / Questions / 308568
Accepted
Patricio Moracho
Asked: 2020-11-15 09:28:41 +0800 CST 2020-11-15 09:28:41 +0800 CST

Why in certain programming languages ​​is the first index of data collections 1?

  • 772

In general we are used to seeing that collection type objects, I am talking about lists, arrays, matrices, recordsets, or whatever they are called in any language, are "indexed" starting at position 0. However, in R, for some decision By design, any objects (in fact Rthere are no scalar objects) are "indexed" starting at 1.

> vector <- c(1,2,3)
> vector[1]
[1] 1
> vector[0]
numeric(0)

Historically speaking, what motivated this decision? Does it have any particular advantage over "indexing" starting at 0?

r

1 Answers

  1. Best Answer

    It is on this particular topic that the difference between the concept of "machine-oriented languages" and "human-oriented languages" is very clear. Of course it is somewhat arbitrary, because all languages ​​are oriented to satisfy the need of humans to communicate with machines, however, the decision to start the indexes in 0or in 1, clearly has to do with this. Let's go by parts:

    Why start from 0?

    Undoubtedly, this has a direct relation to how contiguous areas of the physical memory of a machine are accessed, assuming an object of nelements, each one of the same size, access to each portion of memory that each element has to do is done having take into account the initial memory address plus an offset of a pointer in the area and the length of each element in memory, but to access the first, there is no other option than the offset is 0. Assuming we have an array of elements of a fixed 8byte size, which we know start at an absolute position 689000, accessing each element using a base index 0is highly transparent:

    +----------+----------+----------------+----------------------+
| Longitud | Elemento | Desplazamiento | Posición absoluta    |
+----------+----------+----------------+----------------------+
| 8        | 1        | 0              | 689000 + (8 * 0)     |
+----------+----------+----------------+----------------------+
| 8        | 2        | 1              | 689000 + (8 * 1)     |
+----------+----------+----------------+----------------------+
| 8        | n        | n - 1          | 689000 + (8 * n - 1) |
+----------+----------+----------------+----------------------+

    This is the mechanics of most of the current languages, without a doubt the one that popularized this was C, but certainly there were previous languages ​​that used this methodology (Case BCPL ) and those that came after it, reused it, we can see a more complete list here .

    It is clear that this way is comfortable, simple and fast. But not to be confused, the speed does not lie in the speed of execution, the final machine code always accesses memory with the displacement based on 0, the reason for this is rather the product of a historical conjuncture (see Blarg? ), in the first times, where multitasking did not exist, where compilers did not have to reserve memory with malloc()(C was just a letter of the alphabet), the concept of a pointer did not even exist and the computation speeds were not those of today, you had windows time to load/compile/execute very limited, in this context, preventing the compiler from doing indice - 1for each access statement to a array, was a practical and reasonable decision. Summarizing:Compile time Not run time

    And so ...? Why start from 1?

    Certainly in many disciplines of Mathematics, to speak of the first element of a matrix or vector is to speak of element 1, in fact in our real life any first element of something is 1. Hence this abstraction, although it adds computational complexity having to do makes it indice - 1much more natural, particularly for humans who are not necessarily programmers.

    Returning to the case of R, this language is born from an older one called Swhich, in turn, was strongly influenced by the "father" of all languages: FORTAN. And this one in particular, a math-oriented language, just like R(statistics in particular) uses by default 1as the basis for all data collection (actually you can use arbitrary indices as well). The advantage of this is that it is much more transparent to understand and handle arrays, vectors, matrices, etc., for any human in general, and particularly those who come from mathematical disciplines, it does not require any translation in this regard, to when transferring formulas to the language itself.

    Curiosities ofR

    Surprisingly, it is possible to change the way elements are accessed from a 1-based mode to a 0-based one, globally, we can override the select-by-index function:

    index1 <- .Primitive('[')
`[` <- function(v, i) index1(v, i+1)

vector <- c(1,2,3)
vector[0]
[1] 1
vector[2]
[1] 3

    References

    • 22