Matrix and Lists

#Матрицы и списки. Часть 1 Наследуют свойства векторов

МАТРИЦА

• Двумерный массив данных одного типа

• Работает такой же принцип приведения, как для веткоров

• По сути - это вектор, уложенный по столбцам

• Для создания матрица можно испольовать функци matrix

matrix(1:6, nrow = 2, ncol = 3)

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

Можно избавиться от избыточности

Можно указать только nrow или ncol, а второй будет вычислен автоматически, исxодя из длины вектора

matrix(1:6, nrow = 2)

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

Если хотим упаковать вектор не по столбцам, а по строчкам?

Используем аргумент byrow = TRUE

matrix(1:6, nrow = 2, byrow = TRUE)

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

Несоотвествие между длиной вектора и задаваемым размером?

А) Вектор короче размеров таблицы

Вектор переписывается и повторяется нужное число раз

matrix(7:8, nrow = 2, ncol = 5)

     [,1] [,2] [,3] [,4] [,5]
[1,]    7    7    7    7    7
[2,]    8    8    8    8    8

Б) Если вектор длинее? Тестируем:

Получается, что используются только те значения вектора, которые помещаются в заданные размеры

matrix(1:10, nrow = 2, ncol = 2)

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

Отличия матрицы от векторв

Единственное отличие состоит в том, что у матрицы есть специальный атрибут dim - отвечает за размерность
### Можно получить доступ к размерности, используя dim

n <- matrix(1:6, ncol = 3)
dim(n)

[1] 2 3

2 - это ряды
3 - это столбцы

Cпециальные функции nrow() и ncol() делают то же самое

nrow(n)

[1] 2

ncol(n)

[1] 3

Что будет, если нивелировать dim?

Матрица превращается в обычный вектор

dim(n) <- NULL
n

[1] 1 2 3 4 5 6

Если восстановить аттрибут, то матрица приобретет исходный вид

dim(n) <- c(2,3)
n

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

Вопрос: что будет, если вектору присвоить аттрибут dim?

Ожидаю, что вектор превратится в матрицу. Тестирую:
1. Cоздам вектор от 1 до 8

vec <- 1:8
vec

[1] 1 2 3 4 5 6 7 8

2. Присвою аттрибут dim

dim(vec) <- c(2, 4)
vec

     [,1] [,2] [,3] [,4]
[1,]    1    3    5    7
[2,]    2    4    6    8

Как и ожидалось вектор превратился в матрицу. Прикольно

Арифметические операции с матрицами

Действуют все те же правила, что и для веткоров.
Создадим две матрицы для проверки

n1 <- matrix(1:4, nrow = 2)  
n2 <- matrix(c(1,2,2,3), nrow = 2)
n1

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

n2

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

Сложение

Теперь попробуем их сложить друг с другом. Сложение произойдет поэлементно

n1 + n2 

     [,1] [,2]
[1,]    2    5
[2,]    4    7

Правила переписывания

Правила работают так же, как на векторах, поэтому можем, например, к матрице добавить число (арифметика снова выполняется поэлементно)

n1

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

n1 + 5

     [,1] [,2]
[1,]    6    8
[2,]    7    9

Умножение

Так же будут выполняться поэлементно, как и все остальные арифметические операторы

n1 * 2

     [,1] [,2]
[1,]    2    6
[2,]    4    8

n1 * n2

     [,1] [,2]
[1,]    1    6
[2,]    4   12

Умножение в смысле линейной алгебры требует других операторов

Что такое линейное алгебра, я понятия не имею. Пишут, что умножение в линейной алгебре работает по "принципу строку на столбец
|a1 b1| |c1 d1|
| | * | |
|a2 b2| |c2 d2|
получется то же, что и
|a1c1 + b1c2 a1d1 + b1d2|
| |
|a2c1 + b2c2 a2d1 + b2d2|

n1 %*% n2

     [,1] [,2]
[1,]    7   11
[2,]   10   16

Протестирую сложение с таким же доп оператором - такой функции нет

Функция sum()

Попробую применить к двум матрицам

n1

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

n2

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

sum(n1, n2)

[1] 18

Т.е. sum() возвращает сумму всех элементов всех матрица, а не поэлементную сумму

Индексирование матриц

Действуют те же правила, что и для векторов, но учитываются две размерности например, создадм матрицу

m <- matrix(1:10, ncol = 5)
m

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    3    5    7    9
[2,]    2    4    6    8   10

