Arrays

Arrays are nothing but a collection of some stuff. Imagine a rack with, where each compartment is numbered/indexed 1, 2 ,3 … and so on and you put an item in each compartment. At a later time you can retrieve the item using the index.

The code for this blog can be fount here https://gitlab.com/data-science-with-julia/code/-/blob/master/arrays.ipynb, let’s get practical here now. Launch your Jupyter Lab and try these out:

First lets create an array as shown below:

array = [1, 2, 3, 4, 5]

Output:

5-element Array{Int64,1}:
 1
 2
 3
 4
 5

As you can see we have 1, 2, 3, 4, 5, within [ and ], that’s how Julia knows we have created an array, and we assign it to variable named array. So the variable array points to the start of [1, 2, 3, 4, 5].

To determine how many elements are present in an array, we use the length() function as shown below

length(array)

Output:

I don’t think it should be a mystery to you that we have 5 elements in array.

Now let’s try size():

size(array)

Output:

(5,)

so it returns something weird, and it looks like this (5,), this is called a Tuple, a very similar data structure like Array, but it’s immutable. That is we cannot change it. We will look at it in the later blogs.

Now let’s get into some kind of statistics, what about totaling the values in an array, take a look at the example below:

total = 0

for element in array
    total += element
end

println(total)

Output:

We use the for loop here, in this line for element in array, in each iteration, element get the value of one element of array. That is in the first iteration element becomes 1 in the second 2 and so on. Now when it hits total += 0, in the first iteration total becomes 0 + 1, that is 1, in the second iteration 1 + 2 that is 3 and so on…. Finally we print total here println(total) and its 15.

Now let’s see what the average is. Its nothing but total divided by number of elements in the array as shown below:

avg = total / length(array)

Output:

3.0

In previous blogs we have seen how to find maximum of 2 or three numbers, but look at the program below. You can pack how many number you want in the array and it will find the maximum:

max = array[1]

for element in array
    max = max > element ? max : element
end

println(max)

Output:

First we have a variable max which s assigned to the first element of the array here max = array[1], now we have these lines:

for element in array
    max = max > element ? max : element
end

In the above lines, each element of the array is assigned to element and here max = max > element ? max : element, max takes on the value of element if it’s greater than element and finally we print out max here println(max).

Now let’s see how to access 3rd element of an array:

array[3]

Output:

Now we access elements 2 to 4:

array[2:4]

Output:

3-element Array{Int64,1}:
 2
 3
 4

See that in the above example we pass range 2:4 between the brackets.

We wrote a long program to find maximum of an array, but we can also do it like this:

maximum(array)

Output:

Here is the code to find minimum:

minimum(array)

Output:

We can get cumulative sum of an array as shown:

cumsum(array)

Output:

5-element Array{Int64,1}:
  1
  3
  6
 10
 15

This is how to find total or sum of an array:

sum(array)

Output:

Now let’s multiply all elements of an array by 7:

array * 7

Output:

5-element Array{Int64,1}:
  7
 14
 21
 28
 35

Now let’s add 1 to all elements of the array:

array.+ 1

Output:

5-element Array{Int64,1}:
 2
 3
 4
 5
 6

Note that we use a dot in array.+ 1, the dot . is a broadcasting operator which is used for element wise operations. I find that we can omit . for multiplying and dividing array by scalar.

In the example below we divide array by scalar:

array / 4

Output:

5-element Array{Float64,1}:
25
5
75
0
25

In the below example we subtract 4 from each element of the array, notice that we use the dot . operator:

array.- 4

Output:

5-element Array{Int64,1}:
 -3
 -2
 -1
  0
  1

There is a function called typeof() in Julia that tells the variable type. Let’s see what data type array is:

typeof(array)

Output:

Array{Int64,1}

So it says Array, that is collection of stuff in an ordered format, it’s elements are integers Int, and each element occupies 64 bits of space. Why don’t you check what is the type of array / 4?

Now let’s see how to add a new element to an array:

push!(array, 21)

Output:

6-element Array{Int64,1}:
  1
  2
  3
  4
  5
 21

In the above case we have added 21 to the array using push!() function. As a first argument to push!() we give array and as second argument we give the element to be added that is 21.

Wen ever you use push!(), you see that array gets modified as shown below. The exclamation mark, also called as bang ! in computer science indicates that the argument been passed to it gets modified. Let’s check the value of array now:

array

Output:

6-element Array{Int64,1}:
  1
  2
  3
  4
  5
 21

Now let’s pop out the last element of the array:

pop!(array)

Output:

We use function called pop!(), since it comes with a bang !, we can expect array is modified here as shown below:

array

Output:

5-element Array{Int64,1}:
 1
 2
 3
 4
 5

We push 3 into the array:

push!(array, 3)
sort(array)

Output:

6-element Array{Int64,1}:
 1
 2
 3
 3
 4
 5

We check it again as though we don’t believe in push!():

array

Output:

6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 3

We reverse the order of elements in array

reverse(array)

Output:

6-element Array{Int64,1}:
 3
 5
 4
 3
 2
 1

We sort the array here:

sort!(array)

Output:

6-element Array{Int64,1}:
 1
 2
 3
 3
 4
 5

Since we used a function with bang ! above, we can expect the result to be stored in variable array as shown below:

array

Output:

6-element Array{Int64,1}:
 1
 2
 3
 3
 4
 5

Now let’s do some real math, lets say we are buying some items, their quantities and prices are given below:

mangoes = 2
rice_in_kg = 5
eggs = 12

mango_price = 50
rice_price = 30
egg_price = 7

quantities = [mangoes, rice_in_kg, eggs]
prices = [mango_price, rice_price, egg_price];

The above cell does not spit any output, look at the semicolon ; at the end of the last line that prevents the cell from cluttering your notebook with its outputs.

Since it’s Julia, I can compute the total prices as shown below:

total_array = quantities.* prices

Output:

3-element Array{Int64,1}:
 100
 150
  84

As you can see, you can compute the total cost of each item using just the star * operator. That’s a lot of savings for you from writing lot of iterative code (if you know to code in other languages).

Now let’s compute the sun of the above total_array

grand_total = sum(total_array)

Output:

Julia provides sum() function that computes the total of an array.

Now let’s use Julia’s built in linear algebra package, and since quantities and prices are nothing but vectors, we can compute the total by taking it’s dot product as shown:

using LinearAlgebra
dot(quantities, prices)

Output:

In the above example we have learned to use or import a package, to import it we use using <package name>. Thankfully Julia has LinearAlgebra package built into it, but it’s not imported at the start by default, so we need to import it using using LinearAlgebra. It provides a convenient dot() function to calculate the dot product.

Now say we want to be more concise, we can use the dot operator ⋅ provided by LinearAlgebra package.

quantities ⋅ prices

Output:

In case you are wondering how to type ⋅, type \cdot and press Tab.