Don't let that INV go past your eyes; to solve that system, FACTORIZE!: test_errors - 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_errors

function test_errors
%TEST_ERRORS tests error handling for the factorize object methods
%
% Example
%   test_errors
%
% See also test_all, factorize.

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

fprintf ('\nTesting error handling (error messages are expected)\n\n') ;
reset_rand ;
ok = true ;

% the matrix A must be 2D for factorize
A = ones (2,2,2) ; 
try
    F = factorize (A, [ ], 1) ;                                             %#ok
    ok = false ;
    fprintf ('error not caught: A must be 2D for factorize\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% check if invalid strategy is caught
A = rand (4) ;
try
    F = factorize (A, 'gunk', 1) ;                                          %#ok
    ok = false ;
    fprintf ('error not caught: invalid strategy\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% cannot use COD on sparse matrices
try
    [U R V r] = cod (sparse (A)) ;                                          %#ok
    ok = false ;
    fprintf ('error not caught: cannot use cod for sparse A\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% cannot use RQ on sparse matrices
try
    [R Q] = rq (sparse (A)) ;                                               %#ok
    ok = false ;
    fprintf ('error not caught: cannot use rq for sparse A\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% cannot do B\inverse(A) or inverse(A)/B
A = rand (2) ;
B = rand (2) ;
try
    C = B \ inverse (A) ;                                                   %#ok
    ok = false ;
    fprintf ('error not caught: requires explicit inverseA\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end
try
    C = inverse (A) / B ;                                                   %#ok
    ok = false ;
    fprintf ('error not caught: requires explicit inverseA\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% cannot use COD_SPARSE on full matrices
try
    [U R V r] = cod_sparse (A) ;                                            %#ok
    ok = false ;
    fprintf ('error not caught: cannot use cod_sparse for full A\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

if (~ok)
    error ('!') ;
end

% cannot factorize a logical array, sparse or full
for s = {'default', 'symmetric', 'qr', 'lu', 'ldl', 'chol', 'svd', 'cod'}
    for sp = 0:1
        A = logical (ones (3)) ;                                            %#ok
        if (sp)
            A = sparse (A) ;
        end
        try
            F = factorize (A, char (s), 1) ;                                %#ok
            ok = false ;
            fprintf ('error not caught:\n') ;
        catch me
            fprintf ('\nExpected error: [%s]\n', me.message) ;
        end
    end
end
try
    A = logical (sparse (rand (3,4))) ;
    F = factorize (A, 'qr', 1) ;                                            %#ok
    ok = false ;
    fprintf ('error not caught:\n') ;
catch me
    fprintf ('\nExpected error: [%s]\n', me.message) ;
end

if (~ok)
    error ('!') ;
end

% the matrix A must be full-rank for ldl and chol
for s = {'ldl', 'chol'}
    for sp = 0:1
        A = ones (3) ;
        if (sp)
            A = sparse (A) ;
        end
        try
            F = factorize (A, char (s), 1) ;                                %#ok
            ok = false ;
            fprintf ('error not caught\n') ;
        catch                                                               %#ok
        end
        A = zeros (3,2) ;
        if (sp)
            A = sparse (A) ;
        end
        try
            F = factorize (A, char (s), 1) ;                                %#ok
            ok = false ;
            fprintf ('error not caught\n') ;
        catch                                                               %#ok
        end
        A = zeros (2,3) ;
        if (sp)
            A = sparse (A) ;
        end
        try
            F = factorize (A, char (s), 1) ;                                %#ok
            ok = false ;
            fprintf ('error not caught\n') ;
        catch                                                               %#ok
        end
    end
end

% cannot do LU, CHOL, or LDL on rectangular matrices
for s = {'lu', 'ldl', 'chol'}
    A = rand (3,2) ;
    for sp = 0:1
        try
            F = factorize (A, char (s), 1) ;                                %#ok
            ok = false ;
            fprintf ('\nerror not caught: tall-and-thin case\n') ;
        catch me
            fprintf ('\nExpected error: [%s]\n', me.message) ;
        end
        A = sparse (A) ;
    end
end

if (~ok)
    error ('!') ;
end

% cannot do QR on short-and-fat matrices or QRT on tall-and-thin matrices
try
    F = factorization_qr_dense (rand (2,3), 0) ;                            %#ok
    ok = false ;
    fprintf ('\nerror not caught: short-and-fat case\n') ;
catch me
   fprintf ('\nExpected error: [%s]\n', me.message) ;
end
try
    F = factorization_qr_sparse (sparse (rand (2,3)), 0) ;                  %#ok
    ok = false ;
    fprintf ('\nerror not caught: short-and-fat case\n') ;
catch me
   fprintf ('\nExpected error: [%s]\n', me.message) ;
end
try
    F = factorization_qrt_dense (rand (3,2), 0) ;                           %#ok
    ok = false ;
    fprintf ('\nerror not caught: tall-and-thin case\n') ;
catch me
   fprintf ('\nExpected error: [%s]\n', me.message) ;
end
try
    F = factorization_qrt_sparse (sparse (rand (3,2)), 0) ;                 %#ok
    ok = false ;
    fprintf ('\nerror not caught: tall-and-thin case\n') ;
catch me
   fprintf ('\nExpected error: [%s]\n', me.message) ;
end

if (~ok)
    error ('!') ;
end

% cannot do CHOL, or LDL on singular matrices
for s = {'ldl', 'chol'}
    A = zeros (2) ;
    for sp = 0:1
        try
            F = factorize (A, char (s), 1) ;                                %#ok
            ok = false ;
            fprintf ('\nerror not caught: singular case\n') ;
        catch me
            fprintf ('\nExpected error: [%s]\n', me.message) ;
        end
        A = sparse (A) ;
    end
end

if (~ok)
    error ('!') ;
end

% cannot use cell indexing
A = rand (3,2) ;
F = factorize (A, [ ], 1) ;
try
    C = F {1} ;                                                        %#ok
    ok = false ;
    fprintf ('\nerror not caught: cannot use cell indexing\n') ;
catch me
    fprintf ('\nExpected error: [%s]\n', me.message) ;
end

% invalid indexing
try
    C = F (1,1).L ;                                                    %#ok
    ok = false ;
    fprintf ('error not caught: invalid indexing\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% invalid indexing
try
    C = F.L (1,1).stuff ;                                              %#ok
    ok = false ;
    fprintf ('error not caught: invalid indexing\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% non-existent field
try
    C = F.junk ;                                                       %#ok
    ok = false ;
    fprintf ('error not caught: invalid field\n') ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% can only update/downdate a dense Cholesky factorization
A = rand (2) ;
F = factorize (A, [ ], 1) ;
w = rand (2,1) ;
try
    F = cholupdate (F,w) ;
    fprintf ('error not caught: cannot update this type of matrix\n') ;
    disp (F) ;
    ok = false ;
catch me
    fprintf ('\nExpected error: [%s]\n', me.message) ;
end
try
    F = choldowndate (F,w,'-') ;
    fprintf ('error not caught: cannot downdate this type of matrix\n') ;
    disp (F) ;
    ok = false ;
catch me
    fprintf ('Expected error: [%s]\n', me.message) ;
end

% cannot do condest(F) or cond(F,1) for rectangular matrices
try
    F = factorize (rand (4,3)) ;
    c = condest (F) ;                                                       %#ok
    ok = false ;
    fprintf ('\nerror not caught: condest for rectangular case\n') ;
catch me
   fprintf ('\nExpected error: [%s]\n', me.message) ;
end
try
    F = factorize (rand (4,3), 'svd') ;
    c = cond (F,1) ;                                                        %#ok
    ok = false ;
    fprintf ('\nerror not caught: cond(A,1) for rectangular case\n') ;
catch me
   fprintf ('\nExpected error: [%s]\n', me.message) ;
end

% test for invalid kind of svd
try
    F = factorize (rand (4,3), 'svd') ;
    [U,S,V] = svd (F,'gunk') ;                                              %#ok
    ok = false ;
    fprintf ('\nerror not caught: invalid kind of svd\n') ;
catch me
   fprintf ('\nExpected error: [%s]\n', me.message) ;
end

% test for invalid cholupdate parameter
try
    A = rand (2) ;
    A = A*A' ;
    F = factorize (A) ;
    G = cholupdate (F, ones(2,1), 'gunk') ;                                 %#ok
    ok = false ;
    fprintf ('\nerror not caught: invalid kind of cholupdate\n') ;
catch me
   fprintf ('\nExpected error: [%s]\n', me.message) ;
end

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

if (~ok)
    error ('error-handling failed') ;
end
fprintf ('\nAll error-handing tests passed\n') ;

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!