5  Vectors, Matrices, Arrays, and Control Structures

5.2.1.1 Indexing

Every element in a list has an index (a location, indicated by an integer position)¹.

x <- list("a", 3, FALSE)

x[1] # This returns a list

[[1]]
[1] "a"

x[1:2] # This returns multiple elements in the list

[[1]]
[1] "a"

[[2]]
[1] 3

x[[1]] # This returns the item

[1] "a"

x[[1:2]] # This doesn't work - you can only use [[]] with a single index

Error in x[[1:2]]: subscript out of bounds

x = ["a", 3, False]

x[0]

'a'

x[1]

3

x[0:2]

['a', 3]

We’ll talk more about indexing as it relates to vectors, but indexing is a general concept that applies to just about any multi-value object.

5.2.2.1 Indexing by Location

Each element in a vector has an index - an integer telling you what the item’s position within the vector is. I’m going to demonstrate indices with the string vector

R	Python
1-indexed language	0-indexed language
Count elements as 1, 2, 3, 4, …, N	Count elements as 0, 1, 2, 3, , …, N-1

digits_pi <- c(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)

# Access individual entries
digits_pi[1]

[1] 3

digits_pi[2]

[1] 1

digits_pi[3]

[1] 4

# R is 1-indexed - a list of 11 things goes from 1 to 11
digits_pi[0]

numeric(0)

digits_pi[11]

[1] 5

# Print out the vector
digits_pi

 [1] 3 1 4 1 5 9 2 6 5 3 5

import numpy as np
digits_list = [3,1,4,1,5,9,2,6,5,3,5]
digits_pi = np.array(digits_list)

# Access individual entries
digits_pi[0]

3

digits_pi[1]

1

digits_pi[2]

# Python is 0 indexed - a list of 11 things goes from 0 to 10

4

digits_pi[0]

3

digits_pi[11] 

# multiplication works on the whole vector at once

Error in py_call_impl(callable, dots$args, dots$keywords): IndexError: index 11 is out of bounds for axis 0 with size 11

Detailed traceback:
  File "<string>", line 1, in <module>

digits_pi * 2

# Print out the vector

array([ 6,  2,  8,  2, 10, 18,  4, 12, 10,  6, 10])

print(digits_pi)

[3 1 4 1 5 9 2 6 5 3 5]

import pandas as pd
digits_pi = pd.Series([3,1,4,1,5,9,2,6,5,3,5])

# Access individual entries
digits_pi[0]

3

digits_pi[1]

1

digits_pi[2]

# Python is 0 indexed - a list of 11 things goes from 0 to 10

4

digits_pi[0]

3

digits_pi[11] 

# logical indexing works here too

Error in py_call_impl(callable, dots$args, dots$keywords): KeyError: 11

Detailed traceback:
  File "<string>", line 1, in <module>
  File "/__w/Stat151/Stat151/renv/python/virtualenvs/renv-python-3.8/lib/python3.8/site-packages/pandas/core/series.py", line 958, in __getitem__
    return self._get_value(key)
  File "/__w/Stat151/Stat151/renv/python/virtualenvs/renv-python-3.8/lib/python3.8/site-packages/pandas/core/series.py", line 1069, in _get_value
    loc = self.index.get_loc(label)
  File "/__w/Stat151/Stat151/renv/python/virtualenvs/renv-python-3.8/lib/python3.8/site-packages/pandas/core/indexes/range.py", line 387, in get_loc
    raise KeyError(key) from err

digits_pi[digits_pi > 3]
# simple multiplication works in a vectorized manner
# that is, the whole vector is multiplied at once

2     4
4     5
5     9
7     6
8     5
10    5
dtype: int64

digits_pi * 2

# Print out the series

0      6
1      2
2      8
3      2
4     10
5     18
6      4
7     12
8     10
9      6
10    10
dtype: int64

print(digits_pi)

0     3
1     1
2     4
3     1
4     5
5     9
6     2
7     6
8     5
9     3
10    5
dtype: int64

import pandas as pd
weekdays = pd.Series(['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'], index = ['S', 'M', 'T', 'W', 'R', 'F', 'Sat'])

# access individual objs
weekdays[0]

'Sunday'

weekdays[1]

