Don't let that INV go past your eyes; to solve that system, FACTORIZE!: test_disp - File Exchange

Code covered by the BSD License

Highlights from
Don't let that INV go past your eyes; to solve that system, FACTORIZE!

cod (A, tol) COD complete orthogonal decomposition of a full matrix A = U*R*V'
cod_qmult (Q, X, method)
cod_sparse (A, arg) COD_SPARSE complete orthogonal decomposition of a sparse matrix A = U*R*V'
factorize (A,strategy,burble) FACTORIZE an object-oriented method for solving linear systems
inverse (A, varargin) INVERSE factorized representation of inv(A) or pinv(A).
reset_rand RESET_RAND resets the state of rand
rq (A, m, n) RQ economy RQ or QL factorization of a full matrix A.
test_accuracy TEST_ACCURACY test the accuracy of the factorize object
test_all (performance) TEST_ALL test the Factorize package (factorize, inverse, and related)
test_all_cod TEST_ALL_COD test the COD factorization
test_all_svd TEST_ALL_SVD tests the svd factorization method for a range of problems.
test_cod (A, tol) TEST_COD test the COD, COD_SPARSE and RQ functions
test_disp TEST_DISP test the display method of the factorize object
test_errors TEST_ERRORS tests error handling for the factorize object methods
test_factorize (A) TEST_FACTORIZE test the accuracy of the factorization object
test_function (A, strategy, b... TEST_FUNCTION test various functions applied to a factorize object
test_functions TEST_FUNCTIONS test various functions applied to a factorize object
test_performance TEST_PERFORMANCE compare performance of factorization/solve methods.
test_svd (A)
factorization FACTORIZATION a generic matrix factorization object
factorization_chol_dense FACTORIZATION_CHOL_DENSE A = R'*R where A is full and symmetric pos. def.
factorization_chol_sparse
factorization_cod_dense FACTORIZATION_COD_DENSE complete orthogonal factorization: A = U*R*V' where A is full.
factorization_cod_sparse FACTORIZATION_COD_SPARSE complete orthogonal factorization: A = U*R*V' where A is sparse.
factorization_ldl_dense FACTORIZATION_LDL_DENSE P'*A*P = L*D*L' where A is sparse and full
factorization_ldl_sparse FACTORIZATION_LDL_SPARSE P'*A*P = L*D*L' where A is sparse and symmetric
factorization_lu_dense FACTORIZATION_LU_DENSE P*A = L*U where A is square and full.
factorization_lu_sparse FACTORIZATION_LU_SPARSE P*A*Q = L*U where A is square and sparse.
factorization_qr_dense FACTORIZATION_QR_DENSE A = Q*R where A is full.
factorization_qr_sparse
factorization_qrt_dense FACTORIZATION_QRT_DENSE A' = Q*R where A is full.
factorization_qrt_sparse
factorization_svd FACTORIZATION_SVD A = U*S*V'
Contents.m
Contents.m
factorize_demo.m
fdemo.m
THE FACTORIZE OBJECT for solv...
View all files

from Don't let that INV go past your eyes; to solve that system, FACTORIZE! by Tim Davis
A simple-to-use object-oriented method for solving linear systems and least-squares problems.

test_disp

function test_disp
%TEST_DISP test the display method of the factorize object
%
% Example
%   test_disp
%
% See also factorize, test_all.

% Copyright 2011, Timothy A. Davis, University of Florida.

reset_rand ;
tol = 1e-12 ;

%-------------------------------------------------------------------------------
% dense LU
%-------------------------------------------------------------------------------

fprintf ('\n----------Dense LU factorization:\n') ;
A = rand (3) ;

F = factorize (A, [ ], 1) ; 
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
L = f.L ;
U = f.U ;
P = f.P ;
C = F.A ;
err = norm (P*C - L*U, 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_lu_dense'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_lu_dense'))
    error ('invalid contents') ;
end

fprintf ('\nDense LU With an imaginary F.alpha:\n') ;
alpha = (pi + 2i) ;
F = alpha*F ;
display (F) ;
b = rand (3,1) ;
x = F\b ;
y = (alpha*A)\b ;
err = norm (x-y) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end

%-------------------------------------------------------------------------------
% sparse LU
%-------------------------------------------------------------------------------

fprintf ('\n----------Sparse LU factorization:\n') ;
A = sparse (A) ;

