18.3 Матричные разложения

: R = chol (A)

: [R, p] = chol (A)

: [R, p, Q] = chol (A)

: [R, p, Q] = chol (A, "vector")

: [L, …] = chol (…, "lower")

: [R, …] = chol (…, "upper")

Вычисляет верхний множитель Холецкого R действительной симметричной или комплексной эрмитовой положительно определённой матрицы A.

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

R' * R = A.

Вызов chol с необязательным флагом "upper" выполняет те же действия. Напротив, при использовании необязательного флага "lower" функция chol возвращает нижнее треугольное разложение, вычисленное с использованием нижней треугольной части матрицы A, такое что

L * L' = A.

При вызове с одним выходным аргументом chol завершается ошибкой, если матрица A не является положительно определённой. Обратите внимание: если матрица A не является действительной симметричной или комплексной эрмитовой, нижняя треугольная часть считается (комплексно-сопряжённым) транспонированием верхней треугольной части, или наоборот — в зависимости от флага "lower".

При вызове с двумя или более выходными аргументами p указывает, является ли матрица A положительно определённой; функция chol не завершается ошибкой. Нулевое значение p означает, что матрица A положительно определённая, а R содержит разложение. В противном случае p будет иметь положительное значение.

При вызове с тремя выходными аргументами матрица A должна быть разреженной; перед разложением к ней применяется сохраняющая разреженность перестановка строк/столбцов. То есть R является разложением A(Q,Q) таким, что

R' * R = Q' * A * Q.

Сохраняющая разреженность перестановка обычно возвращается в виде матрицы. Однако при указании необязательного флага "vector" значение Q возвращается в виде вектора, такого что

R' * R = A(Q, Q).

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

См. также: hess, lu, qr, qz, schur, svd, ichol, cholinv, chol2inv, cholupdate, cholinsert, choldelete, cholshift.

: Ainv = cholinv (A)

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

См. также: chol, chol2inv, inv.

: Ainv = chol2inv (R)

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

Обратите внимание, что R должна быть верхней треугольной матрицей с положительными диагональными элементами. chol2inv (U) предоставляет inv (R'*R), но работает намного быстрее, чем inv.

См. также: chol, cholinv, inv.

: [R1, info] = cholupdate (R, u, op)

Обновляет или понижает разложение Холецкого.

Для верхней треугольной матрицы R и вектора-столбца u пытается определить другую верхнюю треугольную матрицу R1, такую что

• R1’*R1 = R’*R + u*u’ если op равен "+"
• R1’*R1 = R’*R - u*u’ если op равен "-"

Если op равен "-", для info устанавливается одно из значений:

• 0, если понижение выполнено успешно;
• 1, если R’*R - u*u’ не является положительно определённой;
• 2, если R является вырожденной.

Если аргумент info отсутствует, в случаях 1 и 2 выводится сообщение об ошибке.

См. также: chol, cholinsert, choldelete, cholshift.

: R1 = cholinsert (R, j, u)

: [R1, info] = cholinsert (R, j, u)

Обновляет разложение Холецкого при заданной строке или столбце, который необходимо вставить в исходную разложенную матрицу.

Для разложения Холецкого действительной симметричной или комплексной эрмитовой положительно определённой матрицы A = R’*R, где R — верхняя треугольная матрица, возвращает разложение Холецкого матрицы A1, где A1(p,p) = A, A1(:,j) = A1(j,:)’ = u и p = [1:j-1,j+1:n+1]. u(j) должен быть положительным.

При возврате для info устанавливается одно из значений:

• 0, если вставка выполнена успешно;
• 1, если A1 не является положительно определённой;
• 2, если R является вырожденной.

Если аргумент info отсутствует, в случаях 1 и 2 выводится сообщение об ошибке.

См. также: chol, cholupdate, choldelete, cholshift.

: R1 = choldelete (R, j)

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

Для разложения Холецкого действительной симметричной или комплексной эрмитовой положительно определённой матрицы A = R’*R, где R — верхняя треугольная матрица, возвращает разложение Холецкого матрицы A(p,p), где p = [1:j-1,j+1:n+1].

См. также: chol, cholupdate, cholinsert, cholshift.

: R1 = cholshift (R, i, j)

Обновляет разложение Холецкого при заданном диапазоне столбцов, которые необходимо переместить в исходной разложенной матрице.

Для разложения Холецкого действительной симметричной или комплексной эрмитовой положительно определённой матрицы A = R’*R, где R — верхняя треугольная матрица, возвращает разложение Холецкого матрицы A(p,p), где p — перестановка
p = [1:i-1, shift(i:j, 1), j+1:n] если i < j
или
p = [1:j-1, shift(j:i,-1), i+1:n] если j < i.

См. также: chol, cholupdate, cholinsert, choldelete.

: H = hess (A)

: [P, H] = hess (A)

Вычисляет разложение Хессенберга матрицы A.

Разложение Хессенберга имеет вид P * H * P' = A, где P — квадратная унитарная матрица (P' * P = I, с использованием комплексно-сопряжённого транспонирования), а H — верхняя матрица Хессенберга (H(i, j) = 0 forall i > j+1).

