Ruby/Справочник/Matrix

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

Детерминант может быть неверно вычислен, если не подключена библиотека mathn (командой require 'mathn'). Эта проблема может быть исправлена в будущем

Каталог методов

Создание матрицы:

• Matrix[*rows]
• Matrix.[](*rows)
• Matrix.rows(rows, copy = true)
• Matrix.columns(columns)
• Matrix.diagonal(*values)
• Matrix.scalar(n, value)
• Matrix.scalar(n, value)
• Matrix.identity(n)
• Matrix.unit(n)
• Matrix.I(n)
• Matrix.zero(n)
• Matrix.row_vector(row)
• Matrix.column_vector(column)

Доступ к элементам/столбцам/строкам/подматрицам матрицы:

• [](i, j)
• #row_size
• #column_size
• #row(i)
• #column(j)
• #collect
• #map
• #minor(*param)

Свойства матрицы:

• #regular?
• #singular?
• #square?

Матричная арифметика:

• *(m)
• +(m)
• -(m)
• #/(m)
• #inverse
• #inv
• **

Матричные функции:

• #determinant
• #det
• #rank
• #trace
• #tr
• #transpose
• #t

Преобразования в другие типы данных:

• #coerce(other)
• #row_vectors
• #column_vectors
• #to_a

Строковые представления:

• #to_s
• #inspect

Примеси

ExceptionForMatrix ()

Методы класса

[], column_vector, columns, diagonal, identity, row_vector, rows, scalar, zero

Методы объекта

[], **, *, +, -, /, ==, clone, coerce, collect, column_size, column_vectors, column, compare_by_row_vectors, determinant, det, eql?, hash, inspect, inverse_from, inverse, inv, map, minor, rank, regular?, row_size, row_vectors, row, singular?, square?, to_a, to_s, trace, transpose, tr, t

Matrix::[](*rows)    #-> matrix

Создает матрицу, где каждый из переданных аргументов *rows интерпретируется как строка (в смысле "ряд").

Matrix[[25, 93], [-1, 66]]   #-> Matrix[[25, 93], [-1, 66]]

Matrix::column_vector(column)   #-> matrix

Создает матрицу, состоящую из одного столбца, значения которого берутся из параметра column.

Matrix.column_vector([4, 5, 6])   #-> Matrix[[4], [5], [6]]

Matrix::columns(columns)

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

Matrix.columns([[25, 93], [-1, 66]])   #-> Matrix[[25, -1], [93, 66]]

Matrix::diagonal(*values)   #-> matrix

Создает матрицу, в которой переданные аргументы *values расположены по главной диагонали.

Matrix.diagonal(9, 5, -3)   #-> Matrix[[9, 0, 0], [0, 5, 0], [0, 0, -3]]

Matrix::identity(n)   #-> matrix

Создает единичную матрицу размерности n.

Matrix.identity(2)   #-> Matrix[[1, 0], [0, 1]]

Matrix::row_vector(row)   #-> matrix

Создает однострочную матрицу, значения которой берутся из row.

Matrix.row_vector([4, 5, 6])   #-> Matrix[[4, 5, 6]]

Matrix::rows(rows, copy = true)   #-> matrix

Создает матрицу на основании данных двумерного массива rows каждый подмассив которого интерпретируется как строка матрицы. Если опциональный параметр copy равен false, то передаваемый массив rows будет использован внутри стурктуры матрицы без предварительного копирования.

Matrix.rows([[25, 93], [-1, 66]])   #-> Matrix[[25, 93], [-1, 66]]

Matrix::scalar(n, value)   #-> matrix

Создает матрицу размером n на n, где каждый элемент главной диагонали равен value.

Matrix.scalar(2, 5)   #-> Matrix[[5, 0], [0, 5]]

Matrix::zero(n)   #-> matrix

Создает нулевую матрицу размерностью n на n.

Matrix.zero(2)   #-> Matrix[[0, 0], [0, 0]]

m * other   #-> matrix

Матричное умножение.

Matrix[[2, 4], [6, 8]] * Matrix.identity(2)   #-> Matrix[[2, 4], [6, 8]]

m ** n   #-> matrix

Матричное возведение в степень. Эквивалентно перемножению матрицы саму на себя n-раз.

Matrix[[7,6], [3,9]] ** 2   #-> Matrix[[67, 96], [48, 99]]

m + other   #-> matrix

Матричное сложение.

