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

annotate scripts/sparse/eigs.m @ 20305:c164cfc24bdd

QtHandles: add annotations dialog * libgui/graphics/annotation-dialog.h: new file * libgui/graphics/annotation-dialog.cc: new file * libgui/graphics/annotation-dialog.ui: new file * libgui/graphics/Canvas.cc (canvasMousePressEvent): call annotation_dialog when in TextMode. * libgui/graphics/module.mk: add annotation-dialog to build

author	John Donoghue <john.donoghue@ieee.org>
date	Sun, 19 Apr 2015 09:54:54 -0400
parents	9fc020886ae9
children	df437a52bcaf

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