Разложение Хессенберга обычно используется как первый шаг при вычислении собственных значений, но имеет и другие применения (см. Golub, Nash и Van Loan, IEEE Transactions on Automatic Control, 1979).

См. также: eig, chol, lu, qr, qz, schur, svd.

: [L, U] = lu (A)

: [L, U, P] = lu (A)

: [L, U, P, Q] = lu (S)

: [L, U, P, Q, R] = lu (S)

: […] = lu (S, thresh)

: y = lu (…)

: […] = lu (…, "vector")

Вычисляет LU-разложение матрицы A.

Для плотной матрицы A используются подпрограммы из LAPACK, а для разреженной матрицы A — UMFPACK.

Результат возвращается в переставленном виде в соответствии с необязательным возвращаемым значением P. Например, для матрицы A = [1, 2; 3, 4],

[L, U, P] = lu (A)

возвращает

L =

  1.00000  0.00000
  0.33333  1.00000

U =

  3.00000  4.00000
  0.00000  0.66667

P =

  0  1
  1  0

Матрица не обязательно должна быть квадратной.

При вызове с двумя или тремя выходными аргументами и разреженной входной матрицей функция lu не пытается выполнять перестановки столбцов, сохраняющие разреженность. При вызове с четвёртым выходным аргументом возвращается сохраняющее разреженность преобразование столбцов Q, такое что P * A * Q = L * U. Это предпочтительный способ вызова lu с разреженными входными матрицами.

При вызове с пятым выходным аргументом и разреженной входной матрицей функция lu пытается применить к входной матрице масштабный коэффициент R, такой что P * (R \ A) * Q = L * U. Обычно это приводит к более разреженному и устойчивому разложению.

Можно указать дополнительный входной аргумент thresh, задающий порог выбора ведущего элемента. thresh может быть скаляром; в этом случае он задаёт допуск выбора ведущего элемента UMFPACK как для симметричных, так и для несимметричных случаев. Если thresh — вектор из двух элементов, первый элемент задаёт допуск выбора ведущего элемента для несимметричной стратегии UMFPACK, а второй — для симметричной стратегии. По умолчанию используются значения, определённые spparms ([0.1, 0.001]).

При задании строкового аргумента "vector" функция lu возвращает значения P и Q в виде векторов, таких что для плотной матрицы A(P,:) = L * U и R(P,:) * A(:,Q) = L * U.

С двумя выходными аргументами возвращаются переставленные формы верхней и нижней треугольных матриц, такие что A = L * U. С одним выходным аргументом y возвращается матрица, возвращаемая подпрограммами LAPACK. Если входная матрица разреженная, матрица L встраивается в U, чтобы получить возвращаемое значение, аналогичное случаю плотной матрицы. Для плотных и разреженных матриц функция lu теряет информацию о перестановке.