'Monday'

weekdays['S']

'Sunday'

weekdays['Sat']

# access the index

'Saturday'

weekdays.index

Index(['S', 'M', 'T', 'W', 'R', 'F', 'Sat'], dtype='object')

weekdays.index[6] = 'Z' # you can't assign things to the index to change it

Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: Index does not support mutable operations

Detailed traceback:
  File "<string>", line 1, in <module>
  File "/__w/Stat151/Stat151/renv/python/virtualenvs/renv-python-3.8/lib/python3.8/site-packages/pandas/core/indexes/base.py", line 5021, in __setitem__
    raise TypeError("Index does not support mutable operations")

weekdays

S         Sunday
M         Monday
T        Tuesday
W      Wednesday
R       Thursday
F         Friday
Sat     Saturday
dtype: object

We can pull out items in a vector by indexing, but we can also replace specific things as well:

favorite_cats <- c("Grumpy", "Garfield", "Jorts", "Jean")

favorite_cats

[1] "Grumpy"   "Garfield" "Jorts"    "Jean"    

favorite_cats[2] <- "Nyan Cat"

favorite_cats

[1] "Grumpy"   "Nyan Cat" "Jorts"    "Jean"    

favorite_cats = ["Grumpy", "Garfield", "Jorts", "Jean"]

favorite_cats

['Grumpy', 'Garfield', 'Jorts', 'Jean']

favorite_cats[1] = "Nyan Cat"

favorite_cats

['Grumpy', 'Nyan Cat', 'Jorts', 'Jean']

5.2.2.2 Indexing with Logical Vectors

As you might imagine, we can create vectors of all sorts of different data types. One particularly useful trick is to create a logical vector that goes along with a vector of another type to use as a logical index.

If we let the black lego represent “True” and the grey lego represent “False”, we can use the logical vector to pull out all values in the main vector.

Black = True, Grey = False	Grey = True, Black = False

Note that for logical indexing to work properly, the logical index must be the same length as the vector we’re indexing. This constraint will return when we talk about data frames, but for now just keep in mind that logical indexing doesn’t make sense when this constraint isn’t true.

# Define a character vector
weekdays <- c("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday")
weekend <- c("Sunday", "Saturday")

# Create logical vectors
relax_days <- c(1, 0, 0, 0, 0, 0, 1) # doing this the manual way
relax_days <- weekdays %in% weekend # This creates a logical vector 
                                    # with less manual construction
relax_days

[1]  TRUE FALSE FALSE FALSE FALSE FALSE  TRUE

school_days <- !relax_days # FALSE if weekend, TRUE if not
school_days

[1] FALSE  TRUE  TRUE  TRUE  TRUE  TRUE FALSE

# Using logical vectors to index the character vector
weekdays[school_days] # print out all school days

[1] "Monday"    "Tuesday"   "Wednesday" "Thursday"  "Friday"   

import numpy as np;

animals = np.array(["Cat", "Dog", "Snake", "Lizard", "Tarantula", "Hamster", "Gerbil", "Otter"])

# Define a logical vector
good_pets = np.array([True, True, False, False, False, True, True, False])
bad_pets = np.invert(good_pets) # Invert the logical vector 
                                # so True -> False and False -> True

animals[good_pets]

array(['Cat', 'Dog', 'Hamster', 'Gerbil'], dtype='<U9')

animals[bad_pets]

array(['Snake', 'Lizard', 'Tarantula', 'Otter'], dtype='<U9')

animals[~good_pets] # equivalent to using bad_pets

array(['Snake', 'Lizard', 'Tarantula', 'Otter'], dtype='<U9')

5.2.2.3 Reviewing Types

As vectors are a collection of things of a single type, what happens if we try to make a vector with differently-typed things?

c(2L, FALSE, 3.1415, "animal") # all converted to strings

[1] "2"      "FALSE"  "3.1415" "animal"

c(2L, FALSE, 3.1415) # converted to numerics

[1] 2.0000 0.0000 3.1415

c(2L, FALSE) # converted to integers

[1] 2 0

import numpy as np

np.array([2, False, 3.1415, "animal"]) # all converted to strings

array(['2', 'False', '3.1415', 'animal'], dtype='<U32')

