QRDecomposition

QR分解を{q,r}ペアとして与える．q はユニタリ行列，そして r は上三角行列となる．

m が正方行列ではない場合でも，完全なQR分解を返す．

詳細とオプション

もとの行列 m はConjugateTranspose[q].r と同値である．これは，m が実数の場合はTranspose[q].r と簡約できる． »
この行列 q はユニタリ行列である．入力が実数なら，q は実直交行列でもある． »
の列数は常にの行数に等しく，とは常に同数の列を持つ． »
QRDecomposition[m]を使うときは．q と r の行数はどちらもMatrixRank[m]に等しい． »
QRDecomposition[m,Full]を使うときは，行列 q は常に正方行列で， r と m の次元は等しい． »
QRDecompositionは以下のオプションを取る．
Pivoting False ピボットを使うかどうか

TargetStructure Automatic 返される行列の構造
QRDecomposition[m,Pivoting->True]は，リスト{q,r,p}を作成する．p は m.p が ConjugateTranspose[q].r と等しくなるような置換行列である． »
次は，TargetStructureの可能な設定である．

	Automatic	自動設定
	"Dense"	すべての行列をリストのリストとして返す
	"Sparse"	すべての行列をSparseArrayオブジェクトとして返す
	"Structured"	r をUpperTriangularMatrixオブジェクト，q をUnitaryMatrixオブジェクトまたはOrthogonalMatrixオブジェクト，p をPermutationMatrixオブジェクトとして返す

設定TargetStructure"Structured"を用いる場合，q がUnitaryMatrixオブジェクトとして返されるかOrthogonalMatrixオブジェクトとして返されるかは，入力が実数であったかどうかに依存する．

例題

すべて開くすべて閉じる

例 (3)

2×2行列のユニタリ（直交）行列と上三角行列への分解：

Wolfram Language code:

