# Arrays¶

An array is an n-dimensional matrix. The elements are accessed by "row" and "column" indices.

## Vectors¶

A `Vector`

is just what you think it is: a 1-dimensional array. In Julia, these are always column vectors (sort of always).

To create a vector, simply fill it with values:

```
a = [1, 2, 3]
3-element Array{Int64,1}:
1
2
3
```

Note that the return values is a one-dimensional `array`

. `Vector`

is simply an alias for this.

```
julia> Vector{Int} === Array{Int,1}
true
```

There are no row vectors in Julia. A row vector is a `1xN`

`Matrix`

:

```
julia> a = [1 2 3]
1×3 Array{Int64,2}:
1 2 3
julia> a isa Matrix{Int}
true
```

### Indexing¶

To extract elements from a vector, hand it a list of indices.

```
julia> a = [2, 3, 4, 5];
julia> a[1]
2
# Note the double brackets
julia> a[[1, 3]]
2-element Array{Int64,1}:
2
4
# What we are really doing is
idx = [1, 3];
a[idx]
```

Then there is logical indexing:

```
a = [1, 2, 3];
a[[true, false, true]]
2-element Array{Int64,1}:
1
3
```

Arrays are "mutable", meaning that the elements can be changed "in-place":

```
julia> a = [1,2,3]
3-element Vector{Int64}:
1
2
3
julia> a[2] = 22
22
julia> a
3-element Vector{Int64}:
1
22
3
```

### Ranges¶

In Matlab, `1:3`

is a `Vector`

, but not in Julia:

```
julia> 1:3
1:3
julia> typeof(1:3)
UnitRange{Int64}
```

The main difference between a `Vector`

and a `Range`

is that the vector is allocated upon construction (its values are computed and stored in memory).

A `Range`

is an `Iterator`

. You can iteratore over its elements, but they are not computed until needed. Therefore, the `Range`

does not allocate memory. This is a big deal when lots of values are involved.

However, a `Range`

is an `AbstractArray`

; so all the indexing that works on `Vectors`

also works on `Range`

s.

collect makes a `Range`

into a `Vector`

.

### Exercises¶

Start with `x = 1 : 3 : 30`

.

- Find all even elements.
- Find all elements between 5 and 20.
- Set all even elements to their negative values.

## Matrices¶

A `Matrix`

is a 2-dimensional array. There are also n-dimensional arrays (see below).

To create a matrix, simply fill it with values.

```
julia> a = [1 2 3; 4 5 6]
2×3 Array{Int64,2}:
1 2 3
4 5 6
```

Many commands work directly on matrices.

```
julia> a = [1 2 3]; b = [2; 1; 1]; a * b
1-element Array{Int64,1}:
7
julia> c=b*a
3×3 Array{Int64,2}:
2 4 6
1 2 3
1 2 3
```

To extract elements:

```
julia> c[1,2]
4
julia> c[1:2, 2:3]
2×2 Array{Int64,2}:
4 6
2 3
```

To extract a row (but note that this produces a `Vector`

):

```
julia> c[1,:]
3-element Array{Int64,1}:
2
4
6
```

Linear indexing works as well:

```
julia> c[4]
4
julia> c[4] == c[1,2]
true
```

In memory, `Arrays`

are stored like `Vectors`

. The compiler just keeps track of how the user wants to interpret the data.

## Multi-dimensional Arrays¶

Arrays can have more than 2 dimensions.

```
julia> using Random
julia> a = rand(4,3,2)
4×3×2 Array{Float64,3}:
[:, :, 1] =
0.146411 0.908415 0.568039
0.444156 0.434034 0.875361
0.429705 0.704086 0.71789
0.502228 0.124412 0.771808
[:, :, 2] =
0.862953 0.58189 0.549077
0.722745 0.677342 0.330188
0.0543144 0.161877 0.358381
0.312414 0.0681076 0.822319
```

Indexing generates new arrays with potentially fewer dimensions:

```
julia> a[:,1,:]
4×2 Array{Float64,2}:
0.146411 0.862953
0.444156 0.722745
0.429705 0.0543144
0.502228 0.312414
```

### Array Exercises¶

- Construct a matrix
`A`

with elements`[2,4,...,20]`

in row 1 and`[1,4,7,...,28]`

in row 2. - Replace row 1 with its square.
- Find all columns where row 1 > row 2.
- Let
`x=ones(10,1)`

. Compute`Ax`

.