См. также: luupdate, ilu, chol, hess, qr, qz, schur, svd.

: [L, U] = luupdate (L, U, x, y)

: [L, U, P] = luupdate (L, U, P, x, y)

Для LU-разложения действительной или комплексной матрицы A = L*U, где L — нижняя единичная трапецеидальная матрица, а U — верхняя трапецеидальная матрица, возвращает LU-разложение матрицы A + x*y.’, где x и y — векторы-столбцы (обновление ранга 1) или матрицы с одинаковым числом столбцов (обновление ранга k).

Можно использовать обновление с выбором ведущего элемента по строкам, указав матрицу перестановки строк (выбора ведущего элемента) P; в этом случае возвращается обновлённая матрица перестановки. Обратите внимание: если L, U, P — LU-разложение с выбором ведущего элемента, полученное с помощью lu:

[L, U, P] = lu (A);

тогда разложение A+x*y.' можно получить одним из следующих способов:

[L1, U1] = lu (L, U, P*x, y)

или

[L1, U1, P1] = lu (L, U, P, x, y)

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

Обработка матриц выполняется как последовательность обновлений ранга 1; поэтому при достаточно большом k быстрее и точнее будет вычислить разложение заново.

См. также: lu, cholupdate, qrupdate.

: [Q, R] = qr (A)

: [Q, R, P] = qr (A)

: X = qr (A) # non-sparse A

: R = qr (A) # sparse A

: X = qr (A, B) # sparse A

: [C, R] = qr (A, B)

: […] = qr (…, 0)

: […] = qr (…, "econ")

: […] = qr (…, "vector")

: […] = qr (…, "matrix")

Вычисляет QR-разложение матрицы A с помощью стандартных подпрограмм LAPACK.

QR-разложение имеет вид

Q * R = A

где Q — ортогональная матрица, а R — верхняя треугольная матрица.

Например, для матрицы A = [1, 2; 3, 4],

[Q, R] = qr (A)

возвращает

Q =

  -0.31623  -0.94868
  -0.94868   0.31623

R =

  -3.16228  -4.42719
   0.00000  -0.63246

произведение которых даёт исходную матрицу

Q * R
  ⇒
     1.0000   2.0000
     3.0000   4.0000

Если запрошено только одно возвращаемое значение, это либо R, если A разреженная, либо X, такое что R = triu (X), если A плотная. (Примечание: в отличие от большинства команд, при запросе нескольких значений единственное возвращаемое значение не является первым из них.)

Если запрошен третий выходной аргумент P, функция qr вычисляет переставленное QR-разложение

Q * R = A * P

где Q — ортогональная матрица, R — верхняя треугольная матрица, а P — матрица перестановки.

Если A — плотная матрица, переставленное QR-разложение обладает дополнительным свойством: диагональные элементы R упорядочены по убыванию абсолютной величины. Иными словами, abs (diag (R)) будут упорядочены от наибольшего к наименьшему.

Если A — разреженная матрица, P представляет собой упорядочение столбцов A, уменьшающее заполнение. В этом случае диагональные элементы R не упорядочены по убыванию абсолютной величины.

Например, для матрицы A = [1, 2; 3, 4],

[Q, R, P] = qr (A)

возвращает

Q =

  -0.44721  -0.89443
  -0.89443   0.44721

R =

  -4.47214  -3.13050
   0.00000   0.44721

P =

   0  1
   1  0