m = (|   |   |
| - | - |
| 1 | 2 |
| 3 | 4 |);
{q, r} = QRDecomposition[m];
{q//MatrixForm, r//MatrixForm}

であることを確認する：

Wolfram Language code: m == ConjugateTranspose[q].r

厳密値の3×2行列のQR分解を計算する：

Wolfram Language code:

{q, r} = QRDecomposition[(⁠|   |   |
| - | - |
| 1 | 2 |
| 3 | 4 |
| 5 | 6 |⁠)];
{q//MatrixForm, r//MatrixForm}

がもとの行列である：

Wolfram Language code: Transpose[q].r//MatrixForm

近似値の2×3行列のQR分解を計算する：

Wolfram Language code:

{q, r} = QRDecomposition[(⁠|    |    |    |
| -- | -- | -- |
| 1. | 2. | 3. |
| 4. | 5. | 6. |⁠)];
{q//MatrixForm, r//MatrixForm}

がもとの行列である：

Wolfram Language code: Transpose[q].r//MatrixForm

スコープ (13)

基本的な用法 (6)

機械精度行列のQR分解を求める：

Wolfram Language code: QRDecomposition[{{1.2, 2.3, 3.4}, {2.3, 4.5, 5.6}, {3.2, 7.6, 6.5}}]

結果をフォーマットする：

Wolfram Language code: Map[MatrixForm, %]

複素行列のQR分解：

Wolfram Language code:

m = (⁠|                |                |                |
| -------------- | -------------- | -------------- |
| 0.18  + 0.26 I | 0.22  + 0.19 I | 0.4  + 0.26 I  |
| 0.26  + 0.54 I | 0.79  + 0.43 I | 0.14  + 0.26 I |
| 0.63  + 0.64 I | 0.33  + 0.42 I | 0.52  + 0.12 I |⁠);
{q, r} = QRDecomposition[m];
MatrixForm /@ %

ConjugateTransposeを使って分解を検証する：

Wolfram Language code: ConjugateTranspose[q].r == m

QRDecompositionを厳密行列に使う：

Wolfram Language code: MatrixForm /@ QRDecomposition[{{3, 1, 5}, {2, 4, 6}, {8, 7, 9}}]

任意精度行列のQR分解：

Wolfram Language code: MatrixForm /@ QRDecomposition[RandomReal[5, {3, 3}, WorkingPrecision -> 10]]

QRDecompositionを記号行列に使う：

Wolfram Language code: FullSimplify[QRDecomposition[{{a, b}, {c, d}}], {a, b, c, d}∈ℝ]

大きい数値行列のQR分解は効率的に計算される：

Wolfram Language code: mat = RandomReal[{0, 9}, {1000, 1000}];

Wolfram Language code: AbsoluteTiming[QRDecomposition[mat];]

完全分解 (3)

階数が不足した正方行列：

Wolfram Language code:

m = (⁠|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |⁠);
MatrixRank[m]

QRDecomposition[m]は矩形行列を与える：

Wolfram Language code:

{qt, rt} = QRDecomposition[m];
MatrixForm /@ %

QRDecomposition[m,Full]は追加の行を加え，q を正方とし，r を m と同じ形状にする：

Wolfram Language code:

{qf, rf} = QRDecomposition[m, Full];
MatrixForm /@ %

どちらのペアも有効な分解である：

Wolfram Language code: qt.rt == m == qf.rf

2つの分解の最も次数が高い行は等しい：

Wolfram Language code: qt == qf[[1 ;; 2]] && rt == rf[[1 ;; 2]]

r 行列は常に0の行で充填される：

Wolfram Language code: rf[[3 ;; ]]

入力の背が高いとき，完全分解は常に行を加える：

Wolfram Language code:

m = (⁠|   |   |
| - | - |
| 1 | 2 |
| 3 | 4 |
| 5 | 6 |⁠);
MatrixForm /@ QRDecomposition[m]

Wolfram Language code:

MatrixForm /@ QRDecomposition[(⁠|   |   |
| - | - |
| 1 | 2 |
| 3 | 4 |
| 5 | 6 |⁠), Full]

これは，背が高い行列は決して完全な行の階数を持たないからである：

Wolfram Language code: MatrixRank[m] < Length[m]

幅が広い行列 m の場合，完全分解と薄い分解は一致する：

Wolfram Language code:

m = (⁠|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 4 | 5 | 6 |⁠);
QRDecomposition[m] == QRDecomposition[m, Full]

これは，これが完全な行の階数を持つからである：

Wolfram Language code: MatrixRank[m] == Length[m]

幅が広い行列dについては，2つの分解は等しくない：

Wolfram Language code:

d = (⁠|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 2 | 4 | 6 |⁠);
QRDecomposition[d] == QRDecomposition[d, Full]

これは，dが完全な行の階数を持たないからである：

Wolfram Language code: MatrixRank[d] < Length[d]

特殊行列 (4)

疎な行列のQR分解を求める：

Wolfram Language code: SparseArray[{{1, 3} -> 1, {2, 2} -> 2, {3, 1} -> 3}, {3, 3}]

Wolfram Language code: QRDecomposition[%]

Wolfram Language code: SparseArray[{{x_, y_} /; Abs[x - y] < 3 -> 3}, {5, 5}]

Wolfram Language code: Map[MatrixForm, QRDecomposition[%]]

構造化行列のQR分解：

Wolfram Language code: SymmetrizedArray[{{1, 1} -> 2, {1, 2} -> 1}, {2, 2}, Symmetric[All]]

Wolfram Language code: QRDecomposition[%]

一貫した単位を持つQuantityArray構造化行列に使う：

Wolfram Language code: QuantityArray[{{1, 4}, {3, 5}}, "Meters"]

行列は無次元である．行列に単位がある：

Wolfram Language code: QRDecomposition[%]

m が恒等行列のときのQRDecomposition[m]は2つの恒等行列からなっている：

Wolfram Language code: QRDecomposition[IdentityMatrix[3]]

Wolfram Language code: QRDecomposition[IdentityMatrix[{3, 4}]]

HilbertMatrixのQR分解：

Wolfram Language code: Map[MatrixForm, QRDecomposition[HilbertMatrix[3]]]

オプション (4)

Pivoting (1)

ピボッティングを含む機械演算でQR分解を計算する：

Wolfram Language code:

m = (⁠|   |   |    |    |
| :- | :- | :- | :- |
| 1 | 2 | 3  | 4  |
| 1 | 4 | 9  | 16 |
| 1 | 8 | 27 | 64 |⁠);
{q, r, p} = QRDecomposition[N[m], Pivoting -> True]

rの対角に沿った要素は，大きさが徐々に小さくなっている：

Wolfram Language code: MatrixForm[r]

行列pは順列行列である：

Wolfram Language code: MatrixForm[p]

QRDecompositionはm.p==ConjugateTranspose[q].rを満足する：

Wolfram Language code: ConjugateTranspose[q].r - m.p//Chop

TargetStructure (3)

デフォルト設定のとき，QRDecompositionは，実入力に対して2つの密な行列のリスとを返す：

Wolfram Language code:

ma = RandomReal[1, {5, 3}];
QRDecomposition[ma]

TargetStructure->"Structured"のとき，結果はOrthogonalMatrixオブジェクトおよびUpperTriangularMatrixオブジェクトになる：

Wolfram Language code: QRDecomposition[ma, TargetStructure -> "Structured"]

TargetStructureのデフォルト設定では，ピボット行列がSparseArrayオブジェクトとして返される：

Wolfram Language code:

ma = RandomReal[1, {5, 3}];
QRDecomposition[ma, Pivoting -> True]

TargetStructure"Dense"を使って3つの行列を通常のリストのリストとして取得する：

Wolfram Language code: QRDecomposition[ma, Pivoting -> True, TargetStructure -> "Dense"]

TargetStructure->"Structured"の設定のとき，実入力の結果は OrthogonalMatrix，UpperTriangularMatrix，PermutationMatrixの3つのオブジェクトである：

Wolfram Language code: QRDecomposition[ma, Pivoting -> True, TargetStructure -> "Structured"]

複素入力でTargetStructure->"Structured"のときm，QRDecompositionはUnitaryMatrixオブジェクトとUpperTriangularMatrixオブジェクトのペアを返す：

Wolfram Language code:

ma = RandomComplex[1 + I, {6, 4}];
QRDecomposition[ma, TargetStructure -> "Structured"]

結果を疎な行列として入手する：

Wolfram Language code: QRDecomposition[ma, TargetStructure -> "Sparse"]

アプリケーション (8)

QR分解の幾何学 (4)

次の行列の列空間の直交基底を求め，その基底を使ってのQR分解を求める：

Wolfram Language code:

a = (|    |    |    |
| -- | -- | -- |
| 1  | 3  | 7  |
| -1 | 2  | -3 |
| -1 | 2  | -9 |
| 1  | -4 | 7  |
| 1  | 2  | 1  |);

の次元を計算する：

Wolfram Language code: {n, m} = Dimensions[a]

をの番目の列とし，を対応するグラム・シュミット(Gram–Schmidt)基底の番目の要素として定義する：

Wolfram Language code: Table[v[k] = a[[All, k]], {k, m}];

Wolfram Language code: Table[e[k] = Normalize[v[k] - Underoverscript[∑, j = 1, k - 1]Projection[v[k], e[j]]], {k, m}]//MatrixForm

を行がの行列とする：

Wolfram Language code: q = %;

を要素が基底ベクトルに沿ったの成分である行列とする：

Wolfram Language code: (r = Table[e[i].v[j], {i, m}, {j, m}])//MatrixForm

であることを確認する：

Wolfram Language code: Transpose[q].r == a

これはQRDecompositionが与える結果に等しい：

Wolfram Language code: {q, r} == QRDecomposition[a]

次の行列について，OrthogonalizeとQRDecompositionを使って求まったQR分解を比較する：

Wolfram Language code:

a = (⁠|   |   |   |
| - | - | - |
| 7 | 1 | 1 |
| 2 | 0 | 0 |
| 9 | 4 | 1 |⁠);

はOrthogonalizeをの列に適用した結果とする：

Wolfram Language code: MatrixForm[q = Orthogonalize[Transpose[a]]]

とは等しいとする：

Wolfram Language code: (r = q.a)//MatrixForm

であることを確認する：

Wolfram Language code: Transpose[q].r == a

これはQRDecompositionが与える結果に等しい：

Wolfram Language code: {q, r} == QRDecomposition[a]

次の行列について，OrthogonalizeとQRDecompositionを使って求まったQR分解を比較する：

Wolfram Language code:

a = (⁠|                                            |                                             |                                            |
| ------------------------------------------ | ------------------------------------------- | ------------------------------------------ |
| 0.3777175008628273 + 0.7554306035890215 I  | 0.042448606227943886 + 0.6597841389667563 I | 0.5294306313261885 + 0.9489845876390817 I  |
| 0.06926665232206441 + 0.7454105710412986 I | 0.3752984378635884 + 0.07592515378172049 I  | 0.934180626643051 + 0.6965119371223651 I   |
| 0.3003335850354458 + 0.8656874330066835 I  | 0.5891726583893067 + 0.4589922313534083 I   | 0.8285542124029186 + 0.32894896452410505 I |⁠);

はOrthogonalizeをの複素共役列に適用した結果とする：

Wolfram Language code: MatrixForm[q = Orthogonalize[ConjugateTranspose[a]]]

とは等しいとする：

Wolfram Language code: (r = q.a//Chop)//MatrixForm

であることを確認する：

Wolfram Language code: ConjugateTranspose[q].r == a

これは，QRDecompositionが与える結果と符号まで等しい：

Wolfram Language code: MatrixForm /@ QRDecomposition[a]

アプリケーションによっては，が正方（かつユニタリ）行列でが入力行列と同じ次元である，いわゆる完全QR分解を計算すると便利なことがある．次の行列の完全QR分解を計算する：

Wolfram Language code:

m = (⁠|       |       |       |
| ----- | ----- | ----- |
| 1     | 2     | 3     |
| 4 I   | 5 I   | 6 I   |
| -7    | -8    | -9    |
| -10 I | -11 I | -12 I |⁠);

線形独立の列は2列しかないので，とはそれぞれ2行しか持たない：

Wolfram Language code:

{q, r} = QRDecomposition[m];
{q//MatrixForm, r//MatrixForm}

NullSpaceを使っての列のスパンの外にあるベクトルを求め，完全集合を直交化する：

Wolfram Language code: MatrixForm[qF = Orthogonalize[Join[q, NullSpace[q]]]]

次の行列はユニタリ行列である：

Wolfram Language code: UnitaryMatrixQ[qF]

行列を0で充填してと同じ形にする：

Wolfram Language code: MatrixForm[rF = PadRight[r, Dimensions[m]]]

これもまた有効なQR分解であることを確認する：

Wolfram Language code: ConjugateTranspose[qF].rF == m

最小二乗と曲線のフィット (4)

次の行列とベクトルについて，QR分解を使ってを最小にするを求める：

Wolfram Language code:

m = (⁠|    |    |    |
| -- | -- | -- |
| 2  | -2 | -2 |
| -2 | 2  | 0  |
| 2  | -2 | 0  |
| 2  | 2  | 0  |
| 2  | 1  | -1 |⁠);
b = {6, 1, 4, 9, 0};

の分解を計算する：

Wolfram Language code:

{q, r} = QRDecomposition[m];
{q//MatrixForm, r//MatrixForm}

, なので正規方程式はとして再計算できる：

Wolfram Language code: Transpose[m].m == Transpose[r].r

は（の列が線形独立であるために）可逆なので，解はである：

Wolfram Language code: Inverse[r].q.b

LeastSquaresを使って結果を確認する：

Wolfram Language code: % == LeastSquares[m, b]

次の行列とベクトルについて，QR分解を使ってを解く：

Wolfram Language code:

m = (⁠|    |    |    |    |    |
| -- | -- | -- | -- | -- |
| 0  | 0  | -1 | -1 | 1  |
| -2 | -1 | -1 | 1  | 0  |
| 0  | -2 | -2 | 0  | -1 |⁠);
b = {7, 9, 0};

のQR分解を計算すると，に線形独立の行があるので可逆なが与えられる：

Wolfram Language code:

{q, r} = QRDecomposition[Transpose[m]];
{q//MatrixForm, r//MatrixForm}

最小二乗問題を解くかのようにとする：

Wolfram Language code: x = Transpose[q].Inverse[Transpose[r]].b//FullSimplify

の列が $TemplateBox[{}, Reals]^3$ にスパンするので，は方程式の解でなくてはならない：

Wolfram Language code: m.x == b

QRDecompositionを使ってデータに最もフィットする曲線が求められる．次のデータについて考える：

Wolfram Language code:

data = IconizedObject[«Data»];
ListPlot[data]

との座標をデータから抽出する：

Wolfram Language code: {x, y} = Extract[data, {{All, 1}, {All, 2}}];

を最小化することが曲線をフィットすることになるように，が列とを持つとする：

Wolfram Language code: m = Map[x |-> {1, x}, x];

の列は線形独立なので，線形最小二乗フィットの係数はである：

Wolfram Language code:

{q, r} = QRDecomposition[m];
{a, b} = Inverse[r].q.y

Fitを使って係数を確認する：

Wolfram Language code: Fit[data, {1, s}, s]

最適合曲線をデータに沿ってプロットする：

Wolfram Language code: Show[Plot[a + b x, {x, 0, 1}], ListPlot[data]]

次のデータに最もフィットする放物線を求める：

Wolfram Language code:

data = IconizedObject[«Data»];
ListPlot[data]

との座標をデータから抽出する：

Wolfram Language code: {x, y} = Extract[data, {{All, 1}, {All, 2}}];

の最小化がへのフィットになるように．が列，，を持つとする：

Wolfram Language code: m = Map[x |-> {1, x, x ^ 2}, x];

の列は線形独立なので，最小二乗フィットの係数はである：

Wolfram Language code:

{q, r} = QRDecomposition[m];
{a, b, c} = Inverse[r].q.y

Fitを使って係数を確認する：

Wolfram Language code: Fit[data, {1, s, s ^ 2}, s]

最適合曲線をデータとともにプロットする：

Wolfram Language code: Show[Plot[a + b x + c x ^ 2, {x, 0, 3}], ListPlot[data]]

特性と関係 (12)

もとの行列はConjugateTranspose[q].r に等しい：

Wolfram Language code:

mℂ = RandomComplex[1 + I, {3, 4}];
{qℂ, rℂ} = QRDecomposition[mℂ];
Chop[mℂ - ConjugateTranspose[qℂ].rℂ]

これは，入力が実数のときはTranspose[q].r に簡約できる：

Wolfram Language code:

mℝ = RandomReal[1, {3, 4}];
{qℝ, rℝ} = QRDecomposition[mℝ];
Chop[mℝ - Transpose[qℝ].rℝ]

分解中の q 行列はユニタリ行列である：

Wolfram Language code:

{qℂ, rℂ} = QRDecomposition[RandomComplex[1 + I, {3, 4}]];
UnitaryMatrixQ[q]

入力が実数のとき，q は実直交行列でもある：

Wolfram Language code:

{qℝ, rℝ} = QRDecomposition[RandomReal[1, {3, 4}]];
OrthogonalMatrixQ[q] && Element[q, Reals]

分解の r 行列は常に上三角行列である：

Wolfram Language code: UpperTriangularMatrixQ[rℂ] && UpperTriangularMatrixQ[rℝ]

が行列なら，行列には列，行列には列あることになる：

Wolfram Language code:

a = RandomReal[1, {3, 5}];
{n, m} = Dimensions[a];
{q, r} = QRDecomposition[a];
n == Last[Dimensions[q]] && m == Last[Dimensions[r]]

QRDecompositionはとがMatrixRank[m]行を持つ「薄い」分解を計算する：

Wolfram Language code:

m = (|   |    |    |    |
| - | -- | -- | -- |
| 1 | 2  | 3  | 4  |
| 5 | 6  | 7  | 8  |
| 9 | 10 | 11 | 12 |);
{q, r} = QRDecomposition[m];
MatrixRank[m] == Length[q] == Length[r]

行列を見る：

Wolfram Language code: {q//MatrixForm, r//MatrixForm}

QRDecomposition[m,Full]は，次元が m と等しい r 行列を与える：

Wolfram Language code:

m = (|   |    |    |    |
| - | -- | -- | -- |
| 1 | 2  | 3  | 4  |
| 5 | 6  | 7  | 8  |
| 9 | 10 | 11 | 12 |);
{q, r} = QRDecomposition[m, Full];
Dimensions[r] == Dimensions[m]

行列 q は，次元が m の行数と等しい正方行列である：

Wolfram Language code: SquareMatrixQ[q] && Length[q] == Length[m]

行列を見る：

Wolfram Language code: {q//MatrixForm, r//MatrixForm}

m が実数値を持つ可逆行列なら，そのQR分解の行列は正方直交行列である：

Wolfram Language code:

m = RandomReal[1, {5, 5}];
MatrixRank[m] == 5

Wolfram Language code:

{q, r} = QRDecomposition[m];
SquareMatrixQ[q] && OrthogonalMatrixQ[q]

m が可逆行列なら．そのQR分解の行列は正方ユニタリ行列である：

Wolfram Language code:

m = RandomComplex[1 + I, {5, 5}];
MatrixRank[m] == 5

Wolfram Language code:

{q, r} = QRDecomposition[m];
SquareMatrixQ[q] && UnitaryMatrixQ[q]

a が行列で MatrixRank[a]==n なら，そのQR分解の行列は正方ユニタリ行列である：

Wolfram Language code:

a = RandomComplex[1 + I, {3, 5}];
{n, m} = Dimensions[a];
MatrixRank[a] == n

Wolfram Language code:

{q, r} = QRDecomposition[a];
SquareMatrixQ[q] && UnitaryMatrixQ[q]

a が行列でMatrixRank[a]==m なら，そのQR分解の行列は可逆行列である：

Wolfram Language code:

a = RandomReal[1, {5, 3}];
{n, m} = Dimensions[a];
MatrixRank[a] == m

Wolfram Language code:

{q, r} = QRDecomposition[a];
Det[r] != 0

さらに，PseudoInverse[a]==Inverse[r].q でもある：

Wolfram Language code: PseudoInverse[a] - Inverse[r].q//Chop

Orthogonalizeを使ってQR分解が計算できる：

Wolfram Language code:

m = RandomComplex[1 + I, {5, 5}];
q = Orthogonalize[ConjugateTranspose[m]];
r = q.m;
m == ConjugateTranspose[q].r && UnitaryMatrixQ[q] && UpperTriangularMatrixQ[r]

近似行列は，通常は，QRDecompositionで求まったものとは異なる：

Wolfram Language code: {q, r} == QRDecomposition[m]

LeastSquaresとQRDecompositionはどちらも最小二乗問題を解くために使うことができる：

Wolfram Language code:

m = {{1, 2}, {3, 4}, {1, 1}};
b = {1, 2, 3};
{q, r} = QRDecomposition[m];

Wolfram Language code: LeastSquares[m, b] == Inverse[r].q.b

のコレスキー(Cholesky)分解は QR分解と位相まで一致する：

Wolfram Language code: m = RandomComplex[1 + I, {6, 3}];

CholeskyDecomposition[ConjugateTranspose[m].]m を計算する：

Wolfram Language code: u = CholeskyDecomposition[ConjugateTranspose[m].m];

のQR分解を求める：

Wolfram Language code: {q, r} = QRDecomposition[m];

は各行の位相の選択を除いてと等しい：

Wolfram Language code: Chop[r Sign[Tr[r, List]] - u]

Top

その他のラーニングリソース

テクニカルサポート

データサイエンス，金融，ビジネス

工学

科学とテクノロジー

教育のためのテクノロジー

教育イニシアチブ

使い始める

Grow Your Skills

Wolframと繋がる

大人用の教育プログラム

若者のための教育プログラム

読む

QRDecomposition

詳細とオプション

例題

例 (3)

スコープ (13)

基本的な用法 (6)

完全分解 (3)

特殊行列 (4)

オプション (4)

Pivoting (1)

TargetStructure (3)

アプリケーション (8)

QR分解の幾何学 (4)

最小二乗と曲線のフィット (4)

特性と関係 (12)

テキスト

CMS

APA

BibTeX

BibLaTeX

	Pivoting	False	ピボットを使うかどうか
	TargetStructure	Automatic	返される行列の構造

QRDecomposition

詳細とオプション

例題

例 (3)

スコープ (13)

基本的な用法 (6)

完全分解 (3)

特殊行列 (4)

オプション (4)

Pivoting (1)

TargetStructure (3)

アプリケーション (8)

QR分解の幾何学 (4)

最小二乗と曲線のフィット (4)

特性と関係 (12)

関連項目

テクニカルノート

関連するガイド

履歴

テキスト

CMS

APA

BibTeX

BibLaTeX