Как задать матрицу в r studio

Обновлено: 06.07.2024

Базовые сведения по математическим операциям можно почерпнуть из встроенной справочной системы:

Последовательное произведение каждого члена вектора на соответствующий член другого вектора и сумма получившихся произведений.

В представленном примере вектор (3,3,3) умножается на вектор (1,2,3) , то есть выполняются следующие действия:

1. 3*1=3 (запоминаем)
2. 3*2=6 (запоминаем)
3. 3*3=9 (запоминаем)
4. (вспоминаем) 3+6+9=18

Таким образом векторы R совместимы с векторами обычной линейной алгебры.

Из линейной алгебры известно:

Вот именно эту операцию R считает внешним произведением:

Если требуется создать матрицу, то нужно использовать функцию matrix() . Для этого требуется:

1. Передать вектор данных.
2. Количество столбцов и/или строк.
3. Задать способ обработки: по столбцам (по умолчанию) или строкам; при помощи опции byrow.

"Склеить" матрицу из нескольких векторов можно функциями cbind(v1,v2) (по столбцам) или rbind(v1,v2) (по строкам).

Размерность матрицы может быть получена функцией dim() . Узнать количество столбцов или строк можно, соответственно, функциями nrow() или ncol() .

Для работы с этими видами матриц требуется специальный набор функций из пакета matlab (в самом Matlab-е эти функции называются идентично).

R позволяет сгенерировать единичную матрицу нужного размера при помощи функции eye() , которой в качестве аргумента передаётся размер матрицы.

Квадратную матрицу полностью состоящую из единиц можно получить при помощи функции ones(), которой в качестве параметра передаётся размер:

Сгенерировать нулевую матрицу заданного размера можно при помощи функции zeros(), которой в качестве параметра передаётся размер:

Для получения диагонали матрицы нужно отдать матрицу в качестве аргумента функции diag() , и она вернёт вектор составленный из элементов диагонали:

Для получения верхнего угла можно использовать функцию upper.tri() , нижнего - lower.tri() . Эти функции принимают матрицу в качестве аргумента и возвращают матрицу идентичного размера с элементами типа Boolean. На месте тех членов, которые должны быть включены, стоит TRUE, на месте прочих - FALSE. Дополнительный аргумент diag (по умолчанию FALSE) определяет включать диагональ или нет. Более наглядно работа этих функций видна на примерах:

Зная логику работы функций несложно "отрезать" от имеющейся матрицы, например, нижний угол без диагонали:

Пример ниже демонстрирует:

Тензорное произведение матриц:

В R эта операция реализуется оператором %x% или функцией kron() из библиотеки fUtilities:

Для транспонирования матрицы нужно применить функцию t() :

Для получения следа матрицы применяется функция tr() из пакета fUtilities:

Для определения ранга матрицы используется функция qr()$rank:

Для вычисления определителя матрицы применяется функция det() :

Для получения обратной матрицы можно воспользоваться функциями solve() , inv() (пакет fUtilities) или ginv() (пакет MASS):

Из линейной алгебры известно, что система:

Этот алгоритм в коде R будет выглядеть следующим образом:

Теория этих терминов не совсем тривиальна, а потому рекомендуется ознакомиться с со статьёй Википедии "Собственные векторы, значения и пространства".

Для вычисления собственных элементов (чисел и векторов) следует применять функцию eigen() .

• Вычислить норму можно функцией norm() (пакет fUtilities).
• Проверить, что матрица положительно определена можно функцией isPositiveDefinite() (пакет fUtilities).
• Привести матрицу к положительно определённой форме можно функцией makePositiveDefinite() (пакет fUtilities).
• Вычленить верхний или нижний треугольник матрицы можно, соответственно, функциями Triang() и triang() (пакет fUtilities).

Также полезными могут оказать другие функции из пакетов matrix, matlab, matrixcalc и matrixStats.