np.array([2, False, 3.1415]) # converted to floats

array([2.    , 0.    , 3.1415])

np.array([2, False]) # converted to integers

array([2, 0])

As a reminder, this is an example of implicit type conversion - R and python decide what type to use for you, going with the type that doesn’t lose data but takes up as little space as possible.

5.2.3.1 Indexing in Matrices

Both R and python use [row, column] to index matrices. To extract the bottom-left element of a 3x4 matrix in R, we would use [3,1] to get to the third row and first column entry; in python, we would use [2,0] (remember that Python is 0-indexed).

As with vectors, you can replace elements in a matrix using assignment.

my_mat <- matrix(1:12, nrow = 3, byrow = T)

my_mat[3,1] <- 500

my_mat

     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]    5    6    7    8
[3,]  500   10   11   12

import numpy as np

my_mat = np.reshape(range(1, 13), (3,4))

my_mat[2,0] = 500

my_mat

array([[  1,   2,   3,   4],
       [  5,   6,   7,   8],
       [500,  10,  11,  12]])

5.2.3.2 Matrix Operations

There are a number of matrix operations that we need to know for basic programming purposes:

• scalar multiplication \[c*\textbf{X} = c * \left[\begin{array}{cc} x_{1,1} & x_{1, 2}\\x_{2,1} & x_{2,2}\end{array}\right] = \left[\begin{array}{cc} c*x_{1,1} & c*x_{1, 2}\\c*x_{2,1} & c*x_{2,2}\end{array}\right]\]
• transpose - flip the matrix across the left top -> right bottom diagonal. \[t(\textbf{X}) = \left[\begin{array}{cc} x_{1,1} & x_{1, 2}\\x_{2,1} & x_{2,2}\end{array}\right]^T = \left[\begin{array}{cc} x_{1,1} & x_{2,1}\\x_{1,2} & x_{2,2}\end{array}\right]\]
• matrix multiplication (dot product) - you will learn more about this in linear algebra, but here’s a preview. Here is a better explanation of the cross product \[\textbf{X}*\textbf{Y} = \left[\begin{array}{cc} x_{1,1} & x_{1, 2}\\x_{2,1} & x_{2,2}\end{array}\right] * \left[\begin{array}{cc} y_{1,1} \\y_{2,1} \end{array}\right] = \left[\begin{array}{c}x_{1,1}*y_{1,1} + x_{1,2}*y_{2,1} \\x_{2, 1}*y_{1,1} + x_{2,2}*y_{2,1}\end{array}\right]\] Note that matrix multiplication depends on having matrices of compatible dimensions. If you have two matrices of dimension \((a \times b)\) and \((c \times d)\), then \(b\) must be equal to \(c\) for the multiplication to work, and your result will be \((a \times d)\).

x <- matrix(c(1, 2, 3, 4), nrow = 2, byrow = T)
y <- matrix(c(5, 6), nrow = 2)

# Scalar multiplication
x * 3

     [,1] [,2]
[1,]    3    6
[2,]    9   12

3 * x

     [,1] [,2]
[1,]    3    6
[2,]    9   12

# Transpose
t(x)

     [,1] [,2]
[1,]    1    3
[2,]    2    4

t(y)

     [,1] [,2]
[1,]    5    6

# matrix multiplication (dot product)
x %*% y

     [,1]
[1,]   17
[2,]   39

import numpy as np
x = np.array([[1,2],[3,4]])
y = np.array([[5],[6]])

# scalar multiplication
x*3

array([[ 3,  6],
       [ 9, 12]])

3*x

# transpose

array([[ 3,  6],
       [ 9, 12]])

x.T # shorthand

array([[1, 3],
       [2, 4]])

x.transpose() # Long form

# Matrix multiplication (dot product)

array([[1, 3],
       [2, 4]])

np.dot(x, y)

array([[17],
       [39]])

5.3.1.1 Representing Conditional Statements as Diagrams

A common way to represent conditional logic is to draw a flow chart diagram.

In a flow chart, conditional statements are represented as diamonds, and other code is represented as a rectangle. Yes/no or True/False branches are labeled. Typically, after a conditional statement, the program flow returns to a single point.

5.3.1.2 Chaining Conditional Statements: Else-If

