cholesky decompositions

both the and use very similar implementation strategies, so we'll limit ourselves to the for now.

there are, generally speaking, three approaches to implementing an . all of them are conceptually equivalent, but differ in the ways they access the matrix, which can affect their potential for parallelism and simd.
these approaches can also be freely combined or interleaved, and many combinations have yet to be explored.

up-looking cholesky

this approach computes a cholesky decomposition row by row, using the result of the previously computed rows to compute row (hence, up-looking).

assume the first rows have been computed, replacing the elements in-place.

the next row is computed as:

left-looking cholesky

this one computes the cholesky decomposition column by column.

assume the first columns have been computed, replacing the elements in-place.

the next column is computed as:

right-looking cholesky

the right looking cholesky applies the updates to the matrix as soon as they are available, rather than waiting until the -th iteration to apply updates to the next row/column.

let .

let such that has been computed, then

block algorithms

the same algorithms from before can be applied just as well to block matrices, instead of scalar elements. all that is required is to replace by , by .

for example, the next column computation in the left-looking algorithm becomes:

where each "element" of and represents a block instead of a single scalar.