Если входная матрица A разреженная, разреженное QR-разложение вычисляется с помощью SPQR или CXSPARSE (например, если SPQR недоступен). Поскольку матрица Q в общем случае является плотной, рекомендуется запрашивать только одно возвращаемое значение R. В этом случае при вычислении не строится Q, а возвращается разреженная матрица R, такая что R = chol (A' * A).

Если A — плотная матрица, задана дополнительная матрица B и запрошены два возвращаемых значения, функция qr возвращает C, где C = Q' * B. Это позволяет вычислить наименьшее квадратичное приближение A \ B следующим образом:

[C, R] = qr (A, B)
X = R \ C

Если A — разреженная матрица размера MxN и задана дополнительная матрица B, можно запросить одно или два возвращаемых значения. Если запрошено одно возвращаемое значение X и M < N, X является решением A \ B с минимальной нормой 2. Если M >= N, X является наименьшим квадратичным приближением A \ B. Если запрошены два возвращаемых значения, C и R имеют тот же смысл, что и для плотной матрицы (C — плотная, а R — разреженная). Следует предпочитать вариант с одним возвращаемым параметром, поскольку он использует меньше памяти и лучше обрабатывает матрицы с неполным рангом.

Если последний аргумент — строка "vector", P является вектором перестановки (столбцов A), а не матрицей перестановки. В этом случае определяющее соотношение имеет вид:

Q * R = A(:, P)

По умолчанию возвращается матрица перестановки; это также можно явно указать, задав в качестве последнего аргумента "matrix".

Если последний аргумент — скаляр 0 или строка "econ", возвращается экономное разложение. Если исходная матрица A имеет размер MxN и M > N, при экономном разложении вычисляются только N строк матрицы R и N столбцов матрицы Q, а нули в R опускаются. Если M ≤ N, экономное разложение не отличается от стандартного. При вычислении экономного разложения плотной матрицы A выходное значение P всегда является вектором, а не матрицей. Если A разреженная, выходное значение P представляет собой разреженную матрицу перестановки.

Справка. QR-разложение применяется при решении задач наименьших квадратов

min norm (A*x - b)

для переопределённых систем уравнений (то есть когда A — высокая узкая матрица).

Переставленное QR-разложение [Q, R, P] = qr (A) позволяет построить ортогональный базис для span (A).

См. также: chol, hess, lu, qz, schur, svd, qrupdate, qrinsert, qrdelete, qrshift.

: [Q1, R1] = qrupdate (Q, R, u, v)

Обновляет QR-разложение по векторам или матрицам обновления.

Для QR-разложения действительной или комплексной матрицы A = Q*R, где Q унитарная, а R — верхняя трапецеидальная матрица, возвращает QR-разложение матрицы A + u*v’, где u и v — векторы-столбцы (обновление ранга 1) или матрицы с одинаковым числом столбцов (обновление ранга k). Обратите внимание, что во втором случае операция выполняется как последовательность обновлений ранга 1; поэтому при достаточно большом k быстрее и точнее будет вычислить разложение заново.

Передаваемое QR-разложение может быть полным (Q — квадратная матрица) или экономным (R — квадратная матрица).

См. также: qr, qrinsert, qrdelete, qrshift.

: [Q1, R1] = qrinsert (Q, R, j, x, orient)

Обновляет QR-разложение при заданной строке или столбце, который необходимо вставить в исходную разложенную матрицу.

Для QR-разложения действительной или комплексной матрицы A = Q*R, где Q унитарная, а R — верхняя трапецеидальная матрица, возвращает QR-разложение [A(:,1:j-1) x A(:,j:n)], где u — вектор-столбец, который необходимо вставить в A (если orient равен "col"), либо QR-разложение [A(1:j-1,:);x;A(:,j:n)], где x — вектор-строка, который необходимо вставить в A (если orient равен "row").

Значение orient по умолчанию — "col". Если orient равен "col", u может быть матрицей, а j — вектором индексов; в результате получается QR-разложение матрицы B, такой что B(:,j) содержит u, а B(:,j) = [] даёт A. Обратите внимание, что во втором случае операция выполняется как последовательность из k вставок; поэтому при достаточно большом k быстрее и точнее будет вычислить разложение заново.

Если orient равен "col", передаваемое QR-разложение может быть полным (Q — квадратная матрица) или экономным (R — квадратная матрица).

Если orient равен "row", требуется полное разложение.

См. также: qr, qrupdate, qrdelete, qrshift.

: [Q1, R1] = qrdelete (Q, R, j, orient)

Обновляет QR-разложение при заданной строке или столбце, который необходимо удалить из исходной разложенной матрицы.

Для QR-разложения действительной или комплексной матрицы A = Q*R, где Q унитарная, а R — верхняя трапецеидальная матрица, возвращает QR-разложение [A(:,1:j-1), U, A(:,j:n)], где u — вектор-столбец, который необходимо вставить в A (если orient равен "col"), либо QR-разложение [A(1:j-1,:);X;A(:,j:n)], где x — строка, а orient равен "row"). Значение orient по умолчанию — "col".

