# Array Indexing¶

We’ve seen many examples in this chapter showing how arrays are indexed. So it might not seem necessary to have a section devoted to discussing how to index arrays. It is true that normally you would simply reference elements in an array using integer values for each subscript. But there are enough other ways to index arrays that it is worth spending some time to talk about them.

## Indices¶

### Integers¶

1-index

For array dimensions specified using integers, Modelica uses
indices starting with **1**. Some languages choose to use zero as
the starting index, but it is important to point out from the start
that Modelica follows the 1-index convention.

Obviously, the most directly way to index an array is to use an integer. For an array declared as:

```
Real x[5,4];
```

we can index elements of the array by providing an integer between 1 and 5 for the first subscript and 1 and 4 for the second subscript.

But it is worth pointing out that Modelica allows the subscripts to be vectors. To understand how vector indices work, first consider the following matrix:

In Modelica, such an array would be declared as follows:

```
parameter Real B[3,3] = [1, 2, 3; 4, 5, 6; 7, 8, 9];
```

Imagine we wish to extract a submatrix of `B`

as follows:

```
parameter Real C[2,2] = [B[1,1], B[1,2]; B[2,1], B[2,2]]; // [1, 2; 4, 5];
```

We could extract the same submatrix more easily using vector subscripts as follows:

```
parameter Real C[2,2] = B[{1,2},{1,2}]; // [1, 2; 4, 5];
```

By using vector subscripts we can extract or construct arbitrary sub-arrays. This is where Range Notation can be very useful. The same submatrix extraction could also be represented as:

```
parameter Real C[2,2] = B[1:2,1:2]; // [1, 2; 4, 5];
```

### Enumerations¶

In our Chemical System examples, we saw how enumerations can be
used to specify array dimensions. Furthermore, we saw how the values
specified by an `enumeration`

type can be used to index the array.
In general, for an `enumeration`

like the following:

```
type Species = enumeration(A, B, X);
```

and then declare an array where that `enumeration`

is used to
specify a dimension, *e.g.,*

```
Real C[Species];
```

then we can use the enumeration values, `Species.A`

, `Species.B`

and `Species.X`

as indices. For example,

```
equation
der(C[Species.A]) = ...;
```

### Booleans¶

We can use the `Boolean`

type in much the same way as an
`enumeration`

. Given an array declared with `Boolean`

for a
dimension:

```
Real C[5,Boolean];
```

We can then use boolean values to index that dimension, *e.g.,*

```
equation
der(C[1,true]) = ...;
der(C[1,false]) = ...;
```

`end`

¶

When specifying a subscript for an array, it is legal to use `end`

in the subscript expression. In this context, `end`

will take on
the value of the highest possible value for the corresponding array
dimension. The use of `end`

within expressions allows easy
reference to array elements with respect to the last element rather
than the first. For example, to reference the second from the last
element in a vector, the expression `end-1`

can be used a subscript.

Remember that `end`

takes on the value of the highest possible index
for the **corresponding array dimension**. So for the following
array:

```
Integer B[2,4] = [1, 2, 3, 4; 5, 6, 7, 8];
```

The following expressions would evaluate as follows:

```
B[1,end] // 4
B[end,1] // 5
B[end,end] // 8
B[2,end-1] // 7
```

## Slicing¶

There is another sophisticated way of indexing arrays in Modelica. But it doesn’t make sense to talk about it just yet. We will see it later when we start our discussion of Arrays of Component.