• Вычислить степень числа можно двумя операторами (например, 10 3 > ):
  • 10^3
  • 10**3

  Смотрите также пакеты polynom и multipol.

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

  Вот несколько примеров:

  Смотрите документацию по пакету numDeriv (англ.) .

  Для взятия интегралов от многих переменных обратитесь к пакету cubature (так как пакет adapt был удалён из CRAN по лицензионным соображениям). Ранее механизм интегрирования применялся следующим образом (сейчас предполагается заменить функцию adapt() из пакета adapt на функцию adaptIntegrate() из пакета cubature, но лично я код не тестировал):

  Функция factorial() возвращает факториал натурального числа. Конечно, также, можно применить функцию prod() к вектору последовательных натуральных чисел от единицы.

  Значения факториала могут быть очень большими, и достаточно легко превысить лимиты ОС:

  Имеется возможность производить целочисленное деление:

  • Число Пи - встроенная константа pi .
  • Тригонометрические функции:
    • cos() ,
    • sin() ,
    • tan() .

    rSymPy (rsympy (англ.) ) предоставляет пакет функций sympy для R (link (англ.) ).

    Команда ?Special позволяет получить справку по специальным математическим функциям, например, таким как Бетта и Гамма функции.

    Матрицы в R можно создавать разными способами. Выбор способа зависит от того, какую матрицу мы хотим создать: пустую матрицу (чтобы потом заполнять ее нужными значениями) или матрицу, составленную из уже имеющихся значений, например, из векторов.

    Для того чтобы создать пустую матрицу, нужно определить, матрицу какой размерности мы хотим. Размерность матрицы – число строк и число столбцов в ней. Создадим для начала матрицу \(2 \times 3\) , состоящую из нулей:

    Можем посмотреть на ее размерность:

    Заполнять эту матрицу другими значениями мы пока не будем – это будет интереснее делать, когда мы узнаем про циклы. А сейчас посмотрим, как собрать матрицу из “готовых” векторов.
    Пусть у нас есть три вектора

    и мы хотим объединить их в матрицу. Векторы будут столбцами матрицы:

    А теперь векторы будут строками матрицы:

    Другой способ создавать матрицы - разбивать на строки один длинный вектор. Возьмем вектор:

    Посиотрим, сколько в нем элементов:

    А теперь превратим вектор в матрицу из трех строк и четырех столбцов:

    Конечно, если бы потребовали от R невозможное – матрицу, произведение числа строк и столбцов которой не равно длине вектора, из которого мы пытаемся эту матрицу создать – мы бы получили ошибку:

    Столбцам и строкам матрицы можно дать названия. Посмотрим еще раз на матрицу m1:

    А теперь дадим столбцам этом матрицы названия.

    А теперь назовем строки матрицы:

    Можно, конечно, присваивать названия сразу и строкам, и столбцам. Проделаем это с матрицей M_cols.

    О том, что такое list – поговорим чуть позже.

    Элементы матрицы

    Для того, чтобы обратиться к элементу матрицы, необходимо указать строку и столбец, на пересечении которых он находится:

    Если нам нужна отдельная строка (одна строка, все столбцы), то номер столбца нужно не указывать, просто оставить позицию пустой:

    Аналогично для столбцов:

    Списки

    Список предсталяет собой “вектор векторов” в терминах R. Для тех, кто знаком с программированием, может показаться, что списки похожи на массивы. Это так, но списки, в отличие от массивов, могут содержать элементы разных типов. Например, в списке может быть сохранен вектор имен студентов (текстовый, тип character) и вектор их оценок (целочисленный, тип integer).

    Пример списка с числовыми значениями:

    А вот пример списка с элементами разных типов:

    Так как в списках может храниться большое число разных векторов, для удобства им можно давать названия. Список grades можно было записать и так:

    И тогда отдельные вектора из списка можно было бы вызывать удобным образом:

    И если мы бы запросили у R структуру этого списка, мы бы увидели названия векторов, которые в него входят.

    Можно подумать: зачем нужно знать про списки, если на практике мы обычно будем сталкиваться с другими объектами – базами данных? На самом деле, со списками мы тоже будем встречаться. Многие статистические функции выдают результат в виде списков. Когда результаты выводятся на экран, это не всегда заметно, но если мы захотим заглянуть внутрь, то увидим, что та же регрессионная выдача представляет собой объект, похожий на список, из которого можно выбрать вектор коэффициентов (coefficients), вектор остатков (residuals), предсказанных значений (fitted.values) и так далее.

    А как обращаться к элементам списка, если вектора в нем никак не названы?

    Для обращения к элементам списка необходимо использовать двойные квадратные скобки:

    Если нужно обратиться к “элементу элемента” списка (например, к числу 8 в этом примере) нужно сначала указывать номер вектора, в котором находится элемент, а потом номер самого элемента в этом векторе.

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

    Для того, чтобы добавить элемент в список, нужно четко понимать положение элемента в этом списке: будет ли это элементом самого списка или “элементом элемента”:

    Аналогичным образом можно изменять элементы списка:

    Если в списке всего один элемент, при необходимости его можно быстро превратить в обычный вектор с помощью unlist() :

    То же можно делать и со списками из нескольких векторов, тогда все склеится в один длинный вектор:

    
    

    R — очень мощный язык, разработанный специально для анализа и визуализации данных и машинного обучения, что делает его обязательным к изучению для любого начинающего специалиста по данным.

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

    В этой вводной в статье про R рассмотрим следующие реализации линейной алгебры:

    Векторы

    • присваивание векторов;
    • векторные операции;
    • генерирование последовательностей;
    • логические векторы;
    • пропущенные значения;
    • индексирование векторов.

    Массивы и матрицы

    • массивы;
    • индексация массивов;
    • индексация матриц;
    • внешнее произведение двух матриц;
    • демонстрация всех возможных определителей одноразрядных матриц 2x2;
    • обобщённое транспонирование массива;
    • умножение матриц;
    • линейные уравнения и инверсия;
    • собственные значения и собственные векторы;
    • сингулярное разложение и определители;
    • выравнивание методом наименьших квадратов и QR-разложение;
    • формирование блочных матриц.

    Присваивание векторов

    R оперирует структурами данн ы х, самой простой из которых является числовой вектор — упорядоченный набор чисел. Чтобы создать вектор x с четырьмя элементами 1 , 2 , 3 и 4 , можно использовать объединяющую функцию c() .

    Здесь используется оператор присваивания <- , указывающий на назначаемый объект. В большинстве случаев <- можно заменить на = .

    Также можно использовать функцию assign() :

    Оператор <- считается сокращённым вариантом этой функции.

    Присваивание векторов работает и в обратном направлении:

    Векторные операции

    Векторы используются различными способами.

    Операция y <- c(x, 0, x) присвоит вектор 1, 2, 3, 4, 0, 1, 2, 3, 4 переменной y .

    Векторы можно свободно перемножать и дополнять константами:

    Заметьте, что эта операция верна, даже когда x и y имеют разную длину. В данном случае R просто будет повторять x (иногда дробно), пока не достигнет длины y. Поскольку y равен 9 числам в длину, а x — 4, x повторится 2.25 раз пока не совпадёт с длиной y.

    Можно использовать все арифметические операторы: + , - , * , / и ^ , а также log , exp , sin , cos , tan , sqrt и многие другие. max(x) и min(x) отображают наибольший и наименьший элементы вектора x , а length(x) — количество элементов x ; sum(x) выдаёт сумму всех элементов x , а prod(x) — их произведение.

    mean(x) вычисляет выборочное среднее, var(x) возвращает выборочную дисперсию, sort(x) возвращает вектор того же размера, что и x, элементы в котором расположены в порядке возрастания.

    Генерация последовательностей

    В R существует множество методов для генерации последовательностей чисел. 1:30 аналогичен c(1, 2, …, 29, 30) . Двоеточие имеет более высокий приоритет в выражении, поэтому 2*1:15 вернёт c(2, 4, …, 28, 30) , а не c(2, 3, …, 14, 15) .

    30:1 используется для генерации последовательности в обратном направлении.

    Для генерации последовательностей можно использовать и функцию seq() . seq(2,10) возвращает такой же вектор, что и 2:10 . В seq() , можно также указать длину шага: seq(1,2,by=0.5) возвращает c(1, 1.5, 2) .

    Аналогичная функция rep() копирует объект различными способами. Например, rep(x, times=5) вернёт пять копий x впритык.

    Логические векторы

    Логические значения в R — TRUE, FALSE и NA. Логические векторы задаются условиями. val <- x > 13 задаёт val в качестве вектора той же длины, что x , со значением TRUE , если условие выполняется, и FALSE , если нет.

    Логические операторы в R: < , <= , > , >= , == и != , означающие, соответственно, меньше чем, меньше чем или равно, больше чем, больше чем или равно, равно или не равно.

    Пропущенные значения

    Функция is.na(x) возвращает логический вектор того же размера, что и x , со значение TRUE , если соответствующий элемент для x равен NA .

    x == NA отличается от is.na(x) , поскольку NA является не значением, а маркером для недоступной величины.

    Второй тип “пропущенного значения” создаётся численными вычислениями, например 0/0 . В этом случае значения NaN (не числа) рассматриваются как значения NA , то есть is.na(x) вернёт TRUE и для NA , и для NaN значений. is.nan(x) используется только для определения значений NaN .

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

    Первый вид индексации — через логический вектор. y <- x[!is.na(x)] устанавливает y значениям x , не равным NA или NaN .

    (x+1)[(!is.na(x)) & x>0] -> z устанавливает z значениям x+1 , больше 0 и не являющимся Na или NaN .

    Второй метод осуществляется с вектором положительных целых значений. В этом случае значения должны быть в наборе . Для формирования результата соответствующие элементы вектора выбираются и объединяются в этом порядке. Важно помнить, что, в отличие от других языков, в R первый индекс равен 1, а не 0.

    x[1:10] возвращает первые 10 элементов x , предполагая, что length(x) не менее 10. c(‘x’, ‘y’)[rep(c(1,2,2,1), times=4)] создаёт символьный вектор длиной 16, где ‘x’, ‘y’, ‘y’, ‘x’ повторяются четыре раза.

    Вектор отрицательных целых чисел определяет значения, которые должны быть исключены. y <- x[-(1:5)] устанавливает y всем значениям x , кроме первых пяти.

    Наконец, вектор символьных строк может использоваться, когда у объекта есть атрибут name для идентификации его компонентов. Для <- c(1, 2, 3, 4) можно задать имя каждому индексу вектора names(fruit) <- c(‘mango’, ‘apple’, ‘banana’, ‘orange’) . Затем элементы можно вызывать по имени lunch <- fruit[c(‘apple’, ‘orange’)] .

    Преимущество этого подхода в том, что иногда буквенно-цифровые имена запомнить легче, чем индексы.

    Обратите внимание, что индексированное выражение может встречаться на принимающей стороне присвоения, где оно только для этих элементов вектора. Например, x[is.na(x)] <- 0 заменяет все значения NA и NaN в векторе x на 0 .

    Другой пример: y[y<0] <- -y[y<0] аналогичен y <- abs(y) — код просто заменяет все значения меньше 0 на отрицательные значения.

    Массивы

    Массив — это проиндексированный набор записей данных, не обязательно численный.

    Вектор размерности — это вектор неотрицательных чисел. Если длина равна k, тогда массив k-размерный. Размерности индексируются от единицы вверх до значения, указанного вектором размерности.

    Вектор может использоваться R в качестве массива, как атрибут dim . Если z — вектор из 1500 элементов, присвоение dim(z) <- c(100, 5, 3) означает, что z теперь представлен как массив 100 на 5 на 3.

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

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

    Первое значение вектора a — 3 на 4 на 6 — может быть вызвано как a[1, 1, 1] , а последнее как a[3, 4, 6] .

    a[,,] отображает массив полностью, следовательно, a[1,1,] берёт первую строку первого 2-размерного сечения a .

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

    Следующий код генерирует массив 4 на 5: x <- array(1:20, dim = c(4,5)) .

    Массивы определяются вектором значений и размерностью матрицы. Значения вычисляются сначала сверху вниз, затем слева направо.

    array(1:4, dim = c(2,2)) вернёт

    В матрицах индексов запрещены отрицательные индексы, а значения NA и ноль разрешены.

    Внешнее произведение двух матриц

    Важной операцией с векторами является внешнее произведение. Если a и b — это два численных массива, их внешним произведением является массив, вектор размерности которого получается объединением двух векторов размерности, а вектор данных достигается формированием всех возможных произведений элементов вектора данных a и элементов вектора b . Внешнее произведение вычисляется с помощью оператора %o% :

    Фактически любую функцию можно применить к двум массивам, используя внешнюю () функцию. Предположим, мы определили функцию f <- function(x, y) cos(y)/(1+x²) . Функцию можно применить к двум векторам x и y с помощью z <- outer(x, y, f) .

    Демонстрация всех возможных определителей одноразрядных матриц 2x2

    Рассмотрим определители матриц 2 на 2 [a, b; c, d], где каждая запись представляет собой неотрицательное число от 0 до 9. Задача: найти определители всех возможных матриц этой формы и отобразить на графике высокой плотности частоту, с которой встречается значение.

    Или, перефразируя, нужно найти распределение вероятности определителя, если каждая цифра выбирается независимо и равномерно случайным образом.

    Один из умных способов сделать это — использовать внешнюю функцию дважды.

    Первая строка присваивает d этой матрице:

    
    

    Вторая строка снова использует внешнюю функцию для расчёта всех возможных определителей. Последняя строка строит график.

    
    

    Обобщённое транспонирование массива

    Функция aperm(a, perm) используется для перестановки массива a. Аргументом perm должна быть перестановка чисел k>, где k — количество индексов в a. Результатом функции будет массив того же размера, что и a, но прежняя размерность, заданная perm[j] , становится новой размерностью j-th .

    Проще понять, если думать об этом как об обобщённом транспонировании матриц. Если A — это матрица, тогда B — просто результат перестановки матрицы A :

    В таких особых случаях перестановку осуществляет функция t() .

    Умножение матриц

    Для умножения матриц используется оператор %*% . Если A и B являются квадратными матрицами одинакового размера, A*B — это поэлементное произведение двух матриц. A %*% B — это скалярное произведение (произведение матриц).

    Если x — вектор, тогда x %*% A %*% x — его квадратичная форма.

    crossprod() осуществляет перекрёстные произведения. Таким образом crossprod(X, y) аналогична операции t(X) %*% y , но более эффективна.

    diag(v) , где v — вектор — задаёт диагональную матрицу с элементами вектора в качестве диагональных элементов. diag(M) , где m — матрица — задаёт вектор основных диагональных элементов M (так же как и в Matlab). diag(k) , где k — единичное числовое значение — возвращает единичную матрицу k на k .

    Линейные уравнения и инверсия

    Решение линейных уравнений является инверсией умножения матриц. Если

    с заданными только A и b , вектор x — решение системы линейных уравнений, которое быстро решается в R:

    Собственные значения и собственные векторы

    Функция eigen(Sm) вычисляет собственные значения и собственные векторы симметричной матрицы Sm. Результат — это список, где первый элемент отображает значения, а второй — векторы. ev <- eigen(Sm) присваивает этот список ev .

    ev$val — это вектор собственных значений Sm , и ev$vec — матрица соответствующих собственных векторов.

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

    Сингулярное разложение и определители

    Функция svd(m) принимает произвольный матричный аргумент m и вычисляет его сингулярное разложение. Оно состоит из 1) матрицы ортонормированных столбцов U с тем же пространством столбцов, что и m , 2) второй матрицы ортонормированных столбцов V , пространство столбцов которой является пространством строк m , 3) и диагональной матрицы положительных элементов D :

    det(m) используется для вычисления определителя квадратной матрицы m .

    Выравнивание методом наименьших квадратов и QR-разложение

    Функция lsfit() возвращает список заданных результатов процедуры выравнивания методом наименьших квадратов. Присваивание наподобие этого:

    выдаёт результаты выравнивания методом наименьших квадратов, где y — это вектор наблюдений, а X — проектная матрица.

    ls.diag() используется для диагностики регрессии.

    Тесно связанной функцией является qr().

    Они вычисляют ортогональную проекцию y на диапазон X в fit , проекцию на ортогональное дополнение в res и вектор коэффициентов для проекции в b .

    Формирование блочных матриц

    Матрицы можно строить из других векторов и матриц с помощью функций cbind() и rbind() .

    cbind() формирует матрицы, связывая матрицы горизонтально (поколоночно), а rbind() связывает матрицы вертикально (построчно).

    В присвоении X <- cbind(arg_1, arg_2, arg_3, …) аргументами cbind() должны быть либо векторы любой длины, либо столбцы одинакового размера (одинаковым количеством строк).

    
    

    Как мы знаем, массивы - это объекты, которые могут хранить две или более двумерных данных. В R массив Array имеет ту же концепцию, которая создается с помощью функции array (). Здесь данные хранятся в матрицах форм, строках и столбцах. Чтобы получить доступ к конкретному элементу из массива, необходимо указать индекс строки, индекс столбца и уровень матрицы.

    Матрицы, часто используемые в R, это особый тип 2-D массива.

    
    

    Наглядное представление: вектор, матрица, массив

    • Одномерный массив называется вектором.
    • Двумерный массив называется матрицей.

    Синтаксис:

    Вот синтаксис массива:

    Array_NAME <- array (data, dim = (row_Size, column_Size, matrices, dimnames)

    • data - Данные - это входной вектор, который подается в массив.
    • матрицы - это относится к размерности матриц. Массив в R может быть многомерной матрицей.
    • row_Size - row_Size отображает количество строк, из которых будет состоять массив.
    • column_Size - column_Size показывает количество столбцов, из которых будет состоять массив.
    • dimnames - это поле, если нужно изменить имена строк и столбцов по умолчанию на пожелания / предпочтения пользователя.

    Свойства:

    • Это однородно. Это означает, что он может хранить данные того же типа.
    • Хранит данные в непрерывной памяти
    • Доступ к элементам массива можно получить, зная номер индекса.

    Как создать массив в R?

    Ниже приведены различные сценарии создания массива в r следующим образом:

    Сценарий 1:

    Давайте создадим массив, который будет 3 × 4 матриц. Здесь 3 будут строки, а 4 будут столбцы, матрицы будут один. В качестве наших начальных шагов давайте оставим dimnames = NULL (это значение по умолчанию, если ничего не указано).

    Это одномерная матрица

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    print(array(c(vector1, vector2), dim = c(3, 4, 1)))

    Выход:

    
    

    Чтобы проверить, был ли создан наконец созданный массив или нет.

    Как только массив будет создан:

    Результат

    Функция «класс» может помочь вам в этом.

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    print(array(c(vector1, vector2), dim = c(3, 4, 1)))
    Result <- array(c(vector1, vector2), dim = c(3, 4, 1))
    class(Result)

    Выход:

    
    

    Чтобы проверить произведение измерения массива, можно использовать функцию: длина.

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    print(array(c(vector1, vector2), dim = c(3, 4, 1)))
    Result <- array(c(vector1, vector2), dim = c(3, 4, 1))
    length(Result)

    Выход:

    
    

    Сценарий 2:

    Давайте создадим тот же массив, который будет 3 × 4 матриц. Здесь снова 3 будет строкой, а 4 - столбцами, а матриц - двумя. Давайте сохраним dimnames = NULL (это значение по умолчанию, если ничего не указано).

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    print(array(c(vector1, vector2), dim = c(3, 4, 2)))

    Выход:

    
    

    Сценарий 3:

    Давайте создадим тот же массив, который будет 3 × 4 матриц. Здесь снова 3 будет строкой и 4 будет столбцами, но матриц будет два. Давайте посмотрим на значения, присвоенные dimnames.

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names ))

    Выход:

    
    

    Теперь мы хороши в создании массива любой размерности. Теперь давайте сосредоточимся на способе доступа к любому элементу в массиве.

    Как создать массив элементов доступа в R?

    Ниже приведены различные элементы доступа о том, как создать массив в r следующим образом:

    Сценарий 1:

    Допустим, у нас есть один и тот же массив в R:

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))

    Выход:

    
    

    Теперь нам нужно получить доступ к 3- й строке, 3- му столбцу второй матрицы в массиве.

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    result(3, 3, 2)

    Выход:

    
    

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

    Сценарий 2:

    Нужно получить доступ ко всей первой матричной матрице:

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    result(,, 1)

    Выход:

    
    

    Различные операции с массивами с примерами

    В этом разделе вы познакомитесь с различными операциями над массивами для достижения различных результатов.

    1. Сложение и вычитание:

    Многомерная матрица должна быть преобразована в одномерную матрицу, чтобы быть добавленной или вычтенной.

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    result(,, 1) result(,, 2) print(result(,, 1) + result(,, 2))

    Выход:

    
    

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    result(,, 1) result(,, 2) print(result(,, 1) - result(,, 2))

    
    

    2. Расчеты по элементу Array

    Имя функции apply (), помогает в применении любой операции к элементам массива.

    Синтаксис:

    apply(x, margin, fun)

    Здесь x - массив, поле здесь относится либо к строкам, либо к столбцам.

    • MARGIN = 1 для построчной операции
    • MARGIN = 2 для столбцов
    • MARGIN = c (1, 2) для обоих.

    Fun - это функция, применяемая ко всем элементам в массиве фрейма данных. Это могут быть стандартные функции, которые являются частью R или пользовательские функции (определяемые пользователем)

    Пример 1:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    result(,, 1) result(,, 2) apply(result(,, 1), 1, sum)

    Выход:

    
    

    Мудрый столбец - код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    result(,, 1) result(,, 2) apply(result(,, 1), 2, sum)

    Выход:

    
    

    Это дает вывод в векторной форме, которая содержит сумму отдельных столбцов. Здесь «сумма» является стандартной функцией R.

    Пример 2:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    result(,, 1) result(,, 2) apply(result(,, 1), 1, function(x) x+10)

    Выход:

    
    

    Это дает вывод того же измерения. Здесь следует отметить, что мы применили пользовательскую функцию. Эта функция очень полезна и эффективна при решении реальных проблем. Применяемая функция также является базовой для других сложных функций, таких как lapply (), rapply () и т. Д.

    3. Проверьте массив

    Проверьте массив, является ли объект массивом или нет. Имя функции is.array () является примитивной функцией, которая позволяет вам это делать. Это дает вывод в терминах True или False

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    result(,, 1) result(,, 2) is.array(result)

    Выход:

    
    

    4. Проверьте размер массива

    Знание размерности, количества строк, столбцов массива помогает в нарезке и копировании данных. Вот несколько функций для этого: dim, nrow, ncol

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    result <- array(c(vector1, vector2), dim = c(3, 4, 2))
    print(result)
    dim(result)
    nrow(result)
    ncol(result)

    Выход:

    
    

    5. Проверьте имена строк и столбцов

    Чтобы узнать имена строк, столбцов и имен измерений массива. Ниже показана его реализация.

    Код R:

    vector1 <- c(2, 18, 30)
    vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
    column.names <- c("COL1", "COL2", "COL3", "COL4")
    row.names <- c("ROW1", "ROW2", "ROW3")
    matrix.names <- c("Matrix1", "Matrix2")
    result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
    matrix.names))
    rownames(result)
    colnames(result)
    dimnames(result)

    Выход:

    
    

    Вывод:

    Изучение вышеуказанного содержимого дало бы вам четкое представление о массивах в R. R - это статистический язык, а массивы - часто используемые объекты данных. Это означает, что работа с различными операциями, такими как сложение, вычитание, применение и т. Д. С массивом в любом приложении, теперь станет для вас легкой прогулкой.

    Рекомендуемые статьи

    Это было руководство по Массиву в R. Здесь мы обсуждаем введение в Массивы в R, свойства R, как создать массив в R и некоторые примеры. Вы также можете просмотреть наши другие предлагаемые статьи, чтобы узнать больше -

    Читайте также:

      
    • Сети компьютеров в одном или нескольких соседних зданиях находящихся на небольшом расстоянии ответ 2
      
    • Bandicam как уменьшить размер видео
      
    • Irbis virago не заводится
      
    • Алгоритмика 4 класс урок 3 как загрузить файл с рисунком выполненным в point
      
    • Как включить звук в фл студио 20