Если orient равен "col", j может быть вектором индексов; в результате получается QR-разложение матрицы B, такой что A(:,j) = [] даёт B. Обратите внимание, что во втором случае операция выполняется как последовательность из k удалений; поэтому при достаточно большом k быстрее и точнее будет вычислить разложение заново.

Если orient равен "col", передаваемое QR-разложение может быть полным (Q — квадратная матрица) или экономным (R — квадратная матрица).

Если orient равен "row", требуется полное разложение.

См. также: qr, qrupdate, qrinsert, qrshift.

: [Q1, R1] = qrshift (Q, R, i, j)

Обновить QR-разложение, задав диапазон столбцов исходной матрицы, которые нужно переместить.

Для QR-разложения действительной или комплексной матрицы A = Q*R, где Q — унитарная матрица, а R — верхняя трапецеидальная матрица, вернуть QR-разложение A(:,p), где p — перестановка
p = [1:i-1, shift(i:j, 1), j+1:n], если i < j
или
p = [1:j-1, shift(j:i,-1), i+1:n], если j < i.

См. также: qr, qrupdate, qrinsert, qrdelete.

: [AA, BB, Q, Z, V, W] = qz (A, B)

: [AA, BB, Q, Z, V, W] = qz (A, B, opt)

Вычислить QZ-разложение обобщённой задачи на собственные значения.

Обобщённая задача на собственные значения определяется как

A x = lambda B x

Функция может вызываться двумя способами:

1. [AA, BB, Q, Z, V, W] = qz (A, B)

   Вычислить комплексное QZ-разложение, обобщённые собственные векторы и обобщённые собственные значения.

   AA = Q * A * Z, BB = Q * B * Z
   A * V * diag (diag (BB)) = B * V * diag (diag (AA))
   diag (diag (BB)) * W' * A = diag (diag (AA)) * W' * B

   где AA и BB — верхние треугольные матрицы, а Q и Z — унитарные матрицы. Матрицы V и W содержат соответственно правые и левые обобщённые собственные векторы.

2. [AA, BB, Q, Z, V, W] = qz (A, B, opt)

   Аргумент opt должен быть равен либо "real", либо "complex". Если он равен "complex", этот способ вызова эквивалентен первому способу с двумя входными аргументами.

   Если opt равен "real", вычисляется действительное QZ-разложение. В частности, гарантируется лишь то, что AA является квази-верхней треугольной матрицей с блоками размером 1 на 1 и 2 на 2 на диагонали, а Q и Z — ортогональными матрицами. Указанные выше соотношения для правых и левых обобщённых собственных векторов выполняются только в том случае, если AA является верхней треугольной матрицей (то есть когда все обобщённые собственные значения действительны; в этом случае действительное и комплексное QZ-разложения совпадают).

Примечание: qz выполняет балансировку перестановками, но не масштабирование (см. balance), поэтому результаты могут быть менее точными, чем у eig. Порядок выходных аргументов выбран для совместимости с MATLAB.

