.
.
AQ
k

1
=
Q
k
R
k
⇒
Q
k
=
A
k
R

1
1
R

1
2
· · ·
R

1
k
.
In version 2, we have
A
=
U
1
R
1
A
2
=
U
1
R
1
U
1
R
1
=
U
1
U
2
R
2
R
1
A
3
=
U
1
R
1
U
1
U
2
R
2
R
1
=
U
1
U
2
R
2
U
2
R
2
R
1
=
U
1
U
2
U
3
R
3
R
2
R
1
.
.
.
A
k
=
U
1
U
2
· · ·
U
k
R
k
R
k

1
· · ·
R
1
,
which is the same thing as version 1 with
Q
k
=
U
1
U
2
· · ·
U
k
.
To keep track of the eigenvectors, we can restate the QR algorithm
as follows.
Let
Γ
0
=
A
,
Q
0
=
I
. For
k
= 1
,
2
, . . . ,
do
[
U
k
,
R
k
] = qr(
Γ
k

1
)
(so
Γ
k

1
=
U
k
R
k
)
Γ
k
=
R
k
U
k
Q
k
=
Q
k

1
U
k
Then
Γ
k
→
Λ
and
Q
k
→
V
.
12
Georgia Tech ECE 6250 Fall 2019; Notes by J. Romberg and M. Davenport. Last updated 13:22, November 13, 2019
Subscribe to view the full document.
Comments on computational complexity
The methods above have been the object of intense study over the
past 5060 years, and their cost and stability is very well understood.
Notice that all of the methods cost
O
(
N
3
) in the general case — this
is the essential cost of solving a system of linear equations.
When
N
is small,
O
(
N
3
) is OK. For example, I have a nice desktop
system (a 3.8 GHz Intel i7 with 8 cores and 64 GB memory), and
this about how long it takes MATLAB to solve
Ax
=
b
for different
N
:
N
= 100: 0.0003 seconds (300
μ
s)
N
= 1 000:
0.01 seconds (10ms)
N
= 5 000:
0.5 seconds
N
= 10 000:
2.6 seconds
N
= 50 000:
190 seconds (3.2 min)
There are many applications where
N
is in the millions (or even
billions). In these situations, solving
Ax
=
b
directly is infeasible.
You can roughly divide problems into three categories:
Small scale.
N
.
10
3
. Here
O
(
N
3
) algorithms are OK, and exact
algorithms are appropriate.
Medium scale.
N
∼
10
4
. Here
O
(
N
3
) is not OK,
O
(
N
2
) is OK. It
may be hard to even store the matrix in memory at this point.
Large scale.
N
&
10
5
.
Here
O
(
N
2
) is not OK,
O
(
N
3
) is typ
ically unthinkable.
We need algorithms that are
O
(
N
) or
O
(
N
log
N
), possibly at the cost of finding an exact solution.
13
Georgia Tech ECE 6250 Fall 2019; Notes by J. Romberg and M. Davenport. Last updated 13:22, November 13, 2019
We will start by looking at certain types of
structured
symmetric
matrices.
This structure allows us to solve
Ax
=
b
significantly
faster than
O
(
N
3
).
After this, we will consider
iterative algorithms
for finding an
appropriate solution to
Ax
=
b
when
A
is sym+def. These algo
rithms have the nice feature that the matrix
A
does not need to be
held in memory — all we need is a “black box” that computes
Ax
given
x
as input. This is especially nice if you have a fast implicit
method for computing
Ax
(e.g
A
involved FFTs, or is sparse).
Structured matrices
We will discuss three types of structured matrices, although plenty of
other types exist. In each of these cases, the structure of the system
allows us to do a solve in much better than
O
(
N
3
) operations.
Identity + low rank
Consider a system of the form
(
γ
I
+
BB
T
)
x
=
b
,
where
γ >
0 is some scalar, and
B
is a
N
×
R
matrix with
R < N
.
Subscribe to view the full document.
 Fall '08
 Staff