# Arrays¶

View arrays.chpl on GitHub

This primer is a tutorial on Chapel’s rectangular arrays and domains. Other primers cover Chapel’s associative and sparse arrays, building on concepts introduced here.

Arrays in Chapel are specified using a square-bracketed expression that specifies the array’s index set or domain, followed by the array’s element type. Rectangular arrays are those whose indices are integers or tuples of integers, bounded by a range in each dimension, supporting multidimensional, rectilinear index sets.

## Declaring Arrays¶

Let’s start by declaring an `n`-element array of 64-bit `real` values (where `n` defaults to 5):

```config const n = 5;

var A: [1..n] real;
```

Like other variable types in Chapel, arrays are initialized so that each element stores its default value. So our array of `real` values above will default to an array whose elements each store the value 0.0.

```writeln("Initially, A is: ", A);  // prints 0.0 for each array element
```

Arrays can also be declared using array literals. These are specified by enclosing a comma-separated list of expressions in square brackets. Unless otherwise specified, the domain of the new array variable will be 0-based, and the type of its elements will be that of the expressions if they all have the same type. If they do not, the array’s element type will be a type that can hold all of the values, if the compiler can determine that one exists.

```var A2 = [-1.1, -2.2, -3.3, -4.4, -5.5];

writeln("Initially, A2 is: ", A2);
```

## Basic Array Indexing and Slicing¶

Arrays can be accessed using scalar index values of the appropriate type, using either parentheses or square brackets:

```A[1] = 1.1;
A(2) = 2.2;

writeln("After assigning two elements, A is: ", A);
```

Arrays can also be accessed using ranges to refer to subsets of array elements, or sub-arrays, using a technique called slicing:

```A[2..4] = 3.3;

writeln("After assigning its interior values, A is: ", A);
writeln();
```

As with array indexing, either square brackets or parentheses can be used for array slicing:

```writeln("A(2..4) is: ", A(2..4), "\n");
```

Further information on slicing can be found in the Slices Primer

## Multidimensional Arrays¶

Arrays can be multidimensional as well. For example, the following declaration creates a 2D `n` x `n` array of `real` values.

```var B: [1..n, 1..n] real;

forall (i,j) in {1..n, 1..n} do
B[i,j] = i + j/10.0;

writeln("Initially, B is:\n", B, "\n");
```

## Loops over Arrays¶

An array’s elements can be iterated over using Chapel’s standard loop forms like `for`, `foreach`, or `forall` (see the Loops Primer for details). These cause the index variable to refer to an array element in each iteration. For example, the following loop increments each of `B`’s elements by 1, in parallel:

```forall b in B do
b += 1;

writeln("After incrementing B's elements, B is:\n", B, "\n");
```

## Domains and Domain Queries¶

An array’s index set is referred to as a domain — a first-class language concept that stores the set of indices used to access the array. The arrays `A` and `B` above are respectively declared over the anonymous domains `{1..n}` and `{1..n, 1..n}`, created from the ranges specified within the array type’s square brackets. Array `A2` above will have the implicit domain `{0..4}` to represent the five values in its initializing expression.

An array’s domain can be queried using the `.domain` method, which returns a `const ref` to the domain in question. For example, here’s a loop that iterates over B’s indices in parallel by querying its domain:

```forall (i,j) in B.domain do
B[i,j] -= 1;

writeln("After decrementing B's elements, B is:\n", B, "\n");
```

Domains can also be queried when arrays are passed to routines, as a means of associating a new `const ref` identifier with the domain for the routine’s duration. For example, the following procedure queries the domain of its array argument `X`, naming it `D`:

```proc negateAndPrintArr(ref X: [?D] real) {
writeln("within negateAndPrintArr, D is: ", D, "\n");
forall (i,j) in D do
X[i,j] = -X[i,j];
writeln("after negating X within negateAndPrintArr, X is:\n", X, "\n");
}

negateAndPrintArr(B);
```

Arrays are passed to routines by constant (`const`) by default, which does not allow them to be modified within the routine. The above procedure `negateAndPrintArr()` must use a non-constant reference intent (`ref`) explicitly, so that its modifications of `X` are both allowed and reflected in the actual argument `B`:

```writeln("After calling negateAndPrintArr, B is:\n", B, "\n");
```

Domains can also be declared and named. This has several advantages, including:

• allowing multiple arrays to share a single domain

• associating a logical name with an index set

• amortizing overheads when storing multiple distributed arrays with the same indices

• enabling compiler optimizations.

The following domain declaration defines a 2D rectangular domain called `ProbSpace`, which has the same size, shape, and index set as `B` above.

```const ProbSpace = {1..n, 1..n};
```

Note that we declare the domain as being `const`, indicating that we will never change the set of indices it represents. Besides indicating the programmer’s intent, this can enable key compiler optimizations, and is therefore recommended whenever a domain’s index set is known to be invariant.

We can then use that domain to declare some arrays…

```var C, D, E: [ProbSpace] bool;
```

…and to iterate over their shared index set…

```forall (i,j) in ProbSpace do
C[i,j] = (i+j) % 3 == 0;

writeln("After assigning C, its value is:\n", C, "\n");
```

An array need not be accessed using indices from the domain that was used to declare it. For example, the following loop indexes into `B` using indices from `ProbSpace` even though there is no direct relationship between `B` and `ProbSpace`.

```for (i,j) in ProbSpace do
B[i,j] = i + j/10.0;

writeln("B has been re-assigned to:\n", B, "\n");
```

When iterating over a multidimensional domain, the indices can be expressed using a single tuple variable rather than destructuring the tuple into its integer components. Similarly, multidimensional array accesses can be written using tuple indices rather than multiple integer arguments. In the following example, the index variable `ij` stores a 2-tuple of integers (`2*int` or ```(int, int)```). Note the use of tuple indexing to access the individual components of the 2-tuple `ij`.

```for ij in ProbSpace do
D[ij] = ij(0) == ij(1);

writeln("After assigning D, its value is:\n", D, "\n");
```

For further information on domains, see the Domain Primer.

## Whole-Array Assignment¶

Arrays of similar size and shape support whole-array assignment.

```E = C;

writeln("After assigning C to E, E's value is:\n", E, "\n");
```

Whole-array assignment also permits a scalar value that is compatible with the array’s element type to be assigned to each element of the array:

```E = true;

writeln("After being assigned 'true', E is:\n", E, "\n");
```

Whole-array assignment can also be used for arrays or sub-arrays whose index sets differ as long as they have the same number of dimensions and the same shape (number of elements per dimension).

```var F, G: [ProbSpace] real;

F[2..n-1, 2..n-1] = B[1..n-2, 3..n];

writeln("After assigning a slice of B to a slice of F, F's value is:\n", F, "\n");
```

## More on Slicing¶

Arrays can also be sliced using unbounded ranges in which either the low and/or high bounds are omitted. In this case, the missing bounds are defined by the array’s bounds. For example, the following statement assigns all rows of `G` starting from row 2 using all rows of `B` up to number `n-1`. It assigns all columns since no bounds are provided in the second dimension.

```G[2.., ..] = B[..n-1, ..];

writeln("After assigning a slice of B to G, G's value is:\n", G, "\n");
```

Array slicing supports rank-change semantics when sliced using a scalar value rather than a range. In the following assignment, recall that `A` was our initial 1-dimensional array. The slice of `B` takes all columns of row `n/2`, treating it as a 1D array.

```A = B[n/2, ..];

writeln("After being assigned a slice of B, A is:\n", A, "\n");
```

Domains can also be sliced. However, rather than having indexing semantics, domain slicing computes the intersection between the domain’s index set and the specified slice. Like array indexing and slicing, domain slicing can be written with either square brackets or parentheses.

```writeln("ProbSpace[1..n-2, 3..] is: ", ProbSpace[1..n-2, 3..], "\n");
```

Domain variables and expressions can also be used to specify an array slice rather than using lists of ranges. For example:

```const ProbSpaceSlice = ProbSpace[0..n+1, 3..];

writeln("B[ProbSpaceSlice] is:\n", B[ProbSpaceSlice], "\n");
```