Matrix.scalar(2, 5) + Matrix[[1, 0], [-4, 7]]   #-> Matrix[[6, 0], [-4, 12]]

m - other   #-> matrix

Матричное вычитание.

Matrix[[1, 5], [4, 2]] - Matrix[[9, 3], [-4, 1]]   #-> Matrix[[-8, 2], [8, 1]]

m / other   #-> matrix

Матричное деление (то есть умножение на обратную матрицу).

Matrix[[7, 6], [3, 9]] / Matrix[[2, 9], [3, 1]]   #-> Matrix[[-7, 1], [-3, -6]]

m == other   #-> matrix

Возвращает true, если в матрицах m и other соответствующие элементы равны.

Matrix[[7,6], [3,9]] == Matrix[[7,6], [3,9]]      #-> true
Matrix[[14,12], [6,18]] == Matrix[[7,6], [3,9]]   #-> false

Методы == и eql? — абсолютно идентичны, то есть являются именами одного и того же метода

m[i,j]   #-> numeric

Возвращает элемент матрицы с индексами (i, j), где i — номер строки, а j — номер столбца.

m.clone   #-> matrix

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

m.coerce(other)   #-> array

Возвращает массив, в котором other преобразован к классу Matrix::Scalar, а второй элемент — исходная матрица m.

Matrix[[14,12], [6,18]].coerce 5
   #-> [#<Matrix::Scalar:0xc6d7048 @value=5>, Matrix[[14, 12], [6, 18]]]
Matrix[[14,12], [6,18]].coerce 12.2
   #-> [#<Matrix::Scalar:0xc6c9664 @value=12.2>, Matrix[[14, 12], [6, 18]]]

m.collect{|e| ... }   #-> matrix

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

Matrix[ [1,2], [3,4] ].collect { |i| i**2 }   #-> Matrix[[1, 4], [9, 16]]

Методы map и collect — абсолютно идентичны, то есть являются именами одного и того же метода

m.column(j)             #-> vector
m.column(j){|e| ... }   #-> 0

Возвращает столбец j матрицы m в виде объекта класса Vector (нумерация столбцов начинается с 0, как в массивах). Если используется вызов метода с блоком, то метод вызывает блок для каждого элемента полученного вектора и возвращает 0 (что вопиюще неверно и должно быть исправлено).

Полезно посмотреть на метод row, который имеет схожую функциональность

m.column_size   #-> integer

Возвращает число столбцов матрицы m. Заметим, что метод можно вызвать для матрицы с неравным количеством столбцов (то есть Matrix[ [1,2,3], [4,5] ]), но это будет математически неверно. Метод возвращает количество столбцов первой строки (то есть с индексом 0) в качестве результата.

Matrix[[1, 2, 3], [4, 5]].column_size   #-> 3
Matrix[[1, 2], [3, 4, 5]].column_size   #-> 2

Полезно посмотреть на метод row_size, который имеет схожую функциональность

m.column_vectors   #-> array

Возвращает массив столбцов матрицы в виде векторов.

Полезно посмотреть на метод row_vectors, который имеет схожую функциональность

m.compare_by_row_vectors(rows)   #-> true или false

Используется внутри библиотеки mathn.rb для выполнения сравнения матриц (в методах == и eql?). Параметр rows -- это двумерный массив элементов (который можно получить при помощи метода to_a).

m = Matrix[ [1,2], [3,4,5] ]
m.compare_by_row_vectors( [[25, 93], [-1, 66]] )   #-> false
m.compare_by_row_vectors( m.to_a )                 #-> true
m.compare_by_row_vectors( [[1, 2], [3, 4, 5]] )    #-> true

m.det   #-> integer

Методы det и determinant — абсолютно идентичны, то есть являются именами одного и того же метода

m.determinant   #-> integer

Возвращает детерминант матрицы m. Если матрица m не является квадратной, то возвращает 0.

Matrix[[7,6], [3,9]].determinant   #-> 63

Методы det и determinant — абсолютно идентичны, то есть являются именами одного и того же метода

m.eql?(other)   #-> true или false

Возвращает true, если в матрицах m и other соответствующие элементы равны.

m.hash   #-> fixnum

Возвращает контрольную сумму для матрицы m.

m.inspect   #-> string

Переопределяет метод Object#inspect.

m.inv   #-> matrix

Методы inv и inverse — абсолютно идентичны, то есть являются именами одного и того же метода

