# Created by Octave 3.2.4, Wed May 04 01:55:45 2011 UTC <root@ross>
# name: cache
# type: cell
# rows: 3
# columns: 11
# name: <cell-element>
# type: string
# elements: 1
# length: 4
bicg
# name: <cell-element>
# type: string
# elements: 1
# length: 357
 -- Function File: X bicg (A,B,TOL,MAXIT,M)
     Solve the system A*X = B using the biconjugate gradient method.
     For having a good convergence, A must be sparse.  TOL specifies
     the tolerance of the method by default tol is 10e-6, MAXIT
     specifies the maximal number of iterations and M is a
     preconditiner.

     See also: pcg, lu, chol



# name: <cell-element>
# type: string
# elements: 1
# length: 63
Solve the system A*X = B using the biconjugate gradient method.

# name: <cell-element>
# type: string
# elements: 1
# length: 8
cartprod
# name: <cell-element>
# type: string
# elements: 1
# length: 771
 -- Function File:  cartprod (VARARGIN )
     Computes the cartesian product of given column vectors ( row
     vectors ).  The vector elements are assumend to be numbers.

     Alternatively the vectors can be specified by as a matrix, by its
     columns.

     To calculate the cartesian product of vectors, P = A x B x C x D
     ... . Requires A, B, C, D be column vectors.  The algorithm is
     iteratively calcualte the products,  ( ( (A x B ) x C ) x D ) x
     etc.

            cartprod(1:2,3:4,0:1)
            ans =   1   3   0
                    2   3   0
                    1   4   0
                    2   4   0
                    1   3   1
                    2   3   1
                    1   4   1
                    2   4   1

   See also: kron


# name: <cell-element>
# type: string
# elements: 1
# length: 71
Computes the cartesian product of given column vectors ( row vectors ).

# name: <cell-element>
# type: string
# elements: 1
# length: 3
cod
# name: <cell-element>
# type: string
# elements: 1
# length: 885
 -- Function File: [Q, R, Z] = cod (A)
 -- Function File: [Q, R, Z, P] = cod (A)
 -- Function File: [...] = cod (A, '0')
     Computes the complete orthogonal decomposition (COD) of the matrix
     A:
            A = Q*R*Z'
     Let A be an M-by-N matrix, and let `K = min(M, N)'.  Then Q is
     M-by-M orthogonal, Z is N-by-N orthogonal, and R is M-by-N such
     that `R(:,1:K)' is upper trapezoidal and `R(:,K+1:N)' is zero.
     The additional P output argument specifies that pivoting should be
     used in the first step (QR decomposition). In this case,
            A*P = Q*R*Z'
     If a second argument of '0' is given, an economy-sized
     factorization is returned so that R is K-by-K.

     NOTE: This is currently implemented by double QR factorization
     plus some tricky manipulations, and is not as efficient as using
     xRZTZF from LAPACK.

     See also: qr



# name: <cell-element>
# type: string
# elements: 1
# length: 80
Computes the complete orthogonal decomposition (COD) of the matrix A:
       A =

# name: <cell-element>
# type: string
# elements: 1
# length: 7
condeig
# name: <cell-element>
# type: string
# elements: 1
# length: 784
 -- Function File: C = condeig (A)
 -- Function File: [V, LAMBDA, C] = condeig (A)
     Compute condition numbers of the eigenvalues of a matrix. The
     condition numbers are the reciprocals of the cosines of the angles
     between the left and right eigenvectors.

Arguments
---------

        * A must be a square numeric matrix.

Return values
-------------

        * C is a vector of condition numbers of the eigenvalue of A.

        * V is the matrix of right eigenvectors of A. The result is the
          same as for `[v, lambda] = eig (a)'.

        * LAMBDA is the diagonal matrix of eigenvalues of A. The result
          is the same as for `[v, lambda] = eig (a)'.

Example
-------

          a = [1, 2; 3, 4];
          c = condeig (a)
          => [1.0150; 1.0150]


# name: <cell-element>
# type: string
# elements: 1
# length: 57
Compute condition numbers of the eigenvalues of a matrix.

# name: <cell-element>
# type: string
# elements: 1
# length: 4
funm
# name: <cell-element>
# type: string
# elements: 1
# length: 803
 funm:  Matrix equivalent of function 'name'

 Usage:    B = funm(A, name)
  where    A = square non-singular matrix, provisionally
               real-valued
           B = square result matrix
        name = string, name of function to apply to A.
        args = any arguments to pass to function 'name'
               The function must accept a vector and apply
               element-wise to that vector.

 Example:  To compute sqrtm(A), you could use funm(A, 'sqrt')

 Note that you should not use funm for 'sqrt', 'log' or 'exp'; instead
 use sqrtm, logm and expm which are more robust. Similarly,
 trigonometric and hyperbolic functions (cos, sin, tan, cot, sec, csc,
 cosh, sinh, tanh, coth, sech, csch) are better handled by thfm(A,
 name), which defines them in terms of the more robust expm.