Получим доступ к элементу в первом ряду, в 3 столбце

m[1, 3]

[1] 5

Интересно, что если опустим один из аргументов при обращении к элементу, то получим доступ ко всей строке/ столбцу

#2-я строка
m[2, ]

[1]  2  4  6  8 10

#3-й столбец
m[ , 3]

[1] 5 6

Можно пользоваться такой аннотацией для замены элементов матрицы

Подставлять в элементы матрицы можно:
* вектора
* вектора единичной длины (скаляры)
* подматрицы

Обнулить всю первую строку

m[1, ] <- 0; m

     [,1] [,2] [,3] [,4] [,5]
[1,]    0    0    0    0    0
[2,]    2    4    6    8   10

То же самое касается отрицательных индексов. Например, если хочу переприсвоить все значения кроме 5-го столбца

m[ , -5] <- 11:18; m

     [,1] [,2] [,3] [,4] [,5]
[1,]   11   13   15   17    0
[2,]   12   14   16   18   10

Схлопывание размерности - особенность матриц

Допустим, возъмем ту же матрицу, что и раньше, но воспользуемся отдельным вектором, который будет указывать индексы столбцов

m <- matrix(1:10, ncol = 5)
ind <- c(1,3,5)
m

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    3    5    7    9
[2,]    2    4    6    8   10

Теперь обратимся к элементам, индексируемым в векторе ind. Получаем подматрицу из 3х столбцов

m[ , ind]

     [,1] [,2] [,3]
[1,]    1    5    9
[2,]    2    6   10

Что будет, если длина индекса будет равна 1. Допустим, нас интересует только 3й столбец. Мы захотим получить подматрицу, состоящую из 3го столбца

ind <- 3
m[ , ind]

[1] 5 6

Мы видим, что происходит “схлопывание размерности” - т.е. резульатом обращения к матрице видим не матрицу, а вектор.
Чтобы избавиться от этого поведения, можно воспользоваться дополнительным аргументом drop

m[ , ind, drop = F]

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

Получаем таким образом матрицу в 1 столбец, а не вектор

Именованные матрицы: rownames/colnames

У векторо могут быть имена, так же и у матриц.Возьмем матрицу и присвоим рядам этой матрицы название

m <- matrix(1:10, ncol = 5)
rownames(m) <- c("row1", "row2")
m

     [,1] [,2] [,3] [,4] [,5]
row1    1    3    5    7    9
row2    2    4    6    8   10

Так же можно присвоить имена столбцам. Но, если не хочется вводить все имена вручную, то можно воспользоваться функцией paste0(), которая склеивает вводные аргументы в вектор из строк

colnames(m) <- paste0("column", 1:5)
m

     column1 column2 column3 column4 column5
row1       1       3       5       7       9
row2       2       4       6       8      10

Получили матрицу, к которой теперь можно обращаться по именам

m["row1", c("column2", "column4"), drop = F]

     column2 column4
row1       3       7

Что будет, если изменить порядок колонок? Изменится ли отображение в коде?

m["row1", c("column4", "column2"), drop = F]

     column4 column2
row1       7       3

То есть порядок выстраивается в соответствии с кодом

В чем отличие paste() и paste0().
paste (…, sep = " ", collapse = NULL) paste0(…, collapse = NULL) Попробуем повторить аналогичную операцию. Пока разницы не вижу.

colnames(m) <- paste("col", 1:5)
m

     col 1 col 2 col 3 col 4 col 5
row1     1     3     5     7     9
row2     2     4     6     8    10

Возможно, если подавать несколько векторов функции, то между ними можно строить некие раделители?

colnames(m) <- paste("col", 1:2, "sol", 3:5)

Error in dimnames(x) <- dn : 
  length of 'dimnames' [2] not equal to array extent

Короче пока какая-то непонятная функция.

Присоединение матриц: rbind/cbind

Что делать, если я хочу присоединить матрицу к матрице.
Для этого есть две функции:
* rbind - т.е. rowbind, т.е. присоединение по рядам

n1

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

n2

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

rbind(n1, n2)

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

• cbind - т.е. columnbind, т.е. присоединение по колонкам

cbind(n1, n2)

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

Что будет, если присоединить к матрице вектор по рядам?

vec <- 1:5
vec

[1] 1 2 3 4 5

rbind(n1, vec)