Чтобы получить собственные значения, используйте функцию ordeig, вычисляющую их по результирующим матрицам AA и BB.

См. также: eig, gsvd, balance, chol, hess, lu, qr, qzhess, schur, ordeig.

: [aa, bb, q, z] = qzhess (A, B)

Вычислить разложение матричного пучка (A, B) на матрицу Хессенберга и верхнюю треугольную матрицу, вернув aa = q * A * z, bb = q * B * z, где q и z — ортогональные матрицы.

Например:

[aa, bb, q, z] = qzhess ([1, 2; 3, 4], [5, 6; 7, 8])
  ⇒ aa =
      -3.02244  -4.41741
       0.92998   0.69749
  ⇒ bb =
      -8.60233  -9.99730
       0.00000  -0.23250
  ⇒ q =
      -0.58124  -0.81373
      -0.81373   0.58124
  ⇒ z =
     Diagonal Matrix
       1   0
       0   1

Разложение на матрицу Хессенберга и верхнюю треугольную матрицу — первый шаг алгоритма QZ Молера и Стюарта.

Алгоритм взят из книги Голуба и Ван Лоана Matrix Computations, 2nd edition.

См. также: lu, chol, hess, qr, qz, schur, svd.

: S = schur (A)

: S = schur (A, "real")

: S = schur (A, "complex")

: S = schur (A, opt)

: [U, S] = schur (…)

Вычислить разложение Шура матрицы A.

Разложение Шура квадратной матрицы A определяется как

S = U' * A * U