F = factorize (A, [ ], 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
L = f.L ;
U = f.U ;
P = f.P ;
Q = f.Q ;
C = F.A ;
err = norm (P*C*Q - L*U, 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_lu_sparse'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_lu_sparse'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% dense Cholesky
%-------------------------------------------------------------------------------

fprintf ('\n----------Dense Cholesky factorization:\n') ;
A = A*A' + eye (3) ;
F = factorize (A, [ ], 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
R = f.R ;
C = F.A ;
err = norm (C - R'*R, 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_chol_dense'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_chol_dense'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% sparse Cholesky
%-------------------------------------------------------------------------------

fprintf ('\n----------Sparse Cholesky factorization:\n') ;
A = sparse (A) ;
F = factorize (A, [ ], 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
L = f.L ;
P = f.P ;
C = F.A ;
err = norm (P'*C*P - L*L', 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_chol_sparse'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (F, 'factorization_chol_sparse'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% dense QR of A
%-------------------------------------------------------------------------------

fprintf ('\n----------Dense QR factorization:\n') ;
A = rand (3,2) ;
F = factorize (A, [ ], 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
Q = f.Q ;
R = f.R ;
C = F.A ;
err = norm (C - Q*R, 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_qr_dense'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_qr_dense'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% dense COD of A
%-------------------------------------------------------------------------------

fprintf ('\n----------Dense COD factorization:\n') ;
F = factorize (A, 'cod', 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
U = f.U ;
R = f.R ;
V = f.V ;
C = F.A ;
err = norm (C - U*R*V', 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_cod_dense'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_cod_dense'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% sparse COD of A
%-------------------------------------------------------------------------------

fprintf ('\n----------Sparse COD factorization:\n') ;
F = factorize (sparse (A), 'cod', 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
U = f.U ;
R = f.R ;
V = f.V ;
C = F.A ;
display (U)
display (V)
U = cod_qmult (U, speye (size (U.H,1)), 1) ;  % convert U to matrix form
V = cod_qmult (V, speye (size (V.H,1)), 1) ;  % convert V to matrix form
display (U) ;
display (V) ;
err = norm (C - U*R*V', 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_cod_sparse'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_cod_sparse'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% dense QR of A'
%-------------------------------------------------------------------------------

fprintf ('\n----------Dense QR factorization of A'':\n') ;
F = factorize (A', [ ], 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
Q = f.Q ;
R = f.R ;
C = F.A ;

err = norm (C' - Q*R, 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_qrt_dense'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_qrt_dense'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% sparse QR of A
%-------------------------------------------------------------------------------

fprintf ('\n----------Sparse QR factorization:\n') ;
A = sparse (A) ;
F = factorize (A, [ ], 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
R = f.R ;
P = f.P ;
C = F.A ;
err = norm ((C*P)'*(C*P) - R'*R, 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_qr_sparse'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_qr_sparse'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% sparse QR of A'
%-------------------------------------------------------------------------------

fprintf ('\n----------Sparse QR factorization of A'':\n') ;
F = factorize (A', [ ], 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
R = f.R ;
P = f.P ;
C = F.A ;
err = norm ((P*C)*(P*C)' - R'*R, 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_qrt_sparse'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_qrt_sparse'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% svd
%-------------------------------------------------------------------------------

fprintf ('\n----------SVD factorization:\n') ;
F = factorize (A, 'svd', 1) ;
display (F) ;
Apinv = inverse (F) ;
display (S) ;

[U,S,V] = svd (F) ;
err = norm (A - U*S*V', 2) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_svd'))
    error ('invalid contents') ;
end
if (~(Apinv.is_inverse) || ~isa (Apinv, 'factorization_svd'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% dense LDL
%-------------------------------------------------------------------------------

fprintf ('\n----------Dense LDL factorization:\n') ;
A = rand (3) ;
A = [zeros(3) A ; A' zeros(3)] ;
F = factorize (A, 'ldl', 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
L = f.L ;
D = f.D ;
C = F.A ;
P = f.P ;
err = norm (P'*C*P - L*D*L', 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_ldl_dense'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_ldl_dense'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------
% sparse LDL
%-------------------------------------------------------------------------------

fprintf ('\n----------Sparse LDL factorization:\n') ;
A = sparse (A) ;
F = factorize (A, 'ldl', 1) ;
display (F) ;
S = inverse (F) ;
display (S) ;

f = F.Factors ;
L = f.L ;
D = f.D ;
P = f.P ;
C = F.A ;
err = norm (P'*C*P - L*D*L', 1) ;
if (err > tol)
    error ('error too high: %g\n', err) ;
end
if (F.is_inverse || ~isa (F, 'factorization_ldl_sparse'))
    error ('invalid contents') ;
end
if (~(S.is_inverse) || ~isa (S, 'factorization_ldl_sparse'))
    error ('invalid contents') ;
end

%-------------------------------------------------------------------------------

fprintf ('\nAll disp tests passed, err: %g\n', err) ;

Highlights from Don't let that INV go past your eyes; to solve that system, FACTORIZE!

Highlights from
Don't let that INV go past your eyes; to solve that system, FACTORIZE!