number of columns of result is not a multiple of vector length (arg 2)

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

cbind(n1, vec)

number of rows of result is not a multiple of vector length (arg 2)

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

Вывод ошибки о том, что результирующий объект не кратен длине аргументе vec.
Попробую привести vec к соответсвующей длине.

length(n1)

[1] 4

length(vec)

[1] 5

Т.е. длина матрицы определяется количеством элементов в ней

vec <- 1:4
rbind(n1, vec)

number of columns of result is not a multiple of vector length (arg 2)

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

vec <- 1:2
rbind(n1, vec)

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

Выходит что-то мне пока не очень понятное.
Если почитать справку по rbind или cbind, то увидим, что аргументом функции служит “…” (ellipsis) - это значит, что функции можно передавать неограниченное число объектов.
Например, хочу вызвать функцию cbind на большом количестве векторов

cbind(n1, n2)

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

cbind(n1, n2, 1:2)

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

cbind(n1, n2, 1:2, c(5,3))

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

cbind(n1, n2, 1:2, c(5,3), n2[ ,1])

     [,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,]    1    3    1    2    1    5    1
[2,]    2    4    2    3    2    3    2

# И так далее
cbind(n1, n2, 1:2, c(5,3), n2[ , 1], n1 + 3, cbind(n2, n1))

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

Таким образом будут работать и другие функции:
* с
* paste
* paste0
* sum

Функция семейства apply

Применение функций к матрице apply()

Часто возникает необходимость применить одну и ту же функцию к солбцам или строчкам. В других языках для этого можно было бы написать цикл for. В R тоже можно, но в этом нет необходимости.
Создадим матрицу

m <- matrix(1:25, 5)
m

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25

N.B! У функции необзательно должно быть ключевое слово return. Если к концу функции return не встречается, то возврашается результат последней операции. Можно сокращать запись Создаем функцию с одной операцией

f <- function(x) sum(x^2)

Три аргумента функции apply:

• Массив (матрица)
• Индекс (1 - по строкам, 2 - по столбцам)
• Функция

# Применю функцию f к матрице m построчно
apply(m, 1, f)

[1]  855  970 1095 1230 1375

# Применю функцию по столбцам
apply(m, 2, f)

[1]   55  330  855 1630 2655

Переписывается ли матрица?

m

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25

Не переписывается.

Применение функций к матрице: apply

Если хочу применить функцию ко всем элементам, то:

apply(m, 1:2, f)

     [,1] [,2] [,3] [,4] [,5]
[1,]    1   36  121  256  441
[2,]    4   49  144  289  484
[3,]    9   64  169  324  529
[4,]   16   81  196  361  576
[5,]   25  100  225  400  625

Можно и задавать условия применения функции, например: если элемент больше 13, то оставляем элемент, а если меньше, то заменяем на 13

apply(m, 1:2, function(i) if (i > 13) i else 13)

     [,1] [,2] [,3] [,4] [,5]
[1,]   13   13   13   16   21
[2,]   13   13   13   17   22
[3,]   13   13   13   18   23
[4,]   13   13   14   19   24
[5,]   13   13   15   20   25

Переписалась ли при этом матрица?

m

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    6   11   16   21
[2,]    2    7   12   17   22
[3,]    3    8   13   18   23
[4,]    4    9   14   19   24
[5,]    5   10   15   20   25

Нет.

Такая функция (не имеющая имени) называется анонимной - она прекращает свое существования сразу после того, как apply была выполнена. Ни в одном окружении ее не осталось. Это удобно для быстрых функций, для которых не хочется заводить переменную С точки зрения языка R - это лишняя работа. Можно было сделать то же с помощью логического индексирования

m[m <= 13] <- 13; m

     [,1] [,2] [,3] [,4] [,5]
[1,]   13   13   13   16   21
[2,]   13   13   13   17   22
[3,]   13   13   13   18   23
[4,]   13   13   14   19   24
[5,]   13   13   15   20   25

Самые частые функции для матриц

Самые частые операции по строкам и столбцам - sum и mean
* rowSums - cумма по рядам

rowSums(m)

[1] 76 78 80 83 86

• rowMeans - среднее по рядам

rowMeans(m)

[1] 15.2 15.6 16.0 16.6 17.2

• colSums - cумма по колонкам
  
• colMeans - среднее по колонкам

Допустим, мы хотим удостовериться, что rowSums действительно считает сумму элементов по рядам. Можем написать свою собственную функцию, используя apply для этого