m.inverse   #-> matrix

Возвращает обратную матрицу для матрицы m.

Matrix[[1, 2], [2, 1]].inverse   #-> Matrix[[-1, 1], [0, -1]]

Методы inv — абсолютно идентичны, то есть являются именами одного и того же метода

m.inverse_from(src)   #-> matrix

Используется внутри библиотеки matrix.rb для вычисления обратной матрицы. Но зачем использовать именно его, если есть inv, который гораздо удобнее (и короче)?

m = Matrix[[1, 2], [2, 1]]
m.inv                                  #-> Matrix[[-1, 1], [0, -1]]
Matrix.I(m.row_size).inverse_from(m)   #-> Matrix[[-1, 1], [0, -1]]

Полезно посмотреть на методы inv и inverse, которые имеют схожую функциональность

m.map{|e| ... }   #-> matrix

Методы map и collect — абсолютно идентичны, то есть являются именами одного и того же метода

m.minor(*param)   #-> matrix

Возвращает подматрицу матрицы m, где координаты задаются следующим образом:

• start_row, nrows, start_col, ncols (координата и отклонение по каждому измерению)
• col_range, row_range (через диапазоны)

Matrix.diagonal(9, 5, -3).minor(0..1, 0..2) #-> Matrix[[9, 0, 0], [0, 5, 0]]

m.rank   #-> integer

Возвращает ранг матрицы m. Остерегайтесь использовать для матриц с действительными числами, так как из-за погрешности вычислений ранг может быть вычислен неверно. Лучше используйте рациональные числа, если это возможно.

Matrix[[7,6], [3,9]].rank   #-> 2

m.regular?   #-> true или false

Возвращает true, если m является невырожденной матрицей.

Matrix[[1]].regular?          #-> true
Matrix[[1,2]].regular?        #-> false
Matrix[[1,2],[3,4]].regular?  #-> true
Matrix[[1,2],[3]].regular?    #-> NoMethodError

Полезно посмотреть на метод singular?, который имеет схожую функциональность

m.row(i)             #-> vector
m.row(i){|e| ... }   #-> 0

Возвращает строку i матрицы m в виде объекта класса Vector (нумерация строк начинается с 0, как в массивах). Если используется вызов метода с блоком, то метод вызывает блок для каждого элемента полученного вектора и возвращает 0 (что вопиюще неверно и должно быть исправлено).

Полезно посмотреть на метод column, который имеет схожую функциональность

m.row_size   #-> integer

Возвращает количество строк матрицы m.

Полезно посмотреть на метод column_size, который имеет схожую функциональность

m.row_vectors   #-> array

Возвращает массив строк матрицы в виде векторов.

Полезно посмотреть на метод column_vectors, который имеет схожую функциональность

m.singular?   #-> true или false

Возвращает true, если m является невырожденной матрицей.

Matrix[[1]].singular?          #-> false
Matrix[[1,2]].singular?        #-> true
Matrix[[1,2],[3,4]].singular?  #-> false
Matrix[[1,2],[3]].singular?    #-> NoMethodError

Полезно посмотреть на метод regular?, который имеет схожую функциональность

m.square?   #-> true или false

Возвращает true, если m является квадратной матрицей (то есть число строк в которой равняется количеству столбцов).

Matrix[[1]].square?          #-> true
Matrix[[1,2]].square?        #-> false
Matrix[[1,2],[3,4]].square?  #-> true
Matrix[[1,2],[3]].square?    #-> true

m.t   #-> matrix

Методы t и transpose — абсолютно идентичны, то есть являются именами одного и того же метода

m.to_a   #-> array

Возвращает двумерный массив, состоящий из элементов матрицы m.

m.to_s   #-> string

Переопределяет метод Object#to_s.

m.tr   #-> integer

Методы tr и trace — абсолютно идентичны, то есть являются именами одного и того же метода

m.trace   #-> integer

Возвращает сумму диагональных элементов матрицы m (так называемый след матрицы).

Matrix[[7,6], [3,9]].trace   #-> 16

Методы tr и trace — абсолютно идентичны, то есть являются именами одного и того же метода

m.transpose   #-> matrix

Возвращает результат транспонирования матрицы m.

m = Matrix[[1,2], [3,4], [5,6]]
m.transpose   #-> Matrix[[1, 3, 5], [2, 4, 6]]

Методы t и transpose — абсолютно идентичны, то есть являются именами одного и того же метода