где U — унитарная матрица (U'* U — единичная матрица), а S — верхняя треугольная матрица. Собственные значения A (и S) являются диагональными элементами S. Если матрица A действительная, вычисляется действительное разложение Шура, в котором матрица U ортогональна, а S — блочная верхняя треугольная матрица с блоками размером не более 2 x 2 на диагонали.

Для действительных матриц по умолчанию вычисляется действительное разложение Шура. Комплексное разложение можно принудительно получить, передав флаг "complex".

При необходимости собственные значения упорядочиваются на диагонали в соответствии со значением opt:

opt = "a"

Переместить собственные значения с отрицательными действительными частями в начальный блок S. Мнемоническое обозначение: "a" — для алгебраических уравнений Риккати, где такое упорядочение полезно.

opt = "d"

Переместить собственные значения с модулем меньше единицы в начальный блок S. Мнемоническое обозначение: "d" — для дискретных алгебраических уравнений Риккати, где такое упорядочение полезно.

opt = "u"

Без упорядочения. Особый порядок собственных значений не задаётся (по умолчанию).

Первые k столбцов U всегда натягивают A-инвариантное подпространство, соответствующее первым k собственным значениям S.

См. также: rsf2csf, ordschur, ordeig, lu, chol, hess, qr, qz, svd, eig.

: [U, T] = rsf2csf (UR, TR)

Преобразовать действительную верхнюю квази-треугольную форму Шура TR в комплексную верхнюю треугольную форму Шура T.

Обратите внимание, что выполняются следующие соотношения:

UR * TR * UR' = U * T * U', а U' * U — единичная матрица I.

Также обратите внимание, что U и T не являются единственными.

См. также: schur.

: [UR, SR] = ordschur (U, S, select)

Изменить порядок действительного разложения Шура (U,S), полученного с помощью функции schur, так, чтобы выбранные собственные значения оказались в верхних левых диагональных блоках квази-треугольной матрицы Шура.

Логический вектор select задаёт выбранные собственные значения в том порядке, в котором они расположены на диагонали S.

Например, для матрицы A = [1, 2; 3, 4] и её разложения Шура

[U, S] = schur (A)

которое возвращает

U =

  -0.82456  -0.56577
   0.56577  -0.82456

S =

  -0.37228  -1.00000
   0.00000   5.37228

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

[U, S] = ordschur (U, S, [0,1])

См. также: schur, ordeig, ordqz.

: [AR, BR, QR, ZR] = ordqz (AA, BB, Q, Z, keyword)

: [AR, BR, QR, ZR] = ordqz (AA, BB, Q, Z, select)

Изменить порядок QZ-разложения обобщённой задачи на собственные значения.

Обобщённая задача на собственные значения определяется как

A x = lambda B x

Её обобщённое разложение Шура вычисляется с помощью алгоритма qz:

[AA, BB, Q, Z] = qz (A, B)

где AA, BB, Q и Z удовлетворяют условиям

AA = Q * A * Z, BB = Q * B * Z

Функция ordqz вычисляет унитарные преобразования QR и ZR, изменяющие порядок собственных значений на диагоналях AA и BB. Полученные переупорядоченные матрицы AR и BR удовлетворяют условиям:

AR = QR * A * ZR, BR = QR * B * ZR

Функцию можно вызвать с аргументом keyword, задающим собственные значения в верхнем левом блоке AR и BR следующим образом:

"S", "udi"

малые: начальный блок содержит все собственные значения, для которых |lambda| < 1

"B", "udo"

большие: начальный блок содержит все собственные значения, для которых |lambda| ≥ 1

"-", "lhp"

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

"+", "rhp"

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

Если вместо ключевого слова задан логический вектор select, функция ordqz перемещает в левый блок все собственные значения k, для которых select(k) имеет значение true.

Примечание: ключевые слова совместимы с ключевыми словами функции qr.

См. также: eig, ordeig, qz, schur, ordschur.

: lambda = ordeig (A)

: lambda = ordeig (A, B)

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

Квази-треугольная матрица A обычно является результатом разложения Шура. Если функция вызывается со вторым входным аргументом B, возвращаются обобщённые собственные значения пары A, B в порядке их расположения в матрице A-lambda*B. Пара A, B обычно является результатом QZ-разложения.

См. также: ordschur, ordqz, eig, schur, qz.

: angle = subspace (A, B)

Определить наибольший главный угол между двумя подпространствами, натянутыми на столбцы матриц A и B.

: s = svd (A)

: [U, S, V] = svd (A)

: [U, S, V] = svd (A, "econ")

: [U, S, V] = svd (A, 0)

Вычислить сингулярное разложение матрицы A.

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

A = U*S*V'

Функция svd обычно возвращает только вектор сингулярных значений. При вызове с тремя выходными аргументами она вычисляет U, S и V. Например,

svd (hilb (3))

возвращает

ans =

  1.4083189
  0.1223271
  0.0026873

а

[u, s, v] = svd (hilb (3))

возвращает

u =

  -0.82704   0.54745   0.12766
  -0.45986  -0.52829  -0.71375
  -0.32330  -0.64901   0.68867

s =

  1.40832  0.00000  0.00000
  0.00000  0.12233  0.00000
  0.00000  0.00000  0.00269

v =

  -0.82704   0.54745   0.12766
  -0.45986  -0.52829  -0.71375
  -0.32330  -0.64901   0.68867

Если второй аргумент не равен 0, svd возвращает разложение уменьшенного размера, исключая ненужные строки или столбцы U или V.

Если второй аргумент точно равен 0, тип разложения выбирается на основе матрицы A. Если строк в A больше, чем столбцов, возвращается разложение уменьшенного размера; в противном случае вычисляется обычное разложение.

Примечания к алгоритму: при вычислении полного разложения (левой и правой сингулярных матриц в дополнение к сингулярным значениям) в LAPACK доступны две процедуры. По умолчанию Octave использует процедуру gesvd. Альтернативная процедура — gesdd — работает в 5 раз быстрее, но может использовать больше памяти и давать неточные результаты для некоторых входных матриц. Существует и третья процедура gejsv, подходящая для повышения точности в экстремальных масштабах. Подробнее о выборе алгоритма см. в документации к svd_driver.

См. также: svd_driver, svds, eig, lu, chol, hess, qr, qz.

: val = svd_driver ()

: old_val = svd_driver (new_val)

: old_val = svd_driver (new_val, "local")

Запросить или задать драйвер LAPACK, используемый функцией svd.

В настоящее время распознаются значения "gesdd", "gesvd" и "gejsv". Значение по умолчанию — "gesvd".

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

Примечания к алгоритму: процедуры библиотеки LAPACK gesvd и gesdd различаются только при вычислении полного сингулярного разложения (левой и правой сингулярных матриц, а также сингулярных значений). При вычислении только сингулярных значений приведённое ниже обсуждение не относится к делу.

Более новая процедура gesdd основана на алгоритме «разделяй и властвуй», который в 5 раз быстрее альтернативной процедуры gesvd, основанной на QR-разложении. Однако новый алгоритм может потреблять значительно больше памяти. Для входной матрицы размера MxN потребление памяти имеет порядок O(min(M,N) ^ 2), тогда как у альтернативного алгоритма — порядок O(max(M,N)).

Процедура gejsv использует предварительно обусловленный алгоритм SVD Якоби. В отличие от gesvd и gesdd, в gejsv нет этапа билинеаризации, который в некоторых экстремальных случаях может ухудшить точность. Кроме того, известно, что gejsv обеспечивает оптимальную точность в некотором смысле. Однако эта процедура работает медленнее (её ядро выполняется в одном потоке) и требует больше памяти (O(min(M,N) ^ 2 + M + N)).

Помимо вопросов скорости и потребления памяти, известны случаи, когда gesdd неточно разлагала некоторые входные матрицы. См. активную на данный момент ошибку https://savannah.gnu.org/bugs/?55564. Пока проблемы с точностью не будут устранены в новой версии библиотеки LAPACK, в Octave по умолчанию используется драйвер "gesvd".

См. также: svd.

: [housv, beta, zer] = housh (x, j, z)

Вычислить вектор отражения Хаусхолдера housv, который преобразует x в j-й столбец единичной матрицы, то есть

(I - beta*housv*housv')x =  norm (x)*e(j) if x(j) < 0,
(I - beta*housv*housv')x = -norm (x)*e(j) if x(j) >= 0

Входные данные

x

вектор

j

индекс элемента вектора

z

пороговое значение для нуля (обычно должно быть равно 0)

Выходные данные (см. Голуба и Ван Лоана):

beta

Если beta = 0, отражение применять не нужно (zer устанавливается в 0)

housv

вектор Хаусхолдера

: [u, h, nu] = krylov (A, V, k, eps1, pflg)

Построить ортогональный базис u блочного подпространства Крылова.

Блочное подпространство Крылова имеет следующий вид:

[v a*v a^2*v ... a^(k+1)*v]

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

Если V — вектор, то h содержит матрицу Хессенберга, такую что a*u == u*h+rk*ek', где rk = a*u(:,k)-u*h(:,k), а ek' — вектор [0, 0, …, 1] длины k. В противном случае h не имеет значения.

Если V — вектор, а k больше length (A) - 1, то h содержит матрицу Хессенберга, такую что a*u == u*h.

Значение nu — это размерность линейной оболочки подпространства Крылова (определяемая на основе eps1).

Если b — вектор, а k больше m-1, то h содержит разложение матрицы A на матрицу Хессенберга.

Необязательный параметр eps1 задаёт пороговое значение для нуля. Значение по умолчанию — 1e-12.

Если необязательный параметр pflg ненулевой, для улучшения численной устойчивости применяется выбор ведущего элемента по строкам. Значение по умолчанию — 0.

Источник: A. Hodel, P. Misra, Частичный выбор ведущего элемента при вычислении подпространств Крылова больших разреженных систем, Материалы 42-й конференции IEEE по принятию решений и управлению, декабрь 2003 г.