# name: <cell-element>
# type: string
# elements: 1
# length: 45
 funm:  Matrix equivalent of function 'name'


# name: <cell-element>
# type: string
# elements: 1
# length: 6
pgmres
# name: <cell-element>
# type: string
# elements: 1
# length: 464
   Solves A x = b using the Preconditioned GMRES iterative method
   with restart a.k.a. PGMRES(m).

   rtol is the relative tolerance,
   maxit the maximum number of iterations,
   x0 the initial guess and 
   m is the restart parameter.

   A can be passed as a matrix or as a function handle or 
   inline function f such that f(x) = A*x.

   The preconditioner P can be passed as a matrix or as a function handle or 
   inline function g such that g(x) = P\x.

# name: <cell-element>
# type: string
# elements: 1
# length: 80
   Solves A x = b using the Preconditioned GMRES iterative method
   with restar

# name: <cell-element>
# type: string
# elements: 1
# length: 9
rotparams
# name: <cell-element>
# type: string
# elements: 1
# length: 466
 -- Function File: [VSTACKED, ASTACKED] =  rotparams ( rstacked )
     The function w = rotparams (r)            - Inverse to rotv().
     Using, W    = rotparams(R)  is such that  rotv(w)*r' == eye(3).

     If used as, [v,a]=rotparams(r) ,  idem, with v (1 x 3) s.t. w ==
     a*v.

     0 <= norm(w)==a <= pi

     :-O !!  Does not check if 'r' is a rotation matrix.

     Ignores matrices with zero rows or with NaNs. (returns 0 for them)

     See also: rotv



# name: <cell-element>
# type: string
# elements: 1
# length: 62
The function w = rotparams (r)            - Inverse to rotv().

# name: <cell-element>
# type: string
# elements: 1
# length: 4
rotv
# name: <cell-element>
# type: string
# elements: 1
# length: 489
 -- Function File: R =  rotv ( v, ang )
     The functionrotv calculates a Matrix of rotation about V w/ angle
     |v| r = rotv(v [,ang])

     Returns the rotation matrix w/ axis v, and angle, in radians,
     norm(v) or ang (if present).

     rotv(v) == w'*w + cos(a) * (eye(3)-w'*w) - sin(a) * crossmat(w)

     where a = norm (v) and w = v/a.

     v and ang may be vertically stacked : If 'v' is 2x3, then rotv( v
     ) == [rotv(v(1,:)); rotv(v(2,:))]


     See also: rotparams



# name: <cell-element>
# type: string
# elements: 1
# length: 80
The functionrotv calculates a Matrix of rotation about V w/ angle |v| r
= rotv(v

# name: <cell-element>
# type: string
# elements: 1
# length: 8
smwsolve
# name: <cell-element>
# type: string
# elements: 1
# length: 614
 -- Function File: X = smwsolve (A, U, V, B)
 -- Function File:  smwsolve (SOLVER, U, V, B)
     Solves the square system `(A + U*V')*X == B', where U and V are
     matrices with several columns, using the Sherman-Morrison-Woodbury
     formula, so that a system with A as left-hand side is actually
     solved. This is especially advantageous if A is diagonal, sparse,
     triangular or positive definite.  A can be sparse or full, the
     other matrices are expected to be full.  Instead of a matrix A, a
     user may alternatively provide a function SOLVER that performs the
     left division operation.


# name: <cell-element>
# type: string
# elements: 1
# length: 80
Solves the square system `(A + U*V')*X == B', where U and V are
matrices with se

# name: <cell-element>
# type: string
# elements: 1
# length: 9
test_gsvd
# name: <cell-element>
# type: string
# elements: 1
# length: 24
 a few tests for gsvd.m

# name: <cell-element>
# type: string
# elements: 1
# length: 22
 a few tests for gsvd.

# name: <cell-element>
# type: string
# elements: 1
# length: 4
thfm
# name: <cell-element>
# type: string
# elements: 1
# length: 769
USAGE  y = thfm ( x, MODE )

       trigonometric/hyperbolic functions of square matrix x

MODE	cos   sin   tan   sec   csc   cot
	cosh  sinh  tanh  sech  csch  coth
       acos  asin  atan  asec  acsc  acot
       acosh asinh atanh asech acsch acoth
       sqrt  log   exp

NOTE		--- IMPORTANT ---
	This algorithm does  NOT USE an eigensystem
	similarity transformation. It maps the MODE
	functions to functions of expm, logm and sqrtm, 
       which are known to be robust with respect to
	non-diagonalizable ('defective') x

EXA	thfm( x ,'cos' )  calculates  matrix cosinus
	EVEN IF input matrix x IS NOT DIAGONALIZABLE

ASSOC	expm, sqrtm, logm, funm
 Copyright	(C) 2001 Rolf Fabian <fabian@tu-cottbus.de>
 010213
	published under current GNU GENERAL PUBLIC LICENSE

# name: <cell-element>
# type: string
# elements: 1
# length: 28
USAGE  y = thfm ( x, MODE )