In many cases, it can be helpful to have a long chain of conditional statements describing a sequence of alternative statements.

age <- 40 # change this as you will to see how the code works

if (age < 18) {
  bracket <- "<18"
} else if (age <= 25) {
  bracket <- "18-25"
} else if (age <= 40) {
  bracket <- "26-40"
} else if (age <= 55) {
  bracket <- "41-55" 
} else if (age <= 65) {
  bracket <- "56-65"
} else {
  bracket <- ">65"
}

bracket

[1] "26-40"

age = 40 # change this to see how the code works

if age < 18:
  bracket = "<18"
elif age <= 25:
  bracket = "18-25"
elif age <= 40:
  bracket = "26-40"
elif age <= 55:
  bracket = "41-55"
elif age <= 65:
  bracket = "56-65"
else:
  bracket = ">65"
  
bracket

'26-40'

5.3.2.1 While Loops

In the previous section, we discussed conditional statements, where a block of code is only executed if a logical statement is true.

The simplest type of loop is the while loop, which executes a block of code until a statement is no longer true.

x <- 0

while (x < 10) { 
  # Everything in here is executed 
  # during each iteration of the loop
  print(x)
  x <- x + 1
}

[1] 0
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9

x = 0

while x < 10:
  print(x)
  x = x + 1

0
1
2
3
4
5
6
7
8
9

5.3.2.2 For Loops

Another common type of loop is a for loop. In a for loop, we run the block of code, iterating through a series of values (commonly, one to N, but not always). Generally speaking, for loops are known as definite loops because the code inside a for loop is executed a specific number of times. While loops are known as indefinite loops because the code within a while loop is evaluated until the condition is falsified, which is not always a known number of times.

for (i in 1:5 ) {
  print(i)
}

[1] 1
[1] 2
[1] 3
[1] 4
[1] 5

for i in range(5):
  print(i)

0
1
2
3
4

For loops are often run from 1 to N (or 0 to N-1 in python) but in essence, a for loop is run for every value of a vector (which is why loops are included in the same chapter as vectors).

for (i in month.name)
  print(i)

[1] "January"
[1] "February"
[1] "March"
[1] "April"
[1] "May"
[1] "June"
[1] "July"
[1] "August"
[1] "September"
[1] "October"
[1] "November"
[1] "December"

futurama_crew = ['Fry', 'Leela', 'Bender', 'Amy', 'the Professor', 'Hermes', 'Zoidberg', 'Nibbler']
for i in futurama_crew:
  print(i)

Fry
Leela
Bender
Amy
the Professor
Hermes
Zoidberg
Nibbler

5.3.2.4 Controlling Loops

Sometimes it is useful to control the statements in a loop with a bit more precision. You may want to skip over code and proceed directly to the next iteration, or, as demonstrated in the previous section with the break statement, it may be useful to exit the loop prematurely.

for (i in 1:20) {
  if (i %% 15 == 0) {
    print("Exiting now")
    break
  } else if (i %% 3 == 0) {    
    print("Divisible by 3")
    next
    print("After the next statement") # this should never execute
  } else if (i %% 5 == 0) {
    print("Divisible by 5")
  } else {
    print(i)
  }
}

[1] 1
[1] 2
[1] "Divisible by 3"
[1] 4
[1] "Divisible by 5"
[1] "Divisible by 3"
[1] 7
[1] 8
[1] "Divisible by 3"
[1] "Divisible by 5"
[1] 11
[1] "Divisible by 3"
[1] 13
[1] 14
[1] "Exiting now"

for i in range(1, 20):
  if i%15 == 0:
    print("Exiting now")
    break
  elif i%3 == 0:
    print("Divisible by 3")
    continue
    print("After the next statement") # this should never execute
  elif i%5 == 0:
    print("Divisible by 5")
  else: 
    print(i)

1
2
Divisible by 3
4
Divisible by 5
Divisible by 3
7
8
Divisible by 3
Divisible by 5
11
Divisible by 3
13
14
Exiting now

To be quite honest, I haven’t really ever needed to use next/continue statements when I’m programming, and I rarely use break statements. However, it’s useful to know they exist just in case you come across a problem where you could put either one to use.