QR/UDT

fact_mult(A::UDT, B::UDT) -> UDT

Stabilized multiplication of two UDT decompositions. Returns a UDT factorization object.

inv!(res, F::UDT) -> res

Same as inv but writes result into preallocated res.

inv_one_plus!(res, A::UDT, Bdagger::UDT) -> res

Stabilized calculation of [1 + UlDlTl(UrDrTr)^†]^(-1). Writes the result into res.

See udt_inv_one_plus for preallocation options.

inv_one_plus!(res, F::UDT) -> res

Same as inv_one_plus but stores the result in preallocated res.

inv_one_plus(A::UDT, Bdagger::UDT) -> AbstractMatrix

Stabilized calculation of [1 + UlDlTl(UrDrTr)^†]^(-1).

See udt_inv_one_plus for preallocation options.

inv_one_plus(F::UDT) -> AbstractMatrix

Stabilized calculation of [1 + UDT]^(-1):

• Use one intermediate UDT decomposition.

Faster but potentially less accurate than inv_one_plus_loh.

See udt_inv_one_plus for preallocation options.

inv_one_plus_loh!(res, F::UDT) -> res

Stabilized calculation of [1 + UDT]^(-1):

• Separate scales larger and smaller than unity
• Use two intermediate UDT decompositions.

Writes the result into res.

See udt_inv_one_plus_loh for preallocation options.

inv_one_plus_loh(F::UDT) -> AbstractMatrix

Stabilized calculation of [1 + UDT]^(-1):

• Separate scales larger and smaller than unity
• Use two intermediate UDT decompositions.

See udt_inv_one_plus_loh for preallocation options.

inv_sum!(res, A::UDT, B::UDT) -> res

Stabilized calculation of [UaDaTa + UbDbTb]^(-1):

• Use one intermediate UDT decompositions.

See udt_inv_sum for preallocation options.

inv_sum(A::UDT, B::UDT) -> AbstractMatrix

Stabilized calculation of [UaDaTa + UbDbTb]^(-1):

• Use one intermediate UDT decompositions.

See udt_inv_sum for preallocation options.

inv_sum_loh!(res, A::UDT, B::UDT) -> res

Stabilized calculation of [UaDaTa + UbDbTb]^(-1):

• Separate scales larger and smaller than unity
• Use two intermediate UDT decompositions.

Writes the result into res.

See udt_inv_sum_loh for preallocation options.

inv_sum_loh(A::UDT, B::UDT) -> AbstractMatrix

Stabilized calculation of [UaDaTa + UbDbTb]^(-1):

• Separate scales larger and smaller than unity
• Use two intermediate UDT decompositions.

See udt_inv_sum_loh for preallocation options.

udv! is the same as svd, but saves space by overwriting the input A, instead of creating a copy.

Compute the UDT decomposition of A and return an UDT object.

U, D, and T, can be obtained from the factorization F with F.U, F.D, and F.T such that A = U * Diagonal(D) * T.

Iterating the decomposition produces the components U, D, and V.

Note that T is upper triangular only up to permutations of columns of T.

udt_inv_one_plus(A::UDT, Bdagger::UDT) -> UDT

Stabilized calculation of [1 + UlDlTl(UrDrTr)^†]^(-1). Returns and UDT factorization object.

Optional preallocations via keyword arguments:

• tmp = similar(A.U)
• tmp2 = similar(A.U)
• tmp3 = similar(A.U)

udt_inv_one_plus(F::UDT) -> UDT

Stabilized calculation of [1 + UDT]^(-1). Returns and UDT factorization object.

Optional preallocations via keyword arguments:

• u = similar(F.U)
• t = similar(F.T)

udt_inv_one_plus_loh(F::UDT) -> UDT

Stabilized calculation of [1 + UDT]^(-1):

• Separate scales larger and smaller than unity
• Use two intermediate UDT decompositions.

Options for preallocation via keyword arguments:

• l = similar(F.U)
• r = similar(F.U)
• Dp = similar(F.D)
• Dm = similar(F.D)

udt_inv_sum(A::UDT, B::UDT) -> UDT

Stabilized calculation of [UaDaTa + UbDbTb]^(-1):

• Use one intermediate UDT decompositions.

Optional preallocations via keyword arguments:

• m2 = similar(A.U)

udt_inv_sum_loh(A::UDT, B::UDT) -> UDT

Stabilized calculation of [UaDaTa + UbDbTb]^(-1):

• Separate scales larger and smaller than unity
• Use two intermediate UDT decompositions.

Options for preallocations via keyword arguments:

• mat2 = similar(A.U)
• Dap = similar(A.D)
• Dam = similar(A.D)
• Dbp = similar(A.D)
• Dbm = similar(A.D)