Dartmouth BASIC array dimensions question

Question

I'm trying to implement the CHANGE command from Dartmouth BASIC v4 and later. It allows you to convert a string into an array of numbers and back again. One key bit of the concept is that the length of the string is put into index zero in the array. So for instance, this code (adapted from the v4 manual page 67):

10 DIM A(50)
20 A$="HELLO"
30 CHANGE A$ TO A
40 FOR I=0 TO A(0)
50 PRINT A(I),
60 NEXT I

Works by looping from 0 to the string length.

But... Dartmouth BASIC also generally starts with array index 1, like most BASICs. So the two attempts to access A(0) and A(I) when I=0 should both give an array-out-of-bounds error. Normally you should have to use OPTION BASE 0 to do this, which this code does not, and I can't find that option in the v4 manual anywhere. Moreover, other examples looping over arrays invariably start at 1, for instance, page 57, while others suggest it starts at 0, like page 21.

All the online emulators emulate earlier versions only, so I have no easy way to test this.

Anyone know what's going on here?

Answer 1

Version 2 of Dartmouth BASIC changed the dimensions of vectors (arrays) from one-based to zero-based. This was kept from there on and inherited by most other BASIC, some later offering an OPTION BASE to select what's preffered.

---

The Dartmouth BASIC V4 describes this (indirect) with the DIM command in section 1.7.8 on p. 37:

1.7.8 DIM

Whenever we want to enter a list or a table with a subscript greater than 10, we must use a DIM statement to inform the computer to save us sufficient room for the list or the table.

Examples:   20 DIM H(35)
           35 DIM Q(5,25)

The first would enable us to enter a list of 35 items (or 36 if we use H(0)), and the latter a table 5 x 25, or by using row 0 and column 0 we get a 6 x 26 table.

Highlighting is mine (*1).

The same way Section 1.4, Lists and Tables (as they call arrays) starting on page 20, implicit talks about elements of numbered as 0..n. For example on p.23 a sample program without using DIM is explained as:

This sample program did not need a dimension statement, since the computer automatically saves enough space to allow all subscripts to run from 0 to 10.

This makes it pretty clear that the default base for indices is zero.

This is further enhanced by the way MATrix operations are described in Section 2.6. On page 54 the V4 manual states:

... However, the user has to be careful to keep (and to understand!) the conventions "built into" the language. We will discuss, below, the individual MAT statements.

The following convention has been adopted for MAT: while every vector has a component 0, and every matrix has a row 0 and a column 0, the MAT instructions ignore these. Thus if in a MAT instruction we have a matrix of dimension M-by-N, the rows are numbered 1, 2,...,M, and the columns 1, 2,...,N.

At that point it might be helpful to keep in mind that the MAT instructions were originally (in V2) a set of external subroutines, following their own logic.

---

This isn't any new behaviour, as V2 states on p.39

BASIC provides that each list has a subscript running from 0 to 10, inclusive. Each subscript in a table may run from 0 to 10. If the user desires to have larger lists or tables, he may use a DIM statement in his program. For example,

        10 DIM A(17)

indicates to the computer that the subscript of the list A runs from 0 to 17, inclusive; ...

---

But... Dartmouth BASIC also generally starts with array index 1,

Only true for the initial Version. Already the second one (CARDBASIC) changed that to zero-based.

like most BASICs.

'most' is quite debatable, as for example all MS default to zero, which is a quite large user base. Same goes for independent microprocessor developments like BBC-BASIC, Sinclair BASIC, Locomotive BASIC (*2) or even way before that for Olivetti P6060 BASIC.

Normally you should have to use OPTION BASE 0 to do this, which this code does not, and I can't find that option in the v4 manual anywhere.

OPTION BASE is a way later addition

Moreover, other examples looping over arrays invariably start at 1, for instance, page 57, while others suggest it starts at 0, like page 21.

Examples are to show some point, the one on p.57 is about MATrix operations, which inherently started at one (*3,4).

All the online emulators emulate earlier versions only, so I have no easy way to test this.

All versions except the initial should have arrays starting at zero. So any emulation of CARDBASIC or later should show exactly this behaviour.

---

*1 - The last part is especially interesting, as they seem to call the 0th element explicit 'row and column' as if they are intended for labling or summation.

*2 - I find int again and again impressive that the English computer industry came up with so many different - and successful - BASIC implementations.

*3 - Since both, zero-based indices and MAT statements, were introduced with CARDBASIC, I can't help to see index 0 for either dimension als intended for label or summation purpose (see *1).

*4 - Beloved Atari-BASIC shows a similar but even more challenging behaviour. Here DIMensioning a numerical arrays have its first element at index 0, but string-"arrays" at 1. So while in Dartmouth V4 the 0th element of a matrix can be addressed, doing so with a string in Atari BASIC will result in a bad subscript :))

Answer 2

In retrospect the answer is "it doesn't matter".

The primary goal of the program is to run known-good programs. As such, we can assume that accesses to A(0) only occur in places where that would be legal.

So it's safe to add a 0th entry to all arrays, as those programs assuming 1-base system would never access it anyway. This will lead to some situations where an illegal access will be allowed, like:

100 INPUT"what index to print";A
110 PRINT B(A)

when the user enters 0, but this seems non-fatal.