octave: libinterp/corefcn/lu.cc annotate

annotate libinterp/corefcn/lu.cc @ 28154:e7fe6703a81f stable

doc: Update documentation for lu(). * lu.cc (Flu): Rename input "thres" to "tresh" for clarity. Use uppercase letters for L,U,P.

author	Rik <rik@octave.org>
date	Thu, 12 Mar 2020 16:56:18 -0700
parents	bd51beb6205e
children	09c071328135 0a5b15007766

rev	line source
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	1 ////////////////////////////////////////////////////////////////////////
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	2 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	3 // Copyright (C) 1996-2020 The Octave Project Developers
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	4 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	5 // See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	6 // distribution or <https://octave.org/copyright/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	7 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	8 // This file is part of Octave.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	9 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	10 // Octave is free software: you can redistribute it and/or modify it
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	11 // under the terms of the GNU General Public License as published by
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	12 // the Free Software Foundation, either version 3 of the License, or
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	13 // (at your option) any later version.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	14 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	15 // Octave is distributed in the hope that it will be useful, but
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	16 // WITHOUT ANY WARRANTY; without even the implied warranty of
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	18 // GNU General Public License for more details.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	19 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	20 // You should have received a copy of the GNU General Public License
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	21 // along with Octave; see the file COPYING. If not, see
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	22 // <https://www.gnu.org/licenses/>.
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	23 //
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	24 ////////////////////////////////////////////////////////////////////////
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	25
21724 aba2e6293dd8 use "#if ..." consistently instead of "#ifdef" and "#ifndef" John W. Eaton <jwe@octave.org> parents: 21547 diff changeset	26 #if defined (HAVE_CONFIG_H)
21301 40de9f8f23a6 Use '#include "config.h"' rather than <config.h>. Rik <rik@octave.org> parents: 21271 diff changeset	27 # include "config.h"
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	28 #endif
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	29
21271 7e67c7f82fc1 better use of templates for lu factorization classes John W. Eaton <jwe@octave.org> parents: 21200 diff changeset	30 #include "lu.h"
21146 ea9c05014809 revamp sparse LU factorization classes John W. Eaton <jwe@octave.org> parents: 21139 diff changeset	31 #include "sparse-lu.h"
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	32
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	33 #include "defun.h"
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	34 #include "error.h"
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21055 diff changeset	35 #include "errwarn.h"
20940 48b2ad5ee801 maint: Rename oct-obj.[cc\|h] to ovl.[cc\|h] for clarity. Rik <rik@octave.org> parents: 20921 diff changeset	36 #include "ovl.h"
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	37 #include "ov-re-sparse.h"
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	38 #include "ov-cx-sparse.h"
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	39
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21100 diff changeset	40 template <typename MT>
8869 c3b743b1b1c6 preset triangular type if possible for lu and qr outputs Jaroslav Hajek <highegg@gmail.com> parents: 8367 diff changeset	41 static octave_value
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	42 get_lu_l (const octave::math::lu<MT>& fact)
8869 c3b743b1b1c6 preset triangular type if possible for lu and qr outputs Jaroslav Hajek <highegg@gmail.com> parents: 8367 diff changeset	43 {
9715 9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	44 MT L = fact.L ();
23593 a8361bc2361a maint: Deprecate is_square and replace with issquare. Rik <rik@octave.org> parents: 23586 diff changeset	45 if (L.issquare ())
9715 9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	46 return octave_value (L, MatrixType (MatrixType::Lower));
8869 c3b743b1b1c6 preset triangular type if possible for lu and qr outputs Jaroslav Hajek <highegg@gmail.com> parents: 8367 diff changeset	47 else
9715 9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	48 return L;
9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	49 }
8869 c3b743b1b1c6 preset triangular type if possible for lu and qr outputs Jaroslav Hajek <highegg@gmail.com> parents: 8367 diff changeset	50
21139 538b57866b90 consistently use "typename" intead of "class" in template declarations John W. Eaton <jwe@octave.org> parents: 21100 diff changeset	51 template <typename MT>
9715 9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	52 static octave_value
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	53 get_lu_u (const octave::math::lu<MT>& fact)
9715 9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	54 {
9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	55 MT U = fact.U ();
23593 a8361bc2361a maint: Deprecate is_square and replace with issquare. Rik <rik@octave.org> parents: 23586 diff changeset	56 if (U.issquare () && fact.regular ())
9715 9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	57 return octave_value (U, MatrixType (MatrixType::Upper));
9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	58 else
9f27172fbd1e auto-set MatrixType from certain functions Jaroslav Hajek <highegg@gmail.com> parents: 9709 diff changeset	59 return U;
8869 c3b743b1b1c6 preset triangular type if possible for lu and qr outputs Jaroslav Hajek <highegg@gmail.com> parents: 8367 diff changeset	60 }
c3b743b1b1c6 preset triangular type if possible for lu and qr outputs Jaroslav Hajek <highegg@gmail.com> parents: 8367 diff changeset	61
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	62 DEFUN (lu, args, nargout,
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	63 doc: /* -- texinfo --
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	64 @deftypefn {} {[@var{L}, @var{U}] =} lu (@var{A})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	65 @deftypefnx {} {[@var{L}, @var{U}, @var{P}] =} lu (@var{A})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	66 @deftypefnx {} {[@var{L}, @var{U}, @var{P}, @var{Q}] =} lu (@var{S})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	67 @deftypefnx {} {[@var{L}, @var{U}, @var{P}, @var{Q}, @var{R}] =} lu (@var{S})
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	68 @deftypefnx {} {[@dots{}] =} lu (@var{S}, @var{thresh})
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	69 @deftypefnx {} {@var{y} =} lu (@dots{})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	70 @deftypefnx {} {[@dots{}] =} lu (@dots{}, "vector")
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	71 @cindex LU decomposition
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	72 Compute the LU@tie{}decomposition of @var{A}.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	73
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	74 If @var{A} is full then subroutines from @sc{lapack} are used, and if
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	75 @var{A} is sparse then @sc{umfpack} is used.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	76
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	77 The result is returned in a permuted form, according to the optional return
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	78 value @var{P}. For example, given the matrix @code{@var{A} = [1, 2; 3, 4]},
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	79
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	80 @example
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	81 [@var{L}, @var{U}, @var{P}] = lu (@var{A})
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	82 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	83
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	84 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	85 returns
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	86
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	87 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	88 @group
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	89 L =
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	90
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	91 1.00000 0.00000
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	92 0.33333 1.00000
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	93
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	94 U =
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	95
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	96 3.00000 4.00000
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	97 0.00000 0.66667
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	98
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	99 P =
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	100
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	101 0 1
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	102 1 0
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	103 @end group
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	104 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	105
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	106 The matrix is not required to be square.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	107
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	108 When called with two or three output arguments and a sparse input matrix,
25036 fa2f8ffd088e Add note about the preferred way to call lu with sparse input (bug #53390). Rik <rik@octave.org> parents: 24534 diff changeset	109 @code{lu} does not attempt to perform sparsity preserving column permutations.
fa2f8ffd088e Add note about the preferred way to call lu with sparse input (bug #53390). Rik <rik@octave.org> parents: 24534 diff changeset	110 Called with a fourth output argument, the sparsity preserving column
fa2f8ffd088e Add note about the preferred way to call lu with sparse input (bug #53390). Rik <rik@octave.org> parents: 24534 diff changeset	111 transformation @var{Q} is returned, such that
fa2f8ffd088e Add note about the preferred way to call lu with sparse input (bug #53390). Rik <rik@octave.org> parents: 24534 diff changeset	112 @code{@var{P} * @var{A} * @var{Q} = @var{L} * @var{U}}. This is the
fa2f8ffd088e Add note about the preferred way to call lu with sparse input (bug #53390). Rik <rik@octave.org> parents: 24534 diff changeset	113 @strong{preferred} way to call @code{lu} with sparse input matrices.
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	114
25036 fa2f8ffd088e Add note about the preferred way to call lu with sparse input (bug #53390). Rik <rik@octave.org> parents: 24534 diff changeset	115 Called with a fifth output argument and a sparse input matrix, @code{lu}
fa2f8ffd088e Add note about the preferred way to call lu with sparse input (bug #53390). Rik <rik@octave.org> parents: 24534 diff changeset	116 attempts to use a scaling factor @var{R} on the input matrix such that
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	117 @code{@var{P} * (@var{R} \ @var{A}) * @var{Q} = @var{L} * @var{U}}.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	118 This typically leads to a sparser and more stable factorization.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	119
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	120 An additional input argument @var{thresh} that defines the pivoting
e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	121 threshold can be given. @var{thresh} can be a scalar, in which case
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	122 it defines the @sc{umfpack} pivoting tolerance for both symmetric and
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	123 unsymmetric cases. If @var{thresh} is a 2-element vector, then the first
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	124 element defines the pivoting tolerance for the unsymmetric @sc{umfpack}
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	125 pivoting strategy and the second for the symmetric strategy. By default,
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	126 the values defined by @code{spparms} are used ([0.1, 0.001]).
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	127
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	128 Given the string argument @qcode{"vector"}, @code{lu} returns the values
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	129 of @var{P} and @var{Q} as vector values, such that for full matrix,
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	130 @code{@var{A}(@var{P},:) = @var{L} * @var{U}}, and @code{@var{R}(@var{P},:)
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	131 * @var{A}(:,@var{Q}) = @var{L} * @var{U}}.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	132
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	133 With two output arguments, returns the permuted forms of the upper and
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	134 lower triangular matrices, such that @code{@var{A} = @var{L} * @var{U}}.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	135 With one output argument @var{y}, then the matrix returned by the
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	136 @sc{lapack} routines is returned. If the input matrix is sparse then the
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	137 matrix @var{L} is embedded into @var{U} to give a return value similar to
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	138 the full case. For both full and sparse matrices, @code{lu} loses the
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	139 permutation information.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	140 @seealso{luupdate, ilu, chol, hess, qr, qz, schur, svd}
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	141 @end deftypefn */)
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	142 {
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	143 int nargin = args.length ();
23583 b7747a2c88b2 maint: Deprecate is_sparse_type and replace with issparse. Rik <rik@octave.org> parents: 23582 diff changeset	144 bool issparse = (nargin > 0 && args(0).issparse ());
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	145
20909 03e4ddd49396 omit unnecessary nargout checks John W. Eaton <jwe@octave.org> parents: 20898 diff changeset	146 if (nargin < 1 \|\| (issparse && nargin > 3) \|\| (! issparse && nargin > 2))
20802 8bb38ba1bad6 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20711 diff changeset	147 print_usage ();
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	148
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	149 bool vecout = false;
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	150 Matrix thresh;
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	151 int n = 1;
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	152
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	153 while (n < nargin)
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	154 {
18112 b560bac0fca2 maint: Don't use space between 'args' and '(' when doing indexing. Rik <rik@octave.org> parents: 18100 diff changeset	155 if (args(n).is_string ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	156 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	157 std::string tmp = args(n++).string_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	158
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	159 if (tmp == "vector")
19743 67f2c76f9f4d Remove unnecessary checking of error_state after is_string validation. Rik <rik@octave.org> parents: 19697 diff changeset	160 vecout = true;
67f2c76f9f4d Remove unnecessary checking of error_state after is_string validation. Rik <rik@octave.org> parents: 19697 diff changeset	161 else
67f2c76f9f4d Remove unnecessary checking of error_state after is_string validation. Rik <rik@octave.org> parents: 19697 diff changeset	162 error ("lu: unrecognized string argument");
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	163 }
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	164 else
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	165 {
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	166 if (! issparse)
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	167 error ("lu: can not define pivoting threshold THRESH for full matrices");
21055 5e00ed38a58b maint: Replace if/error/else paradigm with just if/error. Rik <rik@octave.org> parents: 20941 diff changeset	168
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	169 Matrix tmp = args(n++).matrix_value ();
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	170 if (tmp.numel () == 1)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	171 {
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	172 thresh.resize (1,2);
e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	173 thresh(0) = tmp(0);
e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	174 thresh(1) = tmp(0);
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	175 }
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	176 else if (tmp.numel () == 2)
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	177 thresh = tmp;
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	178 else
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	179 error ("lu: THRESH must be a 1- or 2-element vector");
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	180 }
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	181 }
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	182
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	183 octave_value_list retval;
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	184 bool scale = (nargout == 5);
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	185
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	186 octave_value arg = args(0);
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	187
5275 23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 4329 diff changeset	188 octave_idx_type nr = arg.rows ();
23b37da9fd5b [project @ 2005-04-08 16:07:35 by jwe] jwe parents: 4329 diff changeset	189 octave_idx_type nc = arg.columns ();
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	190
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	191 if (issparse)
f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	192 {
23577 80c42f4cca13 maint: Deprecate is_empty and replace with isempty. Rik <rik@octave.org> parents: 23450 diff changeset	193 if (arg.isempty ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	194 return octave_value_list (5, SparseMatrix ());
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	195
23582 0cc2011d800e maint: Deprecate is_real_type and replace with isreal. Rik <rik@octave.org> parents: 23581 diff changeset	196 if (arg.isreal ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	197 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	198 SparseMatrix m = arg.sparse_matrix_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	199
18678 6113e0c6920b maint: Clean up extra spaces before/after parentheses. Rik <rik@octave.org> parents: 18497 diff changeset	200 if (nargout < 4)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	201 {
25037 1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	202 warning_with_id ("Octave:lu:sparse_input",
1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	203 "lu: function may fail when called with less than 4 output arguments and a sparse input");
1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	204
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	205 ColumnVector Qinit (nc);
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	206 for (octave_idx_type i = 0; i < nc; i++)
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	207 Qinit(i) = i;
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	208 octave::math::sparse_lu<SparseMatrix> fact (m, Qinit, thresh,
25037 1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	209 false, true);
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	210
18678 6113e0c6920b maint: Clean up extra spaces before/after parentheses. Rik <rik@octave.org> parents: 18497 diff changeset	211 if (nargout < 2)
19861 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	212 retval(0) = fact.Y ();
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	213 else
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	214 {
20921 4d3daf7e43f3 eliminate trailing whitespace in source files John W. Eaton <jwe@octave.org> parents: 20909 diff changeset	215 retval.resize (nargout == 3 ? 3 : 2);
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	216 retval(1)
27276 7455523fdf01 style fixes: avoid breaking lines immediately after '(' John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	217 = octave_value (fact.U () * fact.Pc_mat ().transpose (),
7455523fdf01 style fixes: avoid breaking lines immediately after '(' John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	218 MatrixType (MatrixType::Permuted_Upper,
7455523fdf01 style fixes: avoid breaking lines immediately after '(' John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	219 nc, fact.col_perm ()));
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	220
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	221 PermMatrix P = fact.Pr_mat ();
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	222 SparseMatrix L = fact.L ();
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	223
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	224 if (nargout == 2)
22407 34ce5be04942 maint: Style check C++ code in libinterp/. Rik <rik@octave.org> parents: 22372 diff changeset	225 retval(0)
34ce5be04942 maint: Style check C++ code in libinterp/. Rik <rik@octave.org> parents: 22372 diff changeset	226 = octave_value (P.transpose () * L,
34ce5be04942 maint: Style check C++ code in libinterp/. Rik <rik@octave.org> parents: 22372 diff changeset	227 MatrixType (MatrixType::Permuted_Lower,
34ce5be04942 maint: Style check C++ code in libinterp/. Rik <rik@octave.org> parents: 22372 diff changeset	228 nr, fact.row_perm ()));
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	229 else
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	230 {
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	231 retval(0) = L;
18678 6113e0c6920b maint: Clean up extra spaces before/after parentheses. Rik <rik@octave.org> parents: 18497 diff changeset	232 if (vecout)
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	233 retval(2) = fact.Pr_vec();
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	234 else
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	235 retval(2) = P;
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	236 }
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	237 }
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	238 }
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	239 else
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	240 {
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	241 retval.resize (scale ? 5 : 4);
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	242 octave::math::sparse_lu<SparseMatrix> fact (m, thresh, scale);
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	243
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	244 retval(0) = octave_value (fact.L (),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	245 MatrixType (MatrixType::Lower));
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	246 retval(1) = octave_value (fact.U (),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	247 MatrixType (MatrixType::Upper));
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	248
19861 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	249 if (vecout)
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	250 {
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	251 retval(2) = fact.Pr_vec ();
19861 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	252 retval(3) = fact.Pc_vec ();
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	253 }
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	254 else
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	255 {
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	256 retval(2) = fact.Pr_mat ();
19861 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	257 retval(3) = fact.Pc_mat ();
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	258 }
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	259
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	260 if (scale)
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	261 retval(4) = fact.R ();
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	262 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	263 }
23581 c3075ae020e1 maint: Deprecate is_complex_type and replace with iscomplex. Rik <rik@octave.org> parents: 23577 diff changeset	264 else if (arg.iscomplex ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	265 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	266 SparseComplexMatrix m = arg.sparse_complex_matrix_value ();
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	267
18678 6113e0c6920b maint: Clean up extra spaces before/after parentheses. Rik <rik@octave.org> parents: 18497 diff changeset	268 if (nargout < 4)
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	269 {
25037 1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	270 warning_with_id ("Octave:lu:sparse_input",
1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	271 "lu: function may fail when called with less than 4 output arguments and a sparse input");
1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	272
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	273 ColumnVector Qinit (nc);
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	274 for (octave_idx_type i = 0; i < nc; i++)
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	275 Qinit(i) = i;
22407 34ce5be04942 maint: Style check C++ code in libinterp/. Rik <rik@octave.org> parents: 22372 diff changeset	276 octave::math::sparse_lu<SparseComplexMatrix> fact (m, Qinit,
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	277 thresh, false,
22407 34ce5be04942 maint: Style check C++ code in libinterp/. Rik <rik@octave.org> parents: 22372 diff changeset	278 true);
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	279
18678 6113e0c6920b maint: Clean up extra spaces before/after parentheses. Rik <rik@octave.org> parents: 18497 diff changeset	280 if (nargout < 2)
19861 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	281 retval(0) = fact.Y ();
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	282 else
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	283 {
20921 4d3daf7e43f3 eliminate trailing whitespace in source files John W. Eaton <jwe@octave.org> parents: 20909 diff changeset	284 retval.resize (nargout == 3 ? 3 : 2);
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	285 retval(1)
27276 7455523fdf01 style fixes: avoid breaking lines immediately after '(' John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	286 = octave_value (fact.U () * fact.Pc_mat ().transpose (),
7455523fdf01 style fixes: avoid breaking lines immediately after '(' John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	287 MatrixType (MatrixType::Permuted_Upper,
7455523fdf01 style fixes: avoid breaking lines immediately after '(' John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	288 nc, fact.col_perm ()));
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	289
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	290 PermMatrix P = fact.Pr_mat ();
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	291 SparseComplexMatrix L = fact.L ();
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	292 if (nargout == 2)
19861 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	293 retval(0)
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	294 = octave_value (P.transpose () * L,
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	295 MatrixType (MatrixType::Permuted_Lower,
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	296 nr, fact.row_perm ()));
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	297 else
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	298 {
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	299 retval(0) = L;
18678 6113e0c6920b maint: Clean up extra spaces before/after parentheses. Rik <rik@octave.org> parents: 18497 diff changeset	300 if (vecout)
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	301 retval(2) = fact.Pr_vec();
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	302 else
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	303 retval(2) = P;
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	304 }
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	305 }
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	306 }
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	307 else
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	308 {
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	309 retval.resize (scale ? 5 : 4);
28154 e7fe6703a81f doc: Update documentation for lu(). Rik <rik@octave.org> parents: 27923 diff changeset	310 octave::math::sparse_lu<SparseComplexMatrix> fact (m, thresh,
25037 1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	311 scale);
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	312
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	313 retval(0) = octave_value (fact.L (),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	314 MatrixType (MatrixType::Lower));
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	315 retval(1) = octave_value (fact.U (),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	316 MatrixType (MatrixType::Upper));
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	317
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	318 if (vecout)
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	319 {
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	320 retval(2) = fact.Pr_vec ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	321 retval(3) = fact.Pc_vec ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	322 }
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	323 else
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	324 {
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	325 retval(2) = fact.Pr_mat ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	326 retval(3) = fact.Pc_mat ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	327 }
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	328
19861 19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	329 if (scale)
19755f4fc851 maint: Cleanup C++ code to follow Octave coding conventions. Rik <rik@octave.org> parents: 19743 diff changeset	330 retval(4) = fact.R ();
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	331 }
18427 93c019f00e59 maint: whitespace fixes for libinterp/corefcn/lu.cc Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18426 diff changeset	332
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	333 }
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	334 else
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21055 diff changeset	335 err_wrong_type_arg ("lu", arg);
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	336 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	337 else
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	338 {
23577 80c42f4cca13 maint: Deprecate is_empty and replace with isempty. Rik <rik@octave.org> parents: 23450 diff changeset	339 if (arg.isempty ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	340 return octave_value_list (3, Matrix ());
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	341
23582 0cc2011d800e maint: Deprecate is_real_type and replace with isreal. Rik <rik@octave.org> parents: 23581 diff changeset	342 if (arg.isreal ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	343 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	344 if (arg.is_single_type ())
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	345 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	346 FloatMatrix m = arg.float_matrix_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	347
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	348 octave::math::lu<FloatMatrix> fact (m);
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	349
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	350 switch (nargout)
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	351 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	352 case 0:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	353 case 1:
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	354 retval = ovl (fact.Y ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	355 break;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7515 diff changeset	356
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	357 case 2:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	358 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	359 PermMatrix P = fact.P ();
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	360 FloatMatrix L = P.transpose () * fact.L ();
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	361 retval = ovl (L, get_lu_u (fact));
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	362 }
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	363 break;
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	364
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	365 case 3:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	366 default:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	367 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	368 if (vecout)
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	369 retval = ovl (get_lu_l (fact), get_lu_u (fact),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	370 fact.P_vec ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	371 else
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	372 retval = ovl (get_lu_l (fact), get_lu_u (fact),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	373 fact.P ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	374 }
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	375 break;
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	376 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	377 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	378 else
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	379 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	380 Matrix m = arg.matrix_value ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7515 diff changeset	381
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	382 octave::math::lu<Matrix> fact (m);
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	383
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	384 switch (nargout)
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	385 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	386 case 0:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	387 case 1:
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	388 retval = ovl (fact.Y ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	389 break;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7515 diff changeset	390
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	391 case 2:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	392 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	393 PermMatrix P = fact.P ();
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	394 Matrix L = P.transpose () * fact.L ();
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	395 retval = ovl (L, get_lu_u (fact));
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	396 }
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	397 break;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7515 diff changeset	398
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	399 case 3:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	400 default:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	401 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	402 if (vecout)
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	403 retval = ovl (get_lu_l (fact), get_lu_u (fact),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	404 fact.P_vec ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	405 else
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	406 retval = ovl (get_lu_l (fact), get_lu_u (fact),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	407 fact.P ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	408 }
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	409 break;
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	410 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	411 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	412 }
23581 c3075ae020e1 maint: Deprecate is_complex_type and replace with iscomplex. Rik <rik@octave.org> parents: 23577 diff changeset	413 else if (arg.iscomplex ())
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	414 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	415 if (arg.is_single_type ())
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	416 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	417 FloatComplexMatrix m = arg.float_complex_matrix_value ();
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	418
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	419 octave::math::lu<FloatComplexMatrix> fact (m);
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	420
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	421 switch (nargout)
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	422 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	423 case 0:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	424 case 1:
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	425 retval = ovl (fact.Y ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	426 break;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7515 diff changeset	427
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	428 case 2:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	429 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	430 PermMatrix P = fact.P ();
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	431 FloatComplexMatrix L = P.transpose () * fact.L ();
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	432 retval = ovl (L, get_lu_u (fact));
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	433 }
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	434 break;
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	435
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	436 case 3:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	437 default:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	438 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	439 if (vecout)
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	440 retval = ovl (get_lu_l (fact), get_lu_u (fact),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	441 fact.P_vec ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	442 else
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	443 retval = ovl (get_lu_l (fact), get_lu_u (fact),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	444 fact.P ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	445 }
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	446 break;
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	447 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	448 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	449 else
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	450 {
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	451 ComplexMatrix m = arg.complex_matrix_value ();
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7515 diff changeset	452
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	453 octave::math::lu<ComplexMatrix> fact (m);
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	454
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	455 switch (nargout)
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	456 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	457 case 0:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	458 case 1:
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	459 retval = ovl (fact.Y ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	460 break;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7515 diff changeset	461
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	462 case 2:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	463 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	464 PermMatrix P = fact.P ();
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	465 ComplexMatrix L = P.transpose () * fact.L ();
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	466 retval = ovl (L, get_lu_u (fact));
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	467 }
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	468 break;
7789 82be108cc558 First attempt at single precision tyeps David Bateman <dbateman@free.fr> parents: 7515 diff changeset	469
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	470 case 3:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	471 default:
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	472 {
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	473 if (vecout)
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	474 retval = ovl (get_lu_l (fact), get_lu_u (fact),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	475 fact.P_vec ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	476 else
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	477 retval = ovl (get_lu_l (fact), get_lu_u (fact),
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	478 fact.P ());
20555 f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	479 }
f90c8372b7ba eliminate many more simple uses of error_state John W. Eaton <jwe@octave.org> parents: 20228 diff changeset	480 break;
10154 40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	481 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	482 }
40dfc0c99116 DLD-FUNCTIONS/.cc: untabify John W. Eaton <jwe@octave.org>* parents: 10094 diff changeset	483 }
7515 f3c00dc0912b Eliminate the rest of the dispatched sparse functions David Bateman <dbateman@free.fr> parents: 7017 diff changeset	484 else
21100 e39e05d90788 Switch gripe_XXX to either err_XXX or warn_XXX naming scheme. Rik <rik@octave.org> parents: 21055 diff changeset	485 err_wrong_type_arg ("lu", arg);
2928 295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	486 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	487
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	488 return retval;
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	489 }
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	490
295f037b4b3e [project @ 1997-05-05 05:32:33 by jwe] jwe parents: diff changeset	491 /*
21317 a4faec57f4c8 maint: remove semicolon after %!assert tests to follow Octave conventions. Rik <rik@octave.org> parents: 21301 diff changeset	492 %!assert(lu ([1, 2; 3, 4]), [3, 4; 1/3, 2/3], eps)
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	493
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	494 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	495 %! [l, u] = lu ([1, 2; 3, 4]);
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	496 %! assert (l, [1/3, 1; 1, 0], sqrt (eps));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	497 %! assert (u, [3, 4; 0, 2/3], sqrt (eps));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	498
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	499 %!test
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	500 %! [l, u, p] = lu ([1, 2; 3, 4]);
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	501 %! assert (l, [1, 0; 1/3, 1], sqrt (eps));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	502 %! assert (u, [3, 4; 0, 2/3], sqrt (eps));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	503 %! assert (p(:,:), [0, 1; 1, 0], sqrt (eps));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	504
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	505 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	506 %! [l, u, p] = lu ([1, 2; 3, 4], "vector");
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	507 %! assert (l, [1, 0; 1/3, 1], sqrt (eps));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	508 %! assert (u, [3, 4; 0, 2/3], sqrt (eps));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	509 %! assert (p, [2;1], sqrt (eps));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	510
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	511 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	512 %! [l, u, p] = lu ([1, 2; 3, 4; 5, 6]);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	513 %! assert (l, [1, 0; 1/5, 1; 3/5, 1/2], sqrt (eps));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	514 %! assert (u, [5, 6; 0, 4/5], sqrt (eps));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	515 %! assert (p(:,:), [0, 0, 1; 1, 0, 0; 0 1 0], sqrt (eps));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	516
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	517 %!assert (lu (single ([1, 2; 3, 4])), single ([3, 4; 1/3, 2/3]), eps ("single"))
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	518
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	519 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	520 %! [l, u] = lu (single ([1, 2; 3, 4]));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	521 %! assert (l, single ([1/3, 1; 1, 0]), sqrt (eps ("single")));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	522 %! assert (u, single ([3, 4; 0, 2/3]), sqrt (eps ("single")));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	523
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	524 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	525 %! [l, u, p] = lu (single ([1, 2; 3, 4]));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	526 %! assert (l, single ([1, 0; 1/3, 1]), sqrt (eps ("single")));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	527 %! assert (u, single ([3, 4; 0, 2/3]), sqrt (eps ("single")));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	528 %! assert (p(:,:), single ([0, 1; 1, 0]), sqrt (eps ("single")));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	529
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	530 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	531 %! [l, u, p] = lu (single ([1, 2; 3, 4]), "vector");
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	532 %! assert (l, single ([1, 0; 1/3, 1]), sqrt (eps ("single")));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	533 %! assert (u, single ([3, 4; 0, 2/3]), sqrt (eps ("single")));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	534 %! assert (p, single ([2;1]), sqrt (eps ("single")));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	535
87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	536 %!test
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	537 %! [l u p] = lu (single ([1, 2; 3, 4; 5, 6]));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	538 %! assert (l, single ([1, 0; 1/5, 1; 3/5, 1/2]), sqrt (eps ("single")));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	539 %! assert (u, single ([5, 6; 0, 4/5]), sqrt (eps ("single")));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	540 %! assert (p(:,:), single ([0, 0, 1; 1, 0, 0; 0 1 0]), sqrt (eps ("single")));
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	541
18488 4c2465444a96 Use %!testif HAVE_UMFPACK for sparse lu test added in cset 2a45b6b87bee Mike Miller <mtmiller@ieee.org> parents: 18427 diff changeset	542 %!testif HAVE_UMFPACK
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	543 %! Bi = [1 2 3 4 5 2 3 6 7 8 4 5 7 8 9];
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	544 %! Bj = [1 3 4 5 6 7 8 9 11 12 13 14 15 16 17];
2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	545 %! Bv = [1 1 1 1 1 1 -1 1 1 1 1 -1 1 -1 1];
18427 93c019f00e59 maint: whitespace fixes for libinterp/corefcn/lu.cc Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18426 diff changeset	546 %! B = sparse (Bi, Bj, Bv);
25037 1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	547 %! warning ("off", "Octave:lu:sparse_input", "local");
18427 93c019f00e59 maint: whitespace fixes for libinterp/corefcn/lu.cc Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18426 diff changeset	548 %! [L, U] = lu (B);
18426 807e21ebddd5 maint: Style fixes for tests in libinterp/corefcn/lu.cc Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18425 diff changeset	549 %! assert (L*U, B);
18427 93c019f00e59 maint: whitespace fixes for libinterp/corefcn/lu.cc Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18426 diff changeset	550 %! [L, U, P] = lu(B);
18426 807e21ebddd5 maint: Style fixes for tests in libinterp/corefcn/lu.cc Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18425 diff changeset	551 %! assert (P'LU, B);
18427 93c019f00e59 maint: whitespace fixes for libinterp/corefcn/lu.cc Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18426 diff changeset	552 %! [L, U, P, Q] = lu (B);
18426 807e21ebddd5 maint: Style fixes for tests in libinterp/corefcn/lu.cc Jordi Gutiérrez Hermoso <jordigh@octave.org> parents: 18425 diff changeset	553 %! assert (P'LU*Q', B);
18425 2a45b6b87bee correct numerical errors in sparse LU factorization (bug #41116). Michael C. Grant <mcg@cvxr.com> parents: 17787 diff changeset	554
25037 1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	555 %!error lu ()
25095 71ed409b2ffb Change lu BIST test to use testif HAVE_UMFPACK. Rik <rik@octave.org> parents: 25054 diff changeset	556 %!testif HAVE_UMFPACK
71ed409b2ffb Change lu BIST test to use testif HAVE_UMFPACK. Rik <rik@octave.org> parents: 25054 diff changeset	557 %! fail ("[l,u] = lu (sparse (magic (3)))", "warning", "function may fail");
25037 1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	558 %!error <can not define pivoting threshold> lu ([1, 2; 3, 4], 2)
1c077d652c57 Add new warning ID and message when lu is called with sparse input incorrectly (bug #53390). Rik <rik@octave.org> parents: 25036 diff changeset	559
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	560 */
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	561
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	562 static
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	563 bool check_lu_dims (const octave_value& l, const octave_value& u,
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	564 const octave_value& p)
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	565 {
18100 6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	566 octave_idx_type m = l.rows ();
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	567 octave_idx_type k = u.rows ();
6a71e5030df5 Follow coding convention of defining and initializing only 1 variable per line in liboctinterp. Rik <rik@octave.org> parents: 17787 diff changeset	568 octave_idx_type n = u.columns ();
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	569
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	570 return ((l.ndims () == 2 && u.ndims () == 2 && k == l.columns ())
19864 17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions. John W. Eaton <jwe@octave.org> parents: 19861 diff changeset	571 && k == std::min (m, n)
17d647821d61 maint: More cleanup of C++ code to follow Octave coding conventions. John W. Eaton <jwe@octave.org> parents: 19861 diff changeset	572 && (p.is_undefined () \|\| p.rows () == m));
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	573 }
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	574
15039 e753177cde93 maint: Move non-dynamically linked functions from DLD-FUNCTIONS/ to corefcn/ directory Rik <rik@octave.org> parents: 14854 diff changeset	575 DEFUN (luupdate, args, ,
21966 112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	576 doc: /* -- texinfo --
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	577 @deftypefn {} {[@var{L}, @var{U}] =} luupdate (@var{L}, @var{U}, @var{x}, @var{y})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	578 @deftypefnx {} {[@var{L}, @var{U}, @var{P}] =} luupdate (@var{L}, @var{U}, @var{P}, @var{x}, @var{y})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	579 Given an LU@tie{}factorization of a real or complex matrix
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	580 @w{@var{A} = @var{L}*@var{U}}, @var{L}@tie{}lower unit trapezoidal and
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	581 @var{U}@tie{}upper trapezoidal, return the LU@tie{}factorization
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	582 of @w{@var{A} + @var{x}*@var{y}.'}, where @var{x} and @var{y} are
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	583 column vectors (rank-1 update) or matrices with equal number of columns
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	584 (rank-k update).
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	585
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	586 Optionally, row-pivoted updating can be used by supplying a row permutation
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	587 (pivoting) matrix @var{P}; in that case, an updated permutation matrix is
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	588 returned. Note that if @var{L}, @var{U}, @var{P} is a pivoted
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	589 LU@tie{}factorization as obtained by @code{lu}:
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	590
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	591 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	592 [@var{L}, @var{U}, @var{P}] = lu (@var{A});
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	593 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	594
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	595 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	596 then a factorization of @tcode{@var{A}+@var{x}*@var{y}.'} can be obtained
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	597 either as
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	598
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	599 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	600 [@var{L1}, @var{U1}] = lu (@var{L}, @var{U}, @var{P}*@var{x}, @var{y})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	601 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	602
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	603 @noindent
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	604 or
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	605
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	606 @example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	607 [@var{L1}, @var{U1}, @var{P1}] = lu (@var{L}, @var{U}, @var{P}, @var{x}, @var{y})
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	608 @end example
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	609
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	610 The first form uses the unpivoted algorithm, which is faster, but less
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	611 stable. The second form uses a slower pivoted algorithm, which is more
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	612 stable.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	613
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	614 The matrix case is done as a sequence of rank-1 updates; thus, for large
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	615 enough k, it will be both faster and more accurate to recompute the
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	616 factorization from scratch.
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	617 @seealso{lu, cholupdate, qrupdate}
112b20240c87 move docstrings in C++ files out of C strings and into comments John W. Eaton <jwe@octave.org> parents: 21724 diff changeset	618 @end deftypefn */)
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	619 {
20816 b16bcd7a2a33 Use int rather than octave_idx_type for nargin data type. Rik <rik@octave.org> parents: 20812 diff changeset	620 int nargin = args.length ();
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	621
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	622 if (nargin != 4 && nargin != 5)
20802 8bb38ba1bad6 eliminate return statements after calls to print_usage John W. Eaton <jwe@octave.org> parents: 20711 diff changeset	623 print_usage ();
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	624
20812 d9ca869ca124 maint: Clean-up more instances of print_usage(). Rik <rik@octave.org> parents: 20802 diff changeset	625 bool pivoted = (nargin == 5);
d9ca869ca124 maint: Clean-up more instances of print_usage(). Rik <rik@octave.org> parents: 20802 diff changeset	626
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	627 octave_value argl = args(0);
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	628 octave_value argu = args(1);
23450 855122b993da maint: Wrap tertiary operator in parentheses "(COND ? x : y)". Rik <rik@octave.org> parents: 23220 diff changeset	629 octave_value argp = (pivoted ? args(2) : octave_value ());
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	630 octave_value argx = args(2 + pivoted);
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	631 octave_value argy = args(3 + pivoted);
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	632
23586 f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23583 diff changeset	633 if (! (argl.isnumeric () && argu.isnumeric ()
f6c5db0a02e7 maint: Deprecate is_numeric_type and replace with isnumeric. Rik <rik@octave.org> parents: 23583 diff changeset	634 && argx.isnumeric () && argy.isnumeric ()
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	635 && (! pivoted \|\| argp.is_perm_matrix ())))
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	636 error ("luupdate: L, U, X, and Y must be numeric");
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	637
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	638 if (! check_lu_dims (argl, argu, argp))
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	639 error ("luupdate: dimension mismatch");
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	640
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	641 PermMatrix P = (pivoted
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	642 ? argp.perm_matrix_value ()
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	643 : PermMatrix::eye (argl.rows ()));
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	644
23582 0cc2011d800e maint: Deprecate is_real_type and replace with isreal. Rik <rik@octave.org> parents: 23581 diff changeset	645 if (argl.isreal () && argu.isreal ()
0cc2011d800e maint: Deprecate is_real_type and replace with isreal. Rik <rik@octave.org> parents: 23581 diff changeset	646 && argx.isreal () && argy.isreal ())
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	647 {
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	648 // all real case
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	649 if (argl.is_single_type () \|\| argu.is_single_type ()
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	650 \|\| argx.is_single_type () \|\| argy.is_single_type ())
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	651 {
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	652 FloatMatrix L = argl.float_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	653 FloatMatrix U = argu.float_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	654 FloatMatrix x = argx.float_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	655 FloatMatrix y = argy.float_matrix_value ();
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	656
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	657 octave::math::lu<FloatMatrix> fact (L, U, P);
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	658 if (pivoted)
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	659 fact.update_piv (x, y);
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	660 else
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	661 fact.update (x, y);
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	662
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	663 if (pivoted)
20898 8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	664 return ovl (get_lu_l (fact), get_lu_u (fact), fact.P ());
8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	665 else
8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	666 return ovl (get_lu_l (fact), get_lu_u (fact));
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	667 }
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	668 else
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	669 {
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	670 Matrix L = argl.matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	671 Matrix U = argu.matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	672 Matrix x = argx.matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	673 Matrix y = argy.matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	674
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	675 octave::math::lu<Matrix> fact (L, U, P);
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	676 if (pivoted)
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	677 fact.update_piv (x, y);
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	678 else
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	679 fact.update (x, y);
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	680
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	681 if (pivoted)
20898 8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	682 return ovl (get_lu_l (fact), get_lu_u (fact), fact.P ());
8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	683 else
8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	684 return ovl (get_lu_l (fact), get_lu_u (fact));
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	685 }
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	686 }
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	687 else
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	688 {
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	689 // complex case
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	690 if (argl.is_single_type () \|\| argu.is_single_type ()
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	691 \|\| argx.is_single_type () \|\| argy.is_single_type ())
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	692 {
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	693 FloatComplexMatrix L = argl.float_complex_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	694 FloatComplexMatrix U = argu.float_complex_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	695 FloatComplexMatrix x = argx.float_complex_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	696 FloatComplexMatrix y = argy.float_complex_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	697
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	698 octave::math::lu<FloatComplexMatrix> fact (L, U, P);
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	699 if (pivoted)
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	700 fact.update_piv (x, y);
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	701 else
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	702 fact.update (x, y);
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	703
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	704 if (pivoted)
20898 8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	705 return ovl (get_lu_l (fact), get_lu_u (fact), fact.P ());
8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	706 else
8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	707 return ovl (get_lu_l (fact), get_lu_u (fact));
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	708 }
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	709 else
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	710 {
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	711 ComplexMatrix L = argl.complex_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	712 ComplexMatrix U = argu.complex_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	713 ComplexMatrix x = argx.complex_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	714 ComplexMatrix y = argy.complex_matrix_value ();
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	715
22317 6ca3acf5fad8 move some new numeric classes to namespace octave::math John W. Eaton <jwe@octave.org> parents: 21966 diff changeset	716 octave::math::lu<ComplexMatrix> fact (L, U, P);
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	717 if (pivoted)
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	718 fact.update_piv (x, y);
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	719 else
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	720 fact.update (x, y);
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	721
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	722 if (pivoted)
20898 8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	723 return ovl (get_lu_l (fact), get_lu_u (fact), fact.P ());
8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	724 else
8da80da1ac37 maint: Use ovl() more places in the code. Rik <rik@octave.org> parents: 20892 diff changeset	725 return ovl (get_lu_l (fact), get_lu_u (fact));
20892 c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	726 }
c07bee629973 2015 Code Sprint: use ovl (). Rik <rik@octave.org> parents: 20853 diff changeset	727 }
9708 6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	728 }
6f3ffe11d926 implement luupdate Jaroslav Hajek <highegg@gmail.com> parents: 9209 diff changeset	729
7814 87865ed7405f Second set of single precision test code and fix of resulting bugs David Bateman <dbateman@free.fr> parents: 7789 diff changeset	730 /*
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	731 %!shared A, u, v, Ac, uc, vc
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	732 %! A = [0.091364 0.613038 0.999083;
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	733 %! 0.594638 0.425302 0.603537;
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	734 %! 0.383594 0.291238 0.085574;
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	735 %! 0.265712 0.268003 0.238409;
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	736 %! 0.669966 0.743851 0.445057 ];
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	737 %!
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	738 %! u = [0.85082;
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	739 %! 0.76426;
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	740 %! 0.42883;
12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	741 %! 0.53010;
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	742 %! 0.80683 ];
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	743 %!
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	744 %! v = [0.98810;
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	745 %! 0.24295;
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	746 %! 0.43167 ];
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	747 %!
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	748 %! Ac = [0.620405 + 0.956953i 0.480013 + 0.048806i 0.402627 + 0.338171i;
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	749 %! 0.589077 + 0.658457i 0.013205 + 0.279323i 0.229284 + 0.721929i;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	750 %! 0.092758 + 0.345687i 0.928679 + 0.241052i 0.764536 + 0.832406i;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	751 %! 0.912098 + 0.721024i 0.049018 + 0.269452i 0.730029 + 0.796517i;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	752 %! 0.112849 + 0.603871i 0.486352 + 0.142337i 0.355646 + 0.151496i ];
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	753 %!
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	754 %! uc = [0.20351 + 0.05401i;
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	755 %! 0.13141 + 0.43708i;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	756 %! 0.29808 + 0.08789i;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	757 %! 0.69821 + 0.38844i;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	758 %! 0.74871 + 0.25821i ];
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	759 %!
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	760 %! vc = [0.85839 + 0.29468i;
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	761 %! 0.20820 + 0.93090i;
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	762 %! 0.86184 + 0.34689i ];
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	763 %!
cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	764
10094 ab1101011a6d lu.cc: avoid test failures if HAVE_QRUPDATE_LUU is not defined John W. Eaton <jwe@octave.org> parents: 10080 diff changeset	765 %!testif HAVE_QRUPDATE_LUU
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	766 %! [L,U,P] = lu (A);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	767 %! [L,U] = luupdate (L,U,P*u,v);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	768 %! assert (norm (vec (tril (L)-L), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	769 %! assert (norm (vec (triu (U)-U), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	770 %! assert (norm (vec (P'LU - A - uv.'), Inf) < norm (A)1e1*eps);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	771 %!
10094 ab1101011a6d lu.cc: avoid test failures if HAVE_QRUPDATE_LUU is not defined John W. Eaton <jwe@octave.org> parents: 10080 diff changeset	772 %!testif HAVE_QRUPDATE_LUU
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	773 %! [L,U,P] = lu (Ac);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	774 %! [L,U] = luupdate (L,U,P*uc,vc);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	775 %! assert (norm (vec (tril (L)-L), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	776 %! assert (norm (vec (triu (U)-U), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	777 %! assert (norm (vec (P'LU - Ac - ucvc.'), Inf) < norm (Ac)1e1*eps);
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	778
10094 ab1101011a6d lu.cc: avoid test failures if HAVE_QRUPDATE_LUU is not defined John W. Eaton <jwe@octave.org> parents: 10080 diff changeset	779 %!testif HAVE_QRUPDATE_LUU
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	780 %! [L,U,P] = lu (single (A));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	781 %! [L,U] = luupdate (L,U,P*single (u), single (v));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	782 %! assert (norm (vec (tril (L)-L), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	783 %! assert (norm (vec (triu (U)-U), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	784 %! assert (norm (vec (P'LU - single (A) - single (u)single (v).'), Inf) < norm (single (A))1e1*eps ("single"));
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	785 %!
10094 ab1101011a6d lu.cc: avoid test failures if HAVE_QRUPDATE_LUU is not defined John W. Eaton <jwe@octave.org> parents: 10080 diff changeset	786 %!testif HAVE_QRUPDATE_LUU
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	787 %! [L,U,P] = lu (single (Ac));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	788 %! [L,U] = luupdate (L,U,P*single (uc),single (vc));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	789 %! assert (norm (vec (tril (L)-L), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	790 %! assert (norm (vec (triu (U)-U), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	791 %! assert (norm (vec (P'LU - single (Ac) - single (uc)single (vc).'), Inf) < norm (single (Ac))1e1*eps ("single"));
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	792
10094 ab1101011a6d lu.cc: avoid test failures if HAVE_QRUPDATE_LUU is not defined John W. Eaton <jwe@octave.org> parents: 10080 diff changeset	793 %!testif HAVE_QRUPDATE_LUU
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	794 %! [L,U,P] = lu (A);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	795 %! [L,U,P] = luupdate (L,U,P,u,v);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	796 %! assert (norm (vec (tril (L)-L), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	797 %! assert (norm (vec (triu (U)-U), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	798 %! assert (norm (vec (P'LU - A - uv.'), Inf) < norm (A)1e1*eps);
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	799 %!
10094 ab1101011a6d lu.cc: avoid test failures if HAVE_QRUPDATE_LUU is not defined John W. Eaton <jwe@octave.org> parents: 10080 diff changeset	800 %!testif HAVE_QRUPDATE_LUU
18849 aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	801 %! [L,U,P] = lu (A);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	802 %! [~,ordcols] = max (P,[],1);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	803 %! [~,ordrows] = max (P,[],2);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	804 %! P1 = eye (size(P))(:,ordcols);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	805 %! P2 = eye (size(P))(ordrows,:);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	806 %! assert(P1 == P);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	807 %! assert(P2 == P);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	808 %! [L,U,P] = luupdate (L,U,P,u,v);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	809 %! [L,U,P1] = luupdate (L,U,P1,u,v);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	810 %! [L,U,P2] = luupdate (L,U,P2,u,v);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	811 %! assert(P1 == P);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	812 %! assert(P2 == P);
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	813 %!
aa9ca67f09fb make all permutation matrices column permutations (bug #42418) David Spies <dnspies@gmail.com> parents: 18678 diff changeset	814 %!testif HAVE_QRUPDATE_LUU
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	815 %! [L,U,P] = lu (Ac);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	816 %! [L,U,P] = luupdate (L,U,P,uc,vc);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	817 %! assert (norm (vec (tril (L)-L), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	818 %! assert (norm (vec (triu (U)-U), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	819 %! assert (norm (vec (P'LU - Ac - ucvc.'), Inf) < norm (Ac)1e1*eps);
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	820
10094 ab1101011a6d lu.cc: avoid test failures if HAVE_QRUPDATE_LUU is not defined John W. Eaton <jwe@octave.org> parents: 10080 diff changeset	821 %!testif HAVE_QRUPDATE_LUU
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	822 %! [L,U,P] = lu (single (A));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	823 %! [L,U,P] = luupdate (L,U,P,single (u),single (v));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	824 %! assert (norm (vec (tril (L)-L), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	825 %! assert (norm (vec (triu (U)-U), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	826 %! assert (norm (vec (P'LU - single (A) - single (u)single (v).'), Inf) < norm (single (A))1e1*eps ("single"));
11586 12df7854fa7c strip trailing whitespace from source files John W. Eaton <jwe@octave.org> parents: 11572 diff changeset	827 %!
10094 ab1101011a6d lu.cc: avoid test failures if HAVE_QRUPDATE_LUU is not defined John W. Eaton <jwe@octave.org> parents: 10080 diff changeset	828 %!testif HAVE_QRUPDATE_LUU
14501 60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	829 %! [L,U,P] = lu (single (Ac));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	830 %! [L,U,P] = luupdate (L,U,P,single (uc),single (vc));
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	831 %! assert (norm (vec (tril (L)-L), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	832 %! assert (norm (vec (triu (U)-U), Inf) == 0);
60e5cf354d80 Update %!tests in DLD-FUNCTIONS/ directory with Octave coding conventions. Rik <octave@nomad.inbox5.com> parents: 14361 diff changeset	833 %! assert (norm (vec (P'LU - single (Ac) - single (uc)single (vc).'), Inf) < norm (single (Ac))1e1*eps ("single"));
10080 cf70ee43077c add tests for LU updating Jaroslav Hajek <highegg@gmail.com> parents: 9724 diff changeset	834 */

Mercurial > octave

annotate libinterp/corefcn/lu.cc @ 28154:e7fe6703a81f stable