## Resizing Arrays¶

Another advantage to declaring named domain variables is that their index sets can be reassigned. This results in a logical re-allocation of all arrays declared over that domain, preserving the array values for any indices that are preserved by the new domain’s value:

```var VarDom = {1..n};

var VarArr: [VarDom] real = [i in VarDom] i;

writeln("Initially, VarArr = ", VarArr, "\n");
```

Now, if we reassign `VarDom`, `VarArr` will be reallocated with the old values preserved and the new values initialized to the element type’s default value.

```VarDom = {1..2*n};

writeln("After doubling VarDom, VarArr = ", VarArr, "\n");
```

As mentioned, this reallocation preserves values according to index, so if we extend the lower bound of the domain, the non-zero values will still logically be associated with indices `1..n`:

```VarDom = {-n+1..2*n};

writeln("After lowering VarDom's lower bound, VarArr = ", VarArr, "\n");
```

If the domain shrinks, values will be thrown away

```VarDom = {2..n-1};

writeln("After shrinking VarDom, VarArr = ", VarArr, "\n");
```

One trick to reallocate an array without preserving any values is to assign its domain variable a degenerate domain (e.g. `{1..0}`) and then assign it the new value:

```VarDom = {1..0};  // empty the array such that no values need to be preserved

writeln("VarArr is now empty: ", VarArr, "\n");

VarDom = {1..n};  // re-assign the domain to establish the new indices

writeln("VarArr should now be reset: ", VarArr, "\n");
```

Note that querying an array’s domain via the `.domain` method or the function argument query syntax does not result in a domain that can be reassigned since those forms return a `const ref`. In particular, we cannot do:

`B.domain = {1..2*n, 1..2*n};`

nor:

`proc foo(X: [?D]) {  D = {1..2*n};  }`

Instead, to resize such arrays, their domains would need to be named variables, and would need to be passed by `ref` to any subroutines wanting to resize the arrays.

An implication of this is that arrays declared using an anonymous domain cannot be reallocated. So for our original array declarations `A` and `B`, we have no way of reallocating them. Arrays with constant domains provide the compiler with optimization benefits, so this design supports a common case efficiently.

## Array Fields / Storing Arrays in Objects¶

A record with an array field whose size is not known until initialization time can be declared as follows:

```record wrapFixedArr {
const size: int;
var Arr: [1..size] real;
}

var RSmall = new wrapFixedArr(size=10);
var RLarge = new wrapFixedArr(size=1000);

writeln("Size of RSmall's FieldArr: ", RSmall.Arr.size);
writeln("Size of RLarge's FieldArr: ", RLarge.Arr.size);
```

Note that such a record does not support resizing the array since its domain is not a named variable. However, we could create such a record as follows:

```record wrapDynArr {
var Inds = {1..0};
var Arr: [Inds] real;
}

var r: wrapDynArr;

writeln("Initial size of r: ", r.Arr.size);

r.Inds = {1..100};

writeln("New size of r: ", r.Arr.size);
```

Either of these approaches can be used to create records (or classes) with array fields where each instance of the type has a different array size.

Further information on records can be found in the Records Primer

## Arrays of Arrays¶

Arrays in Chapel can have arbitrary element types, such as numeric values, classes, or records. Arrays can also have array elements, and initial support for this is implemented in our compiler. For example:

```var Y: [ProbSpace] [1..3] real;

forall (i,j) in ProbSpace do
for k in 1..3 do
Y[i,j][k] = i*10 + j + k/10.0;

writeln("Y is:\n", Y);
```

In such array-of-array cases, our current implementation requires that the array elements all have the same index set. In the future, we expect to support skyline/jagged arrays, in which the inner array sizes can be a function of their indices. In particular, it is our intention to support arrays like these:

```var Triangle: [row in 1..n] [1..row] real;
var HierArr: [lvl in 1..n] [1..2**lvl, 1..2**lvl] real;
```

For the time being, such cases must be implemented by wrapping the array elements in records, as shown above.