- 15.1.1 Array Elements
- 15.1.1.1 Array Indices
- 15.1.1.2 Array Dimensions
- 15.1.1.2.1 Implementation Limits on Individual Array Dimensions
- 15.1.1.3 Array Rank
- 15.1.1.3.1 Vectors
- 15.1.1.3.1.1 Fill Pointers
- 15.1.1.3.2 Multidimensional Arrays
- 15.1.1.3.2.1 Storage Layout for Multidimensional Arrays
- 15.1.1.3.2.2 Implementation Limits on Array Rank
- 15.1.2 Specialized Arrays
- 15.1.2.1 Array Upgrading
- 15.1.2.2 Required Kinds of Specialized Arrays

An *array* contains a set of *objects* called *elements* that can be referenced individually according to a rectilinear coordinate system.

An *array* *element* is referred to by a (possibly empty) series of indices. The length of the series must equal the *rank* of the *array*. Each index must be a non-negative *fixnum* less than the corresponding *array* *dimension*. *Array* indexing is zero-origin.

An axis of an *array* is called a dimension.

Each *dimension* is a non-negative *fixnum*; if any dimension of an *array* is zero, the *array* has no elements. It is permissible for a *dimension* to be zero, in which case the *array* has no elements, and any attempt to *access* an *element* is an error. However, other properties of the *array*, such as the *dimensions* themselves, may be used.

An *implementation* may impose a limit on *dimensions* of an *array*, but there is a minimum requirement on that limit. See the *variable* **array-dimension-limit**.

An *array* can have any number of *dimensions* (including zero). The number of *dimensions* is called the rank.

If the rank of an *array* is zero then the *array* is said to have no *dimensions*, and the product of the dimensions (see **array-total-size**) is then 1; a zero-rank *array* therefore has a single element.

An *array* of *rank* one (* i.e.*, a one-dimensional

A fill pointer is a non-negative *integer* no larger than the total number of *elements* in a *vector*. Not all *vectors* have *fill pointers*. See the *functions* **make-array** and **adjust-array**.

An *element* of a *vector* is said to be active if it has an index that is greater than or equal to zero, but less than the *fill pointer* (if any). For an *array* that has no *fill pointer*, all *elements* are considered *active*.

Only *vectors* may have *fill pointers*; multidimensional *arrays* may not. A multidimensional *array* that is displaced to a *vector* that has a *fill pointer* can be created.

Multidimensional *arrays* store their components in row-major order; that is, internally a multidimensional *array* is stored as a one-dimensional *array*, with the multidimensional index sets ordered lexicographically, last index varying fastest.

An *implementation* may impose a limit on the *rank* of an *array*, but there is a minimum requirement on that limit. See the *variable* **array-rank-limit**.

An *array* can be a *general* *array*, meaning each *element* may be any *object*, or it may be a *specialized* *array*, meaning that each *element* must be of a restricted *type*.

The phrasing “an *array* *specialized* to *type* ” is sometimes used to emphasize the *element type* of an *array*. This phrasing is tolerated even when the is **t**, even though an *array* *specialized* to *type* *t* is a *general* *array*, not a *specialized* *array*.

Figure 15–1 lists some *defined names* that are applicable to *array* creation, *access*, and information operations.

The upgraded array element type of a *type* *T*_{1} is a *type* *T*_{2} that is a *supertype* of *T*_{1} and that is used instead of *T*_{1} whenever *T*_{1} is used as an *array element type* for object creation or type discrimination.

During creation of an *array*, the *element type* that was requested is called the expressed array element type. The *upgraded array element type* of the *expressed array element type* becomes the actual array element type of the *array* that is created.

*Type* *upgrading* implies a movement upwards in the type hierarchy lattice. A *type* is always a *subtype* of its *upgraded array element type*. Also, if a *type* *T*_{x} is a *subtype* of another *type* *T*_{y}, then the *upgraded array element type* of *T*_{x} must be a *subtype* of the *upgraded array element type* of *T*_{y}. Two *disjoint* *types* can be *upgraded* to the same *type*.

The *upgraded array element type* *T*_{2} of a *type* *T*_{1} is a function only of *T*_{1} itself; that is, it is independent of any other property of the *array* for which *T*_{2} will be used, such as *rank*, *adjustability*, *fill pointers*, or displacement. The *function* **upgraded-array-element-type** can be used by *conforming programs* to predict how the *implementation* will *upgrade* a given *type*.

*Vectors* whose *elements* are restricted to *type* **character** or a *subtype* of **character** are called strings. *Strings* are of *type* **string**. Figure 15–2 lists some *defined names* related to *strings*.

*Strings* are *specialized* *arrays* and might logically have been included in this chapter. However, for purposes of readability most information about *strings* does not appear in this chapter; see instead Chapter 16 (Strings).

*Vectors* whose *elements* are restricted to *type* **bit** are called bit vectors. *Bit vectors* are of *type* **bit-vector**. Figure 15–3 lists some *defined names* for operations on *bit arrays*.