Arrays in Julia are, by default, Dynamic (i.e. growable, resizable) unless defined otherwise. We could change this default behavior by resorting to the StaticArrays.jl package, which can enhance performance for certain type of operations.

But let’s go about how to use the default dynamic arrays in Julia.

## Resizing 1D Arrays with Push and Pop

One-dimensional Arrays can be resized with functions such as push! and pop!. In our example below we are using numerical arrays, but these functions can be also applied to non-numerical arrays.

A = Float64[]       # Equivalent to A=Array{Float64}(undef,0)
push!(A, 4)         # Adds the number 4 at the end of the array
push!(A, 3)         # Adds the number 3 at the end of the array
v = pop!(A)         # Returns 3 and removes it from A

There are also functions such as pushfirst!, and popfirst! which work on the beginning of the array as opposed to the end. Additionally, the function splice!(A,i) and deleteat!(A,i) will incorporates (resp. delete) an element at a given position i.

## Multi-Dimensional Array Concatenation

A common operation is to concatenate arrays, for example, to add rows to an existing matrix. In Julia, there are a few ways to do this.

### Using hcat, vcat, and cat

For example, we can resort to hcat, vcat, and cat functions, to concatenate in the horizontal, vertical, or along any given dimension.

For example,

A = [4 5 6]
B = [6 7 8]

M1 = vcat(A, B)
2×3 Matrix{Int64}:
4  5  6
6  7  8

M2 = hcat(A, B)
1×6 Matrix{Int64}:
4  5  6  6  7  8

The cat function, in turn, can be used to acomplish the same results as above. Importantly, cat will also work for n-dimensional arrays, as we can concatenate along any dimension. For example.

M1 = cat(A, B, dims=1)
M2 = cat(A, B, dims=2)
M3 = cat(A, B, dims=3)

### Concatenating 2D Matrices

For 2D matrices, we can also resort to the same syntax that we used to input a matrix, using brackets and spaces and semicolons as alternatives to hcat and vcat, respectively.

For example,

M1 = [A; B]
2×3 Matrix{Int64}:
4  5  6
6  7  8

M2 = [A B]
1×6 Matrix{Int64}:
4  5  6  6  7  8

### Concatenating Vectors

So far we have been concatenating matrices, sometimes 1xn matrices.

But what if we have two vectors?

a = [1, 2, 3]
b = [4, 5, 6] 

Using vcat or hcat with vectors will consider the vectors are spanned along the vertical direction. That is, vcat will return a longer vector:

vcat(a,b)
6-element Vector{Int64}:
1
2
3
4
5
6

while hcat will concatenate them horizontally, and return a matrix

3×2 Matrix{Int64}:
1  4
2  5
3  6

Trying to use spaces or semicolons will return the same outputs (spaces are equivalent to hcat while semicolons are equivalent to vcat).

[a b]
3×2 Matrix{Int64}:
1  4
2  5
3  6

and

[a; b]
6-element Vector{Int64}:
1
2
3
4
5
6

Another possibility is to concatenate vectors using commas, which results in a vector of vectors:

[a,b]
2-element Vector{Vector{Int64}}:
[1, 2, 3]
[4, 5, 6]

Finally, in Julia 1.9, the stack function was introduced, which will concatenate a vector of vectors along a specified dimension:

stack([a,b], dims=1)
2×3 Matrix{Int64}:
1  2  3
4  5  6

and

stack([a,b], dims=2)
3×2 Matrix{Int64}:
1  4
2  5
3  6

## Conclusion

We have covered the basics of Array manipulation, using the Julia Base syntax.

There is, of course, more array functionality in several packages, such as LinearAlgebra.jl, StaticArrays.jl, SparseArrays.jl, which will be the subject of future posts. Stay tuned!