all.equal(rowSums(m),apply(m, 1, sum))

[1] TRUE

all.equal(colSums(m),apply(m, 2, sum))

[1] TRUE

Комментарии Stepik

Управляющие конструкции тоже работают с векторами и матрицами

Например,

t <- matrix(1:9, 3); t

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

y <-  ifelse(t %% 2 == 0, 1, 0)
y

     [,1] [,2] [,3]
[1,]    0    1    0
[2,]    1    0    1
[3,]    0    1    0

Но стоит учитывать, что ifelse хоть и векторизована, но не работает не очень быстро. В приведенном примере лучше опять же использовать индексирование. Например

m <-  matrix(0, 3, 3); m

     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0
[3,]    0    0    0

m[seq_along(m) %% 2 == 0] <- 1
m

     [,1] [,2] [,3]
[1,]    0    1    0
[2,]    1    0    1
[3,]    0    1    0

Некоторые особенности матриц

1. Матрицы занимают меньший объем оперативной памяти, чем аналогичный dataframe

2. Скорость выполнения аналогичных функций на матрицах, выше чем на dataframe

3. В контексте работы с чем-то очень большим, используется наследник матрицы bigmatrix

Применение функции семейства apply не самая хорошая практика из-за нестабильности получаемого результата

Матрицы и Списки - часть 2

Допустим, есть две матрицы. Чтобы получить из них одну большую матрицу можно воспользоваться функциями rbind() или cbind().
Но, допустим, этого недостаточно. Например, хотим объединить их по диагонали так, чтобы m1 занимала левый верхний угол, m2 - правый нижний угол, а остальные элементы матрицы были заполнены какими-нибудь значеними
### Как написать функцию для решения такой задачи? Напишем функцию. Нам нужно ввести результирующую матрицу, мы знаем ее размер - это сумма количества рядов m1 и m2, то же самое верно и для столбцов.
1. Заполним m3 элементом fill, который будет заполнять пустые ячейки, а потом просто заполним левый верхний и правый нижний углы

bind_diag <- function(m1, m2, fill) {
  m3 <- matrix(fill, 
               nrow = nrow(m1) + nrow(m2),
               ncol = ncol(m1) + ncol(m2)
               )
  # Матрицы создана, теперь можно заполнить ее два куска
  # Первый кусок - левый верхний угол m1
  m3[1:nrow(m1), 1:ncol(m1)] <- m1
  m3[nrow(m1) + 1:nrow(m2), ncol(m1) + 1:ncol(m2)] <- m2
  m3
}

Вот функция и готова.
Можем ввести матрицы

m1 <- matrix(1:12, nrow = 3)
m2 <- matrix(10:15, ncol = 3)
m1; m2

     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
     [,1] [,2] [,3]
[1,]   10   12   14
[2,]   11   13   15

Применим функцию

bind_diag(m2, m1, fill = NA)

     [,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,]   10   12   14   NA   NA   NA   NA
[2,]   11   13   15   NA   NA   NA   NA
[3,]   NA   NA   NA    1    4    7   10
[4,]   NA   NA   NA    2    5    8   11
[5,]   NA   NA   NA    3    6    9   12

bind_diag(m2, m1, fill = 0)

     [,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,]   10   12   14    0    0    0    0
[2,]   11   13   15    0    0    0    0
[3,]    0    0    0    1    4    7   10
[4,]    0    0    0    2    5    8   11
[5,]    0    0    0    3    6    9   12

bind_diag(m2, m1, fill = "fuck")

     [,1]   [,2]   [,3]   [,4]   [,5]   [,6]   [,7]  
[1,] "10"   "12"   "14"   "fuck" "fuck" "fuck" "fuck"
[2,] "11"   "13"   "15"   "fuck" "fuck" "fuck" "fuck"
[3,] "fuck" "fuck" "fuck" "1"    "4"    "7"    "10"  
[4,] "fuck" "fuck" "fuck" "2"    "5"    "8"    "11"  
[5,] "fuck" "fuck" "fuck" "3"    "6"    "9"    "12"  

Записывается ли при этом переменная m3 в глобальное окружение или это одноразовый вывод?

m3

Error: object 'm3' not found

Не записывается, как и ожидалось

Тоже самое можно было и сделать через cbind и rbind

bind_diag2<-function(m1,m2,fill)
{
  cbind(
  rbind(m1,matrix(fill,nrow(m2),ncol(m1))),
  rbind(matrix(fill,nrow(m1),ncol(m2)),m2))
}

Пробуем

bind_diag2(m1, m2, fill = 0)

     [,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,]    1    4    7   10    0    0    0
[2,]    2    5    8   11    0    0    0
[3,]    3    6    9   12    0    0    0
[4,]    0    0    0    0   10   12   14
[5,]    0    0    0    0   11   13   15

Задача, с которой я не справился

Напишите функцию, которая принимает одно целое число n, а возвращает “ступенчатую” матрицу, состоящую из n этажей. Этажи нумеруются с первого, ширина каждой ступеньки равна одной строке или столбцу.

Пример. Пусть n=4, тогда необходимо вернуть матрицу вида

1 1 1 1 1 1 1
1 2 2 2 2 2 1
1 2 3 3 3 2 1
1 2 3 4 3 2 1
1 2 3 3 3 2 1
1 2 2 2 2 2 1
1 1 1 1 1 1 1

Решения

1 - c циклом for

build_ziggurat2 <- function(n) {
  m<-matrix(0,2*n-1,2*n-1)
  b<-n*2-1
  c<-b
  for (i in 1:n) {
    if (i==1) {
      m1<-matrix(i,b,b)
      m[i:b,i:b] <- m1
      b <- b-1
    } else {
      c <- c-2
      m1 <-matrix(i,c,c)
      m[i:b,i:b] <-m1
      b <- b-1
    }
  }
  m
}  

Через индексы

build_ziggurat <- function(n) {
    #Выводим в отдельную матрицу со столбцами "row" и "col" все индексы матрицы размерности зиккурата
    z <- which(matrix(1,n*2-1,n*2-1)==1, arr.ind = T)
    #В каждой строке меняем значения, превышающее заданное число n
    z <- ifelse(z>n,2*n-z,z)
    #В каждой строке оставляем только наименьшее
    z <- ifelse(z[,1]>=z[,2],z[,2],z[,1])
    #Итоговый вектор превращаем в матрицу (зиккурат)
    dim(z)<-c(2*n-1,2*n-1)
    #Zиккурат
    z
}

2 без циклов и рекурсий

build_ziggurat <- function(n) {
  d <- n * 2 - 1
  outer(1:d, 1:d, function(x,y) {
   x <- n - abs(n - x)
   y <- n - abs(n - y)
   pmin(x,y)
  })
}  

3 - красивое решение без циклов

build_ziggurat <- function(n) {
  d = n*2-1  
  # создадим 4 ступенчатые матрицы, направленные в разные стороны
  m1 = matrix(1:d, d, d)
  m2 = matrix(1:d, d, d, byrow = T)
  m3 = matrix(d:1, d, d)
  m4 = matrix(d:1, d, d, byrow = T)
  # найдем минимум для каждой позиции из четырех матриц
  pmin(m1, m2, m3, m4)
}

Геометрическое решение

build_ziggurat <- function(n) {
  v <- c(1:(n-1), n, (n-1):1)  # пример: 1 2 3 2 1
  N <- 2*n-1
  
  # матрица из повторяющихся векторов
  mat1 <- matrix(rep(v, N), N, N)
  
  # та же матрица в траспонированном ("повернутом") виде
  mat2 <- matrix(rep(v, N), N, N, byrow=T)
  
  # смешение матриц дает пирамиду
  # модуль позволяет "убрать" избыточные диагональные элементы
  return((mat1+mat2-abs(mat1-mat2))/2)
}

Важно, что код на R с циклом работает медленее

Функция на цикле

build_ziggurat_1 <- function(n) {
result_m <- matrix(0, nrow = 2n - 1, ncol = 2n - 1)
for(i in 1:(2n - 1)){
for(j in 1:(2n - 1)){
result_m[i,j] = -max(abs(i-n),abs(j-n))
}
}
return(result_m + n)

Функция без цикла

build_ziggurat_2 <- function(n) {
size <- n*2-1
temp <- matrix(NaN, size, size)
pmin(n-abs(n - row(temp)), n-abs(n-col(temp)))

Проверим скорость работы

system.time(build_ziggurat_1(1000))

пользователь система прошло 9.42 0.30 10.09

system.time(build_ziggurat_2(1000))

пользователь система прошло 0.71 0.04 0.75