octave-nkf: scripts/sparse/eigs.m annotate

annotate scripts/sparse/eigs.m @ 20526:d8992a16643c

doc: Clean up m-files which generate images for Manual. * geometryimages.m, interpimages.m, plotimages.m, sparseimages.m, splineimages.m: Use the same style throughout the mi-files. Obey Octave coding conventions.

author	Rik <rik@octave.org>
date	Thu, 09 Jul 2015 21:38:57 -0700
parents	df437a52bcaf
children

rev	line source
19898 4197fc428c7d maint: Update copyright notices for 2015. John W. Eaton <jwe@octave.org> parents: 19863 diff changeset	1 ## Copyright (C) 2005-2015 David Bateman
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	2 ##
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	3 ## This file is part of Octave.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	4 ##
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	5 ## Octave is free software; you can redistribute it and/or modify it
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	6 ## under the terms of the GNU General Public License as published by
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	7 ## the Free Software Foundation; either version 3 of the License, or (at
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	8 ## your option) any later version.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	9 ##
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	10 ## Octave is distributed in the hope that it will be useful, but
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	11 ## WITHOUT ANY WARRANTY; without even the implied warranty of
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	12 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	13 ## General Public License for more details.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	14 ##
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	15 ## You should have received a copy of the GNU General Public License
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	16 ## along with Octave; see the file COPYING. If not, see
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	17 ## <http://www.gnu.org/licenses/>.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	18
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	19 ## -- texinfo --
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	20 ## @deftypefn {Function File} {@var{d} =} eigs (@var{A})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	21 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{A}, @var{k})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	22 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{A}, @var{k}, @var{sigma})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	23 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{A}, @var{k}, @var{sigma}, @var{opts})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	24 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{A}, @var{B})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	25 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{A}, @var{B}, @var{k})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	26 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{A}, @var{B}, @var{k}, @var{sigma})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	27 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{A}, @var{B}, @var{k}, @var{sigma}, @var{opts})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	28 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{af}, @var{n})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	29 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{af}, @var{n}, @var{B})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	30 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{af}, @var{n}, @var{k})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	31 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{af}, @var{n}, @var{B}, @var{k})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	32 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{af}, @var{n}, @var{k}, @var{sigma})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	33 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{af}, @var{n}, @var{B}, @var{k}, @var{sigma})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	34 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{af}, @var{n}, @var{k}, @var{sigma}, @var{opts})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	35 ## @deftypefnx {Function File} {@var{d} =} eigs (@var{af}, @var{n}, @var{B}, @var{k}, @var{sigma}, @var{opts})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	36 ## @deftypefnx {Function File} {[@var{V}, @var{d}] =} eigs (@var{A}, @dots{})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	37 ## @deftypefnx {Function File} {[@var{V}, @var{d}] =} eigs (@var{af}, @var{n}, @dots{})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	38 ## @deftypefnx {Function File} {[@var{V}, @var{d}, @var{flag}] =} eigs (@var{A}, @dots{})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	39 ## @deftypefnx {Function File} {[@var{V}, @var{d}, @var{flag}] =} eigs (@var{af}, @var{n}, @dots{})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	40 ## Calculate a limited number of eigenvalues and eigenvectors of @var{A},
20374 df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	41 ## based on a selection criteria.
df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	42 ##
df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	43 ## The number of eigenvalues and eigenvectors to calculate is given by
df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	44 ## @var{k} and defaults to 6.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	45 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	46 ## By default, @code{eigs} solve the equation
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	47 ## @tex
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	48 ## $A \nu = \lambda \nu$,
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	49 ## @end tex
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	50 ## @ifinfo
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	51 ## @code{A * v = lambda * v},
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	52 ## @end ifinfo
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	53 ## where
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	54 ## @tex
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	55 ## $\lambda$ is a scalar representing one of the eigenvalues, and $\nu$
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	56 ## @end tex
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	57 ## @ifinfo
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	58 ## @code{lambda} is a scalar representing one of the eigenvalues, and @code{v}
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	59 ## @end ifinfo
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	60 ## is the corresponding eigenvector. If given the positive definite matrix
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	61 ## @var{B} then @code{eigs} solves the general eigenvalue equation
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	62 ## @tex
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	63 ## $A \nu = \lambda B \nu$.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	64 ## @end tex
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	65 ## @ifinfo
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	66 ## @code{A * v = lambda * B * v}.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	67 ## @end ifinfo
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	68 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	69 ## The argument @var{sigma} determines which eigenvalues are returned.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	70 ## @var{sigma} can be either a scalar or a string. When @var{sigma} is a
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	71 ## scalar, the @var{k} eigenvalues closest to @var{sigma} are returned. If
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	72 ## @var{sigma} is a string, it must have one of the following values.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	73 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	74 ## @table @asis
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	75 ## @item @qcode{"lm"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	76 ## Largest Magnitude (default).
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	77 ##
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	78 ## @item @qcode{"sm"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	79 ## Smallest Magnitude.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	80 ##
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	81 ## @item @qcode{"la"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	82 ## Largest Algebraic (valid only for real symmetric problems).
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	83 ##
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	84 ## @item @qcode{"sa"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	85 ## Smallest Algebraic (valid only for real symmetric problems).
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	86 ##
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	87 ## @item @qcode{"be"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	88 ## Both Ends, with one more from the high-end if @var{k} is odd (valid only for
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	89 ## real symmetric problems).
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	90 ##
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	91 ## @item @qcode{"lr"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	92 ## Largest Real part (valid only for complex or unsymmetric problems).
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	93 ##
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	94 ## @item @qcode{"sr"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	95 ## Smallest Real part (valid only for complex or unsymmetric problems).
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	96 ##
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	97 ## @item @qcode{"li"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	98 ## Largest Imaginary part (valid only for complex or unsymmetric problems).
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	99 ##
17281 bc924baa2c4e doc: Add new @qcode macro for code samples which are quoted. Rik <rik@octave.org> parents: 17220 diff changeset	100 ## @item @qcode{"si"}
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	101 ## Smallest Imaginary part (valid only for complex or unsymmetric problems).
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	102 ## @end table
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	103 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	104 ## If @var{opts} is given, it is a structure defining possible options that
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	105 ## @code{eigs} should use. The fields of the @var{opts} structure are:
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	106 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	107 ## @table @code
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	108 ## @item issym
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	109 ## If @var{af} is given, then flags whether the function @var{af} defines a
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	110 ## symmetric problem. It is ignored if @var{A} is given. The default is false.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	111 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	112 ## @item isreal
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	113 ## If @var{af} is given, then flags whether the function @var{af} defines a
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	114 ## real problem. It is ignored if @var{A} is given. The default is true.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	115 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	116 ## @item tol
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	117 ## Defines the required convergence tolerance, calculated as
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	118 ## @code{tol * norm (A)}. The default is @code{eps}.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	119 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	120 ## @item maxit
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	121 ## The maximum number of iterations. The default is 300.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	122 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	123 ## @item p
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	124 ## The number of Lanzcos basis vectors to use. More vectors will result in
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	125 ## faster convergence, but a greater use of memory. The optimal value of
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	126 ## @code{p} is problem dependent and should be in the range @var{k} to @var{n}.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	127 ## The default value is @code{2 * @var{k}}.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	128 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	129 ## @item v0
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	130 ## The starting vector for the algorithm. An initial vector close to the
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	131 ## final vector will speed up convergence. The default is for @sc{arpack}
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	132 ## to randomly generate a starting vector. If specified, @code{v0} must be
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	133 ## an @var{n}-by-1 vector where @code{@var{n} = rows (@var{A})}
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	134 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	135 ## @item disp
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	136 ## The level of diagnostic printout (0\|1\|2). If @code{disp} is 0 then
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	137 ## diagnostics are disabled. The default value is 0.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	138 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	139 ## @item cholB
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	140 ## Flag if @code{chol (@var{B})} is passed rather than @var{B}. The default is
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	141 ## false.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	142 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	143 ## @item permB
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	144 ## The permutation vector of the Cholesky@tie{}factorization of @var{B} if
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	145 ## @code{cholB} is true. That is @code{chol (@var{B}(permB, permB))}. The
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	146 ## default is @code{1:@var{n}}.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	147 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	148 ## @end table
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	149 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	150 ## It is also possible to represent @var{A} by a function denoted @var{af}.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	151 ## @var{af} must be followed by a scalar argument @var{n} defining the length
20374 df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	152 ## of the vector argument accepted by @var{af}. @var{af} can be a function
df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	153 ## handle, an inline function, or a string. When @var{af} is a string it
df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	154 ## holds the name of the function to use.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	155 ##
20374 df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	156 ## @var{af} is a function of the form @code{y = af (x)} where the required
df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	157 ## return value of @var{af} is determined by the value of @var{sigma}. The
df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	158 ## four possible forms are
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	159 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	160 ## @table @code
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	161 ## @item A * x
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	162 ## if @var{sigma} is not given or is a string other than "sm".
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	163 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	164 ## @item A \ x
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	165 ## if @var{sigma} is 0 or "sm".
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	166 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	167 ## @item (A - sigma * I) \ x
20374 df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	168 ## for the standard eigenvalue problem, where @code{I} is the identity matrix
df437a52bcaf doc: Update more docstrings to have one sentence summary as first line. Rik <rik@octave.org> parents: 20038 diff changeset	169 ## of the same size as @var{A}.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	170 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	171 ## @item (A - sigma * B) \ x
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	172 ## for the general eigenvalue problem.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	173 ## @end table
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	174 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	175 ## The return arguments of @code{eigs} depend on the number of return arguments
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	176 ## requested. With a single return argument, a vector @var{d} of length @var{k}
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	177 ## is returned containing the @var{k} eigenvalues that have been found. With
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	178 ## two return arguments, @var{V} is a @var{n}-by-@var{k} matrix whose columns
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	179 ## are the @var{k} eigenvectors corresponding to the returned eigenvalues. The
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	180 ## eigenvalues themselves are returned in @var{d} in the form of a
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	181 ## @var{n}-by-@var{k} matrix, where the elements on the diagonal are the
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	182 ## eigenvalues.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	183 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	184 ## Given a third return argument @var{flag}, @code{eigs} returns the status
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	185 ## of the convergence. If @var{flag} is 0 then all eigenvalues have converged.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	186 ## Any other value indicates a failure to converge.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	187 ##
19232 0850b5212619 doc: Add @nospell macro around proper names in documentation. Rik <rik@octave.org> parents: 18972 diff changeset	188 ## This function is based on the @sc{arpack} package, written by
0850b5212619 doc: Add @nospell macro around proper names in documentation. Rik <rik@octave.org> parents: 18972 diff changeset	189 ## @nospell{R. Lehoucq, K. Maschhoff, D. Sorensen, and C. Yang}. For more
0850b5212619 doc: Add @nospell macro around proper names in documentation. Rik <rik@octave.org> parents: 18972 diff changeset	190 ## information see @url{http://www.caam.rice.edu/software/ARPACK/}.
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	191 ##
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	192 ## @seealso{eig, svds}
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	193 ## @end deftypefn
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	194
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	195 function varargout = eigs (varargin)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	196
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	197 ## For compatibility with Matlab, handle small matrix cases here
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	198 ## that ARPACK does not.
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	199
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	200 if (nargin == 0)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	201 print_usage ();
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	202 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	203
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	204 call_eig = false;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	205 offset = 0;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	206 k = 6;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	207 sigma = "lm";
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	208
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	209 if (isnumeric (varargin{1}) && issquare (varargin{1}))
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	210 a = varargin{1};
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	211 if (nargin > 1 && isnumeric (varargin{2})
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	212 && issquare (varargin{2}) && size_equal (a, varargin{2}))
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	213 b = varargin{2};
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	214 offset = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	215 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	216
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	217 if (rows (a) < 9)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	218 call_eig = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	219 endif
19790 446c46af4b42 strip trailing whitespace from most source files John W. Eaton <jwe@octave.org> parents: 18972 diff changeset	220
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	221 if (nargin > 1 + offset)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	222 tmp = varargin{2+offset};
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	223 if (isnumeric (tmp) && isscalar (tmp) && isreal (tmp)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	224 && round (tmp) == tmp)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	225 k = tmp;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	226
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	227 if (rows (a) - k < 3)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	228 call_eig = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	229 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	230 else
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	231 call_eig = false;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	232 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	233
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	234 if (nargin > 2 + offset)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	235 tmp = varargin{3+offset};
19862 6e2729924601 eigs.m: Only transform char input sigma to lower case in cset 08dbf53f34c1. Rik <rik@octave.org> parents: 19825 diff changeset	236 if (ischar (tmp))
19825 08dbf53f34c1 eigs.m: Transform any character input for sigma to lower case before proceeding. Rik <rik@octave.org> parents: 19790 diff changeset	237 sigma = tolower (tmp);
19862 6e2729924601 eigs.m: Only transform char input sigma to lower case in cset 08dbf53f34c1. Rik <rik@octave.org> parents: 19825 diff changeset	238 elseif (isnumeric (tmp) && isscalar (tmp))
6e2729924601 eigs.m: Only transform char input sigma to lower case in cset 08dbf53f34c1. Rik <rik@octave.org> parents: 19825 diff changeset	239 sigma = tmp;
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	240 else
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	241 call_eig = false;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	242 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	243 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	244 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	245 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	246
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	247 if (call_eig)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	248 varargout = cell (1, min (2, max (1, nargout)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	249 if (offset)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	250 real_valued = isreal (a) && isreal (b);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	251 symmetric = issymmetric (a) && issymmetric (b);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	252 [varargout{:}] = eig (a, b);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	253 else
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	254 real_valued = isreal (a);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	255 symmetric = issymmetric (a);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	256 [varargout{:}] = eig (a);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	257 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	258 varargout = select (varargout, k, sigma, real_valued, symmetric);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	259 if (nargout == 3)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	260 varargout{3} = 0;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	261 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	262 else
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	263 varargout = cell (1, max (1, nargout));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	264 [varargout{:}] = __eigs__ (varargin{:});
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	265 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	266
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	267 endfunction
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	268
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	269 function out = select (args, k, sigma, real_valued, symmetric)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	270
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	271 if (numel (args) == 1)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	272 d = args{1};
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	273 else
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	274 d = diag (args{2});
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	275 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	276
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	277 if (ischar (sigma))
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	278 switch (sigma)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	279 case "lm"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	280 [~, idx] = sort (abs (d), "descend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	281
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	282 case "sm"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	283 [~, idx] = sort (abs (d), "ascend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	284
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	285 case "la"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	286 if (real_valued && symmetric)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	287 [~, idx] = sort (real (d), "descend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	288 else
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	289 error ('sigma = "la" requires real symmetric problem');
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	290 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	291
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	292 case "sa"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	293 if (real_valued && symmetric)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	294 [~, idx] = sort (real (d), "ascend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	295 else
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	296 error ('sigma = "sa" requires real symmetric problem');
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	297 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	298
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	299 case "be"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	300 if (real_valued && symmetric)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	301 [~, idx] = sort (real (d), "ascend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	302 else
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	303 error ('sigma = "be" requires real symmetric problem');
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	304 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	305
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	306 case "lr"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	307 if (! (real_valued \|\| symmetric))
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	308 [~, idx] = sort (real (d), "descend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	309 else
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	310 error ('sigma = "lr" requires complex or unsymmetric problem');
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	311 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	312
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	313 case "sr"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	314 if (! (real_valued \|\| symmetric))
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	315 [~, idx] = sort (real (d), "ascend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	316 else
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	317 error ('sigma = "sr" requires complex or unsymmetric problem');
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	318 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	319
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	320 case "li"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	321 if (! (real_valued \|\| symmetric))
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	322 [~, idx] = sort (imag (d), "descend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	323 else
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	324 error ('sigma = "li" requires complex or unsymmetric problem');
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	325 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	326
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	327 case "si"
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	328 if (! (real_valued \|\| symmetric))
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	329 [~, idx] = sort (imag (d), "ascend");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	330 else
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	331 error ('sigma = "si" requires complex or unsymmetric problem');
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	332 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	333
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	334 otherwise
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	335 error ("unrecognized value for sigma: %s", sigma);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	336 endswitch
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	337 else
42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	338 ## numeric sigma, find k closest values
42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	339 [~, idx] = sort (abs (d - sigma));
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	340 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	341
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	342 d = d(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	343
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	344 n = numel (d);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	345
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	346 k = min (k, n);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	347
17846 42453dcfa95e eigs.m: Fix regression when numeric sigma is used and eig() is called instead of __eigs__. Rik <rik@octave.org> parents: 17845 diff changeset	348 if (strcmp (sigma, "be"))
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	349 tmp = k / 2;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	350 n1 = floor (tmp);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	351 n2 = n - ceil (tmp) + 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	352 selection = [1:floor(k/2), n2:n];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	353 else
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	354 selection = 1:k;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	355 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	356
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	357 d = d(selection);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	358
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	359 if (numel (args) == 1)
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	360 out{1} = d;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	361 else
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	362 out{2} = diag (d);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	363
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	364 v = args{1};
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	365 v = v(:,idx);
18972 1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	366 out{1} = v(:,selection);
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	367 endif
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	368
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	369 endfunction
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	370
17338 1c89599167a6 maint: End m-files with 1 blank line. Rik <rik@octave.org> parents: 17281 diff changeset	371
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	372 #### SPARSE MATRIX VERSIONS ####
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	373
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	374 ## Real positive definite tests, n must be even
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	375 %!shared n, k, A, d0, d2
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	376 %! n = 20;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	377 %! k = 4;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	378 %! A = sparse ([3:n,1:n,1:(n-2)],[1:(n-2),1:n,3:n],[ones(1,n-2),4*ones(1,n),ones(1,n-2)]);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	379 %! d0 = eig (A);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	380 %! d2 = sort (d0);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	381 %! [~, idx] = sort (abs (d0));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	382 %! d0 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	383 %! rand ("state", 42); # initialize generator to make eigs behavior reproducible
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	384 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	385 %! d1 = eigs (A, k);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	386 %! assert (d1, d0(end:-1:(end-k+1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	387 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	388 %! d1 = eigs (A, k+1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	389 %! assert (d1, d0(end:-1:(end-k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	390 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	391 %! d1 = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	392 %! assert (d1, d0(end:-1:(end-k+1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	393 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	394 %! d1 = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	395 %! assert (d1, d0(k:-1:1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	396 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	397 %! d1 = eigs (A, k, "la");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	398 %! assert (d1, d2(end:-1:(end-k+1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	399 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	400 %! d1 = eigs (A, k, "sa");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	401 %! assert (d1, d2(1:k), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	402 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	403 %! d1 = eigs (A, k, "be");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	404 %! assert (d1, d2([1:floor(k/2), (end - ceil(k/2) + 1):end]), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	405 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	406 %! d1 = eigs (A, k+1, "be");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	407 %! assert (d1, d2([1:floor((k+1)/2), (end - ceil((k+1)/2) + 1):end]), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	408 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	409 %! d1 = eigs (A, k, 4.1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	410 %! [~, idx0] = sort (abs (d0 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	411 %! [~, idx1] = sort (abs (d1 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	412 %! assert (d1(idx1), d0(idx0(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	413 %!testif HAVE_ARPACK, HAVE_CHOLMOD
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	414 %! d1 = eigs (A, speye (n), k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	415 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	416 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	417 %! assert (eigs (A, k, 4.1), eigs (A, speye (n), k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	418 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	419 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	420 %! d1 = eigs (A, speye (n), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	421 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	422 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	423 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	424 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	425 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	426 %! d1 = eigs (A, speye (n)(q,q), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	427 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	428 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	429 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	430 %! d1 = eigs (A, speye (n), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	431 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	432 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	433 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	434 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	435 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	436 %! d1 = eigs (A, speye (n)(q,q), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	437 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	438 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	439 %! assert (eigs (A, k, 4.1), eigs (A, speye (n), k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	440 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	441 %! fn = @(x) A * x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	442 %! opts.issym = 1; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	443 %! d1 = eigs (fn, n, k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	444 %! assert (d1, d0(end:-1:(end-k+1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	445 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	446 %! fn = @(x) A \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	447 %! opts.issym = 1; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	448 %! d1 = eigs (fn, n, k, "sm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	449 %! assert (d1, d0(k:-1:1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	450 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	451 %! fn = @(x) (A - 4.1 * eye (n)) \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	452 %! opts.issym = 1; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	453 %! d1 = eigs (fn, n, k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	454 %! assert (d1, eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	455 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	456 %! AA = speye (10);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	457 %! fn = @(x) AA * x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	458 %! opts.issym = 1; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	459 %! assert (eigs (fn, 10, AA, 3, "lm", opts), [1; 1; 1], 10*eps);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	460 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	461 %! [v1,d1] = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	462 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	463 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	464 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	465 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	466 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	467 %! [v1,d1] = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	468 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	469 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	470 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	471 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	472 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	473 %! [v1,d1] = eigs (A, k, "la");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	474 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	475 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	476 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	477 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	478 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	479 %! [v1,d1] = eigs (A, k, "sa");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	480 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	481 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	482 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	483 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	484 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	485 %! [v1,d1] = eigs (A, k, "be");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	486 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	487 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	488 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	489 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	490
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	491 ## Real unsymmetric tests
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	492 %!shared n, k, A, d0
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	493 %! n = 20;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	494 %! k = 4;
20038 9fc020886ae9 maint: Clean up m-files to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	495 %! A = sparse ([3:n,1:n,1:(n-2)],[1:(n-2),1:n,3:n],[ones(1,n-2),1:n,-ones(1,n-2)]);
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	496 %! d0 = eig (A);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	497 %! [~, idx] = sort (abs (d0));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	498 %! d0 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	499 %! rand ("state", 42); % initialize generator to make eigs behavior reproducible
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	500 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	501 %! d1 = eigs (A, k);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	502 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	503 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	504 %! d1 = eigs (A, k+1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	505 %! assert (abs (d1), abs (d0(end:-1:(end-k))),1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	506 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	507 %! d1 = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	508 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	509 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	510 %! d1 = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	511 %! assert (abs (d1), abs (d0(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	512 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	513 %! d1 = eigs (A, k, "lr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	514 %! [~, idx] = sort (real (d0));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	515 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	516 %! assert (real (d1), real (d2(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	517 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	518 %! d1 = eigs (A, k, "sr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	519 %! [~, idx] = sort (real (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	520 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	521 %! assert (real (d1), real (d2(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	522 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	523 %! d1 = eigs (A, k, "li");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	524 %! [~, idx] = sort (imag (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	525 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	526 %! assert (sort (imag (d1)), sort (imag (d2(end:-1:(end-k+1)))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	527 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	528 %! d1 = eigs (A, k, "si");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	529 %! [~, idx] = sort (imag (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	530 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	531 %! assert (sort (imag (d1)), sort (imag (d2(1:k))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	532 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	533 %! d1 = eigs (A, k, 4.1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	534 %! [~, idx0] = sort (abs (d0 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	535 %! [~, idx1] = sort (abs (d1 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	536 %! assert (abs (d1(idx1)), abs (d0(idx0(1:k))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	537 %! assert (sort (imag (d1(idx1))), sort (imag (d0(idx0(1:k)))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	538 %!testif HAVE_ARPACK, HAVE_CHOLMOD
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	539 %! d1 = eigs (A, speye (n), k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	540 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	541 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	542 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	543 %! d1 = eigs (A, speye (n), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	544 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	545 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	546 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	547 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	548 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	549 %! d1 = eigs (A, speye (n)(q,q), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	550 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	551 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	552 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	553 %! d1 = eigs (A, speye (n), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	554 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	555 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	556 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	557 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	558 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	559 %! d1 = eigs (A, speye (n)(q,q), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	560 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	561 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	562 %! assert (abs (eigs (A, k, 4.1)), abs (eigs (A, speye (n), k, 4.1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	563 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	564 %! assert (sort (imag (eigs (A, k, 4.1))), sort (imag (eigs (A, speye (n), k, 4.1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	565 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	566 %! fn = @(x) A * x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	567 %! opts.issym = 0; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	568 %! d1 = eigs (fn, n, k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	569 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	570 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	571 %! fn = @(x) A \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	572 %! opts.issym = 0; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	573 %! d1 = eigs (fn, n, k, "sm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	574 %! assert (abs (d1), d0(1:k), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	575 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	576 %! fn = @(x) (A - 4.1 * eye (n)) \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	577 %! opts.issym = 0; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	578 %! d1 = eigs (fn, n, k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	579 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	580 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	581 %! [v1,d1] = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	582 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	583 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	584 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	585 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	586 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	587 %! [v1,d1] = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	588 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	589 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	590 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	591 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	592 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	593 %! [v1,d1] = eigs (A, k, "lr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	594 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	595 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	596 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	597 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	598 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	599 %! [v1,d1] = eigs (A, k, "sr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	600 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	601 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	602 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	603 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	604 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	605 %! [v1,d1] = eigs (A, k, "li");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	606 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	607 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	608 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	609 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	610 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	611 %! [v1,d1] = eigs (A, k, "si");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	612 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	613 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	614 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	615 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	616
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	617
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	618 ## Complex hermitian tests
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	619 %!shared n, k, A, d0
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	620 %! n = 20;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	621 %! k = 4;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	622 %! A = sparse ([3:n,1:n,1:(n-2)],[1:(n-2),1:n,3:n],[1iones(1,n-2),4ones(1,n),-1i*ones(1,n-2)]);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	623 %! d0 = eig (A);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	624 %! [~, idx] = sort (abs (d0));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	625 %! d0 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	626 %! rand ("state", 42); % initialize generator to make eigs behavior reproducible
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	627 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	628 %! d1 = eigs (A, k);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	629 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	630 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	631 %! d1 = eigs (A, k+1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	632 %! assert (abs (d1), abs (d0(end:-1:(end-k))),1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	633 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	634 %! d1 = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	635 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	636 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	637 %! d1 = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	638 %! assert (abs (d1), abs (d0(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	639 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	640 %! d1 = eigs (A, k, "lr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	641 %! [~, idx] = sort (real (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	642 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	643 %! assert (real (d1), real (d2(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	644 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	645 %! d1 = eigs (A, k, "sr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	646 %! [~, idx] = sort (real (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	647 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	648 %! assert (real (d1), real (d2(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	649 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	650 %! d1 = eigs (A, k, "li");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	651 %! [~, idx] = sort (imag (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	652 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	653 %! assert (sort (imag (d1)), sort (imag (d2(end:-1:(end-k+1)))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	654 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	655 %! d1 = eigs (A, k, "si");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	656 %! [~, idx] = sort (imag (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	657 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	658 %! assert (sort (imag (d1)), sort (imag (d2(1:k))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	659 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	660 %! d1 = eigs (A, k, 4.1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	661 %! [~, idx0] = sort (abs (d0 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	662 %! [~, idx1] = sort (abs (d1 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	663 %! assert (abs (d1(idx1)), abs (d0(idx0(1:k))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	664 %! assert (sort (imag (d1(idx1))), sort (imag (d0(idx0(1:k)))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	665 %!testif HAVE_ARPACK, HAVE_CHOLMOD
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	666 %! d1 = eigs (A, speye (n), k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	667 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	668 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	669 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	670 %! d1 = eigs (A, speye (n), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	671 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	672 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	673 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	674 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	675 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	676 %! d1 = eigs (A, speye (n)(q,q), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	677 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	678 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	679 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	680 %! d1 = eigs (A, speye (n), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	681 %! assert (abs (abs (d1)), abs (eigs (A, k, 4.1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	682 %! assert (sort (imag (abs (d1))), sort (imag (eigs (A, k, 4.1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	683 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	684 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	685 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	686 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	687 %! d1 = eigs (A, speye (n)(q,q), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	688 %! assert (abs (abs (d1)), abs (eigs (A, k, 4.1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	689 %! assert (sort (imag (abs (d1))), sort (imag (eigs (A, k, 4.1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	690 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	691 %! assert (abs (eigs (A, k, 4.1)), abs (eigs (A, speye (n), k, 4.1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	692 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	693 %! assert (sort (imag (eigs (A, k, 4.1))), sort (imag (eigs (A, speye (n), k, 4.1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	694 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	695 %! fn = @(x) A * x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	696 %! opts.issym = 0; opts.isreal = 0;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	697 %! d1 = eigs (fn, n, k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	698 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	699 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	700 %! fn = @(x) A \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	701 %! opts.issym = 0; opts.isreal = 0;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	702 %! d1 = eigs (fn, n, k, "sm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	703 %! assert (abs (d1), d0(1:k), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	704 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	705 %! fn = @(x) (A - 4.1 * eye (n)) \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	706 %! opts.issym = 0; opts.isreal = 0;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	707 %! d1 = eigs (fn, n, k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	708 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	709 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	710 %! [v1,d1] = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	711 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	712 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	713 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	714 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	715 %!testif HAVE_ARPACK, HAVE_UMFPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	716 %! [v1,d1] = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	717 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	718 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	719 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	720 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	721 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	722 %! [v1,d1] = eigs (A, k, "lr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	723 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	724 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	725 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	726 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	727 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	728 %! [v1,d1] = eigs (A, k, "sr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	729 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	730 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	731 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	732 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	733 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	734 %! [v1,d1] = eigs (A, k, "li");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	735 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	736 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	737 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	738 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	739 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	740 %! [v1,d1] = eigs (A, k, "si");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	741 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	742 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	743 %! assert (max (abs ((A - d1(i)speye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	744 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	745
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	746 #### FULL MATRIX VERSIONS ####
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	747
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	748 ## Real positive definite tests, n must be even
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	749 %!shared n, k, A, d0, d2
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	750 %! n = 20;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	751 %! k = 4;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	752 %! A = full (sparse ([3:n,1:n,1:(n-2)],[1:(n-2),1:n,3:n],[ones(1,n-2),4*ones(1,n),ones(1,n-2)]));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	753 %! d0 = eig (A);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	754 %! d2 = sort (d0);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	755 %! [~, idx] = sort (abs (d0));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	756 %! d0 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	757 %! rand ("state", 42); % initialize generator to make eigs behavior reproducible
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	758 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	759 %! d1 = eigs (A, k);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	760 %! assert (d1, d0(end:-1:(end-k+1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	761 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	762 %! d1 = eigs (A, k+1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	763 %! assert (d1, d0(end:-1:(end-k)),1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	764 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	765 %! d1 = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	766 %! assert (d1, d0(end:-1:(end-k+1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	767 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	768 %! d1 = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	769 %! assert (d1, d0(k:-1:1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	770 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	771 %! d1 = eigs (A, k, "la");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	772 %! assert (d1, d2(end:-1:(end-k+1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	773 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	774 %! d1 = eigs (A, k, "sa");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	775 %! assert (d1, d2(1:k), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	776 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	777 %! d1 = eigs (A, k, "be");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	778 %! assert (d1, d2([1:floor(k/2), (end - ceil(k/2) + 1):end]), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	779 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	780 %! d1 = eigs (A, k+1, "be");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	781 %! assert (d1, d2([1:floor((k+1)/2), (end - ceil((k+1)/2) + 1):end]), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	782 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	783 %! d1 = eigs (A, k, 4.1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	784 %! [~, idx0] = sort (abs (d0 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	785 %! [~, idx1] = sort (abs (d1 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	786 %! assert (d1(idx1), d0(idx0(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	787 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	788 %! d1 = eigs (A, eye (n), k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	789 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	790 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	791 %! assert (eigs (A, k, 4.1), eigs (A, eye (n), k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	792 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	793 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	794 %! d1 = eigs (A, eye (n), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	795 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	796 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	797 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	798 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	799 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	800 %! d1 = eigs (A, eye (n)(q,q), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	801 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	802 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	803 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	804 %! d1 = eigs (A, eye (n), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	805 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	806 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	807 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	808 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	809 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	810 %! d1 = eigs (A, eye (n)(q,q), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	811 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	812 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	813 %! assert (eigs (A, k, 4.1), eigs (A, eye (n), k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	814 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	815 %! fn = @(x) A * x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	816 %! opts.issym = 1; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	817 %! d1 = eigs (fn, n, k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	818 %! assert (d1, d0(end:-1:(end-k+1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	819 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	820 %! fn = @(x) A \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	821 %! opts.issym = 1; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	822 %! d1 = eigs (fn, n, k, "sm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	823 %! assert (d1, d0(k:-1:1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	824 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	825 %! fn = @(x) (A - 4.1 * eye (n)) \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	826 %! opts.issym = 1; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	827 %! d1 = eigs (fn, n, k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	828 %! assert (d1, eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	829 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	830 %! [v1,d1] = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	831 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	832 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	833 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	834 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	835 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	836 %! [v1,d1] = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	837 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	838 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	839 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	840 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	841 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	842 %! [v1,d1] = eigs (A, k, "la");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	843 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	844 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	845 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	846 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	847 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	848 %! [v1,d1] = eigs (A, k, "sa");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	849 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	850 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	851 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	852 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	853 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	854 %! [v1,d1] = eigs (A, k, "be");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	855 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	856 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	857 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	858 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	859
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	860 ## Real unsymmetric tests
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	861 %!shared n, k, A, d0
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	862 %! n = 20;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	863 %! k = 4;
20038 9fc020886ae9 maint: Clean up m-files to follow Octave coding conventions. Rik <rik@octave.org> parents: 19898 diff changeset	864 %! A = full (sparse ([3:n,1:n,1:(n-2)],[1:(n-2),1:n,3:n],[ones(1,n-2),1:n,-ones(1,n-2)]));
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	865 %! d0 = eig (A);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	866 %! [~, idx] = sort (abs (d0));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	867 %! d0 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	868 %! rand ("state", 42); % initialize generator to make eigs behavior reproducible
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	869 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	870 %! d1 = eigs (A, k);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	871 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	872 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	873 %! d1 = eigs (A, k+1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	874 %! assert (abs (d1), abs (d0(end:-1:(end-k))),1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	875 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	876 %! d1 = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	877 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	878 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	879 %! d1 = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	880 %! assert (abs (d1), abs (d0(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	881 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	882 %! d1 = eigs (A, k, "lr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	883 %! [~, idx] = sort (real (d0));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	884 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	885 %! assert (real (d1), real (d2(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	886 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	887 %! d1 = eigs (A, k, "sr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	888 %! [~, idx] = sort (real (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	889 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	890 %! assert (real (d1), real (d2(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	891 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	892 %! d1 = eigs (A, k, "li");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	893 %! [~, idx] = sort (imag (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	894 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	895 %! assert (sort (imag (d1)), sort (imag (d2(end:-1:(end-k+1)))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	896 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	897 %! d1 = eigs (A, k, "si");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	898 %! [~, idx] = sort (imag (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	899 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	900 %! assert (sort (imag (d1)), sort (imag (d2(1:k))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	901 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	902 %! d1 = eigs (A, k, 4.1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	903 %! [~, idx0] = sort (abs (d0 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	904 %! [~, idx1] = sort (abs (d1 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	905 %! assert (abs (d1(idx1)), abs (d0(idx0(1:k))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	906 %! assert (sort (imag (d1(idx1))), sort (imag (d0(idx0(1:k)))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	907 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	908 %! d1 = eigs (A, eye (n), k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	909 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	910 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	911 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	912 %! d1 = eigs (A, eye (n), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	913 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	914 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	915 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	916 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	917 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	918 %! d1 = eigs (A, eye (n)(q,q), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	919 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	920 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	921 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	922 %! d1 = eigs (A, eye (n), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	923 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	924 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	925 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	926 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	927 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	928 %! d1 = eigs (A, eye (n)(q,q), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	929 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	930 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	931 %! assert (abs (eigs (A, k, 4.1)), abs (eigs (A, eye (n), k, 4.1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	932 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	933 %! assert (sort (imag (eigs (A, k, 4.1))), sort (imag (eigs (A, eye (n), k, 4.1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	934 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	935 %! fn = @(x) A * x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	936 %! opts.issym = 0; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	937 %! d1 = eigs (fn, n, k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	938 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	939 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	940 %! fn = @(x) A \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	941 %! opts.issym = 0; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	942 %! d1 = eigs (fn, n, k, "sm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	943 %! assert (abs (d1), d0(1:k), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	944 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	945 %! fn = @(x) (A - 4.1 * eye (n)) \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	946 %! opts.issym = 0; opts.isreal = 1;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	947 %! d1 = eigs (fn, n, k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	948 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	949 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	950 %! [v1,d1] = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	951 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	952 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	953 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	954 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	955 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	956 %! [v1,d1] = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	957 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	958 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	959 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	960 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	961 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	962 %! [v1,d1] = eigs (A, k, "lr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	963 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	964 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	965 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	966 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	967 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	968 %! [v1,d1] = eigs (A, k, "sr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	969 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	970 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	971 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	972 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	973 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	974 %! [v1,d1] = eigs (A, k, "li");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	975 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	976 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	977 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	978 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	979 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	980 %! [v1,d1] = eigs (A, k, "si");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	981 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	982 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	983 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	984 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	985
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	986 ## Complex hermitian tests
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	987 %!shared n, k, A, d0
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	988 %! n = 20;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	989 %! k = 4;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	990 %! A = full (sparse ([3:n,1:n,1:(n-2)],[1:(n-2),1:n,3:n],[1iones(1,n-2),4ones(1,n),-1i*ones(1,n-2)]));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	991 %! d0 = eig (A);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	992 %! [~, idx] = sort (abs (d0));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	993 %! d0 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	994 %! rand ("state", 42); % initialize generator to make eigs behavior reproducible
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	995 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	996 %! d1 = eigs (A, k);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	997 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	998 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	999 %! d1 = eigs (A, k+1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1000 %! assert (abs (d1), abs (d0(end:-1:(end-k))),1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1001 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1002 %! d1 = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1003 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1004 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1005 %! d1 = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1006 %! assert (abs (d1), abs (d0(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1007 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1008 %! d1 = eigs (A, k, "lr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1009 %! [~, idx] = sort (real (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1010 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1011 %! assert (real (d1), real (d2(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1012 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1013 %! d1 = eigs (A, k, "sr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1014 %! [~, idx] = sort (real (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1015 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1016 %! assert (real (d1), real (d2(1:k)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1017 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1018 %! d1 = eigs (A, k, "li");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1019 %! [~, idx] = sort (imag (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1020 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1021 %! assert (sort (imag (d1)), sort (imag (d2(end:-1:(end-k+1)))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1022 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1023 %! d1 = eigs (A, k, "si");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1024 %! [~, idx] = sort (imag (abs (d0)));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1025 %! d2 = d0(idx);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1026 %! assert (sort (imag (d1)), sort (imag (d2(1:k))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1027 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1028 %! d1 = eigs (A, k, 4.1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1029 %! [~, idx0] = sort (abs (d0 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1030 %! [~, idx1] = sort (abs (d1 - 4.1));
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1031 %! assert (abs (d1(idx1)), abs (d0(idx0(1:k))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1032 %! assert (sort (imag (d1(idx1))), sort (imag (d0(idx0(1:k)))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1033 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1034 %! d1 = eigs (A, eye (n), k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1035 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1036 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1037 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1038 %! d1 = eigs (A, eye (n), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1039 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1040 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1041 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1042 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1043 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1044 %! d1 = eigs (A, eye (n)(q,q), k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1045 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1046 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1047 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1048 %! d1 = eigs (A, eye (n), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1049 %! assert (abs (abs (d1)), abs (eigs (A, k, 4.1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1050 %! assert (sort (imag (abs (d1))), sort (imag (eigs (A, k, 4.1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1051 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1052 %! opts.cholB = true;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1053 %! q = [2:n,1];
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1054 %! opts.permB = q;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1055 %! d1 = eigs (A, eye (n)(q,q), k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1056 %! assert (abs (abs (d1)), abs (eigs (A, k, 4.1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1057 %! assert (sort (imag (abs (d1))), sort (imag (eigs (A, k, 4.1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1058 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1059 %! assert (abs (eigs (A, k, 4.1)), abs (eigs (A, eye (n), k, 4.1)), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1060 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1061 %! assert (sort (imag (eigs (A, k, 4.1))), sort (imag (eigs (A, eye (n), k, 4.1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1062 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1063 %! fn = @(x) A * x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1064 %! opts.issym = 0; opts.isreal = 0;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1065 %! d1 = eigs (fn, n, k, "lm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1066 %! assert (abs (d1), abs (d0(end:-1:(end-k+1))), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1067 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1068 %! fn = @(x) A \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1069 %! opts.issym = 0; opts.isreal = 0;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1070 %! d1 = eigs (fn, n, k, "sm", opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1071 %! assert (abs (d1), d0(1:k), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1072 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1073 %! fn = @(x) (A - 4.1 * eye (n)) \ x;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1074 %! opts.issym = 0; opts.isreal = 0;
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1075 %! d1 = eigs (fn, n, k, 4.1, opts);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1076 %! assert (abs (d1), eigs (A, k, 4.1), 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1077 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1078 %! [v1,d1] = eigs (A, k, "lm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1079 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1080 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1081 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1082 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1083 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1084 %! [v1,d1] = eigs (A, k, "sm");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1085 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1086 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1087 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1088 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1089 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1090 %! [v1,d1] = eigs (A, k, "lr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1091 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1092 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1093 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1094 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1095 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1096 %! [v1,d1] = eigs (A, k, "sr");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1097 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1098 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1099 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1100 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1101 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1102 %! [v1,d1] = eigs (A, k, "li");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1103 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1104 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1105 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1106 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1107 %!testif HAVE_ARPACK
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1108 %! [v1,d1] = eigs (A, k, "si");
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1109 %! d1 = diag (d1);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1110 %! for i=1:k
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1111 %! assert (max (abs ((A - d1(i)eye (n))v1(:,i))), 0, 1e-11);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1112 %! endfor
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1113
17845 0f912af348e0 add a test to mark regression in eigs Carlo de Falco <cdf@users.sourceforge.net> parents: 17744 diff changeset	1114 %!test
0f912af348e0 add a test to mark regression in eigs Carlo de Falco <cdf@users.sourceforge.net> parents: 17744 diff changeset	1115 %! A = 2 * diag (ones (10, 1)) - diag (ones (9, 1), 1) - diag (ones (9, 1), -1);
0f912af348e0 add a test to mark regression in eigs Carlo de Falco <cdf@users.sourceforge.net> parents: 17744 diff changeset	1116 %! B = diag (ones (10, 1));
0f912af348e0 add a test to mark regression in eigs Carlo de Falco <cdf@users.sourceforge.net> parents: 17744 diff changeset	1117 %! reseig = eig (A, B);
0f912af348e0 add a test to mark regression in eigs Carlo de Falco <cdf@users.sourceforge.net> parents: 17744 diff changeset	1118 %! [~, idx] = sort (abs (reseig), "ascend");
0f912af348e0 add a test to mark regression in eigs Carlo de Falco <cdf@users.sourceforge.net> parents: 17744 diff changeset	1119 %! assert (eigs (A, B, 10, 0), reseig (idx))
0f912af348e0 add a test to mark regression in eigs Carlo de Falco <cdf@users.sourceforge.net> parents: 17744 diff changeset	1120
18972 1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1121 %!test
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1122 %! X = [70 47 42 39 50 73 79 23;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1123 %! 19 52 61 80 36 76 63 68;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1124 %! 14 34 66 65 29 4 72 9;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1125 %! 24 8 78 49 58 54 43 33;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1126 %! 62 69 32 31 40 46 22 28;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1127 %! 48 12 45 59 10 17 15 25;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1128 %! 64 67 77 56 13 55 41 74;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1129 %! 37 38 18 21 11 3 71 7;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1130 %! 5 35 16 1 51 27 26 44;
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1131 %! 30 57 60 75 2 53 20 6];
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1132 %! Z = X * X';
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1133 %! r = rank (Z);
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1134 %! assert (r, 8);
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1135 %! [V, D] = eigs (Z, r, "lm");
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1136 %! ZZ = V * D * V';
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1137 %! tmp = abs (Z - ZZ);
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1138 %! assert (max (tmp(:)) < 5e-11);
1782f5294fdc eigs: selection columns of V, not rows (bug #41795) John W. Eaton <jwe@octave.org> parents: 17846 diff changeset	1139
17220 ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1140 %!assert (eigs (diag (1:5), 5, "sa"), [1;2;3;4;5]);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1141 %!assert (eigs (diag (1:5), 5, "la"), [5;4;3;2;1]);
ea9992fd9c89 fix eigs to handle small matrices John W. Eaton <jwe@octave.org> parents: diff changeset	1142 %!assert (eigs (diag (1:5), 3, "be"), [1;4;5]);