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 Ranges.

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.