LAPACK doc and plans for J 
Author Message
 LAPACK doc and plans for J

I have completed the documentation and the implementation of an improved
J-LAPACK interface. In about 2-1/2 weeks I expect to put a new version
of J with keyed files, an interface to vfftpack, and several miscellaneous
functions (for combinations and a new verb for fractional representations)
at watserv1.  This version of J will compile on the PC, the MAC, and of course
on any UNIX box.

In the meantime if someone is eager for the enhanced version of J they
can email me and, if I can email them back, I will provide them with
the information they need to compile J with lapack and fftpack.
However, anyone programming on the PC or MAC is better off waiting
for the watserv version.

FYI, the lapack alternative to matrix divide is 3-8 times faster than
J's %., and it uses much less memory, is more accurate, and has additional
functionality!

After this is completed I don't expect to be spending as much time on
J as I expect to prepare for several actuarial examinations offered in
november.

I mentioned several weeks ago that I was working on an online tutorial-
documentation package for J via Emacs. I received a mail request for
something which could run on the PC from Peter Devoil. I will take
a look at what would be involved in porting what has been done in
Emacs to the PC over the weekend. But I Mr. Devoil, please note that
I can not email you from my account and I don't yet have anything on
J GUI.

  If I have access to a UNIX box after the november exams I would like
  to optimize amend, and roll, and start on a GNUPlot interface.
  Requests by those actually using the enhanced version of J will get
  consideration also.

 -emmett

#!/bin/sh
# This is a shell archive (produced by shar 3.50)
# To extract the files from this archive, save it to a file, remove
# everything above the "!/bin/sh" line above, and type "sh file_name".
#

# Source directory /usr/cp2/emclean/src
#
# existing files will NOT be overwritten unless -c is specified
#
# This shar contains:
# length  mode       name
# ------ ---------- ------------------------------------------
#   1467 -r--r--r-- doc.leq
#   1417 -r--r--r-- doc.svd
#    582 -r--r--r-- doc.schur
#   1041 -r--r--r-- doc.rcond
#    629 -r--r--r-- doc.qr
#    801 -r--r--r-- doc.norm
#   1340 -r--r--r-- doc.lu
#    497 -r--r--r-- doc.hess
#   1454 -r--r--r-- doc.evev
#   2526 -r--r--r-- doc.gevev
#   1342 -r--r--r-- doc.chol
#    522 -r--r--r-- doc.bal
#
# ============= doc.leq ==============
if test -f 'doc.leq' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.leq (File already exists)'
else
echo 'x - extracting doc.leq (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.leq' &&
X
X (30!:11 y) (MINV) (monad) (2)
X
X 30!:11 y is the multiplicative inverse to y if y is a nonsingular
X matrix or the pseudo inverse of y if y is singular or is rectangular
X and has more rows than columns.
X
X If
X
X ('inv';'info') =. 30!:11 y
X
X Then
X

X
X If the storage type of y is boolean, integer, or float, and y
X is n-by-n, then dgesev computes the multiplicative inverse of y
X using lu factorization with column pivoting and row exchanges or
X if y is rectangular, then dgelss computes the pseudo inverse using
X the SVD. If y is complex then either dgelss or zgelss is used.
X
X info  = 0 -> successful exit from dgesev, zgesev, dgelss or zgelss.
X
X info  > 0 -> if y is n-by-n and info = k, then (<:k) { (<:k) { u is
X              exactly zero indicating that y is singular.
X
X info  < 0 -> successful exit from dgesev, zgesev, dgelss or zgelss.
X

X
X 30!:11 (LEQSV) (2 2)
X
X (x 30!:11 y) solves the set of linear equations defined by y and x.
X
X If
X
X ('ans';'info') =. x 30!:11 y
X
X then
X
X y +/ .* ans is the projection of the vector x on the column space of y.
X
X For example :
X
X   u =. 2 3 $ 1 2 5 4 1 9
X   u +/ .* > {. 1 2 3 (30!:11) u
1 2
X
X   v =. 3 3 $ 1 2 4 3 5 6 9 7 2
X   v +/ .* > {. 1 2 3 (30!:11) v
1 2 3
X
X   x =.  8.4 9.5 11.8 10.4 13.3 14.8 13.2 14.7 16.4 16.5 18.9 18.5
X   y =. (1: ,. ]) 20 22 24 26 28 30 32 34 36 38 40 42
X   x %. y
_0.289277 0.456643

_0.289277 0.456643
X  
SHAR_EOF
chmod 0444 doc.leq ||
echo 'restore of doc.leq failed'
Wc_c="`wc -c < 'doc.leq'`"
test 1467 -eq "$Wc_c" ||
        echo 'doc.leq: original size 1467, current size' "$Wc_c"
fi
# ============= doc.svd ==============
if test -f 'doc.svd' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.svd (File already exists)'
else
echo 'x - extracting doc.svd (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.svd' &&
X
X
X 30!:0 (SVD) (monad) (2)
X
X (30!:0 y) computes the singular value decomposition of y
X
X If :
X
X ('u';'s';'vt';'info') =. 30!:0 y
X
X then (u +/ .* s +/ .* vt) is y.
X
X u consists of the left singular vectors of y,
X
X s is a matrix whose diagonals are the singular values of y,
X
X and the columns of v are the right singular vectors of y.
X
X If the storage type of y is boolean, integer, or float
X dgesvd computes u, s, and vt. If the storage type of y is
X complex zgesvd is used.
X
X info =  0 -> successful exit from dgesvd or zgesvd
X
X info >  0 -> successful exit from dgesvd or zgesvd except that k
X              superdiagonals of an intermediate bidiagonal form did
X              not converge to zero.
X
X info < 0  -> non successful exit from dgesvd or zgesvd.
X
X
X 30!:0 (SVD) (dyad) (0 2)
X
X
X (x 30!:0 y) computes the singular value decomposition of y.
X
X OPTIONS
X
X 'A' 30!:0 y
X 'S' 30!:0 y
X 'N' 30!:0 y
X
X =====
X ('A' 30!:0 y) is the same as 30!:0 y.
X
X =====
X ('S' 30!:0 y)
X
X If :
X
X ('u';'s';'vt';'info') =. 'S' 30!:0 y
X
X then (u +/ .* s +/ .* vt) is y.
X
X u consists of the min(m,n) m-dimensional left singular vectors of y
X s is a table whose diagonals are the singular values of y
X the columns of v are the right singular vectors of y
X
X =====
X ('S' 30!:0 y)
X
X If :
X
X ('s';'info') =. 'N' 30!:0 y
X
X then s is the set of min(m,n) singular values of y and the interpretation
X of info is the same as for the monad 30!:0.
X
SHAR_EOF
chmod 0444 doc.svd ||
echo 'restore of doc.svd failed'
Wc_c="`wc -c < 'doc.svd'`"
test 1417 -eq "$Wc_c" ||
        echo 'doc.svd: original size 1417, current size' "$Wc_c"
fi
# ============= doc.schur ==============
if test -f 'doc.schur' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.schur (File already exists)'
else
echo 'x - extracting doc.schur (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.schur' &&
X
X 30!:9 (SCHUR) (monad) (2)
X
X (30!:9 y) computes Schur form and the Schur vectors of n-by-n y.
X
X If :
X
X ('t';'z';'info') =. 30!:9 y
X
X then :
X
X z +/ .* t +/ .* (|: z) is y.
X
X If the storage type of y is boolean, integer, or float
X dgees computes z and t. If the storage type of y is
X complex zgees is used.
X
X info =  0 -> successful exit from dgees or zgees
X
X info >  0 -> the QR algorithm (used in intermediate computations)
X              failed to compute all the eigenvalues so z is of partically
X              converged form
X
X info <  0 -> unsuccessful exit from dgees or zgees
SHAR_EOF
chmod 0444 doc.schur ||
echo 'restore of doc.schur failed'
Wc_c="`wc -c < 'doc.schur'`"
test 582 -eq "$Wc_c" ||
        echo 'doc.schur: original size 582, current size' "$Wc_c"
fi
# ============= doc.rcond ==============
if test -f 'doc.rcond' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.rcond (File already exists)'
else
echo 'x - extracting doc.rcond (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.rcond' &&
X
X  30!:6 (RCOND NORM) (monad) (2)
X
X  (30!:6 y)  returns an estimate for the reciprocal of the
X  condition number and the one norm of y.
X
X  If :
X
X  ('rcond';'norm';'rinfo';'luinfo') 30!:6 y
X
X  then
X
X  rcond is an estimate for the reciprocal of the condition number
X
X  and
X
X  norm is the one norm of y.
X
X  The one norm of y is returned since it is used in intermediate
X  computations.
X
X  If the storage type of y is boolean, integer, or float,
X  dlange computes the '1' norm of  y, then dgetrf and dgecon
X  are used to compute the estimate for the reciprocal of the
X  condition number. If the storage type of y is complex
X  zlange, zgetrf, and zgecon are used.
X
X
X  30!:1 (NORM) (dyad) (0 2)
X
X  OPTIONS
X
X  'M' 30!:1 y
X  '1' 30!:1 y
X  'I' 30!:1 y
X  'F' 30!:1 y
X
X  =====
X  ('M' 30!:1 y) returns the atom of larges absolute value of y
X
X  =====
X  ('1' 30!:1 y) returns the maximum column sum of y
X
X  =====
X  ('I' 30!:1 y) returns the maximum row sum of y
X
X  =====
X  ('F' 30!:1 y) returns the Forbenius norm (square root of sum of
X   squares) of y
SHAR_EOF
chmod 0444 doc.rcond ||
echo 'restore of doc.rcond failed'
Wc_c="`wc -c < 'doc.rcond'`"
test 1041 -eq "$Wc_c" ||
        echo 'doc.rcond: original size 1041, current size' "$Wc_c"
fi
# ============= doc.qr ==============
if test -f 'doc.qr' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.qr (File already exists)'
else
echo 'x - extracting doc.qr (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.qr' &&
X
X 30!:7 (QR) (monad) (2)
X
X (30!:7 y) computes the QR factorization of y. The number of rows
X must be greater than or equal to the number of columns for this
X to be defined.
X
X If :
X
X ('q';'r';'infoq';'infor') =. 30!:7 y
X
X then
X
X q +/ .* r is y.
X
X If the storage type of y is boolean or integer or float dorqrf
X computes q and dgeqrf computes r. If the storage type of y is
X complex zungrqr and zgeqrf are used.
X
X infoq = 0 -> successful exit from dorqrf or zungqr.
X       < 0 -> unsuccessful exit from dorqrf or zungqr.
X
X infor = 0 -> successful exit from dgeqrf or zgeqrf.
X       < 0 -> unsuccessful exit from dgeqrf or zgeqrf.
SHAR_EOF
chmod 0444 doc.qr ||
echo 'restore of doc.qr failed'
Wc_c="`wc -c < 'doc.qr'`"
test 629 -eq "$Wc_c" ||
        echo 'doc.qr: original size 629, current size' "$Wc_c"
fi
# ============= doc.norm ==============
if test -f 'doc.norm' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.norm (File already exists)'
else
echo 'x - extracting doc.norm (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.norm' &&
X
X  30!:1 (NORM) (monad) (2)
X
X  (30!:1 y)  returns the value of the one norm, the Frobenius norm,
X  the infinity norm, and the element of largest absolute value of y.
X
X  If the storage type of y is boolean, integer, or float dlange
X  computes the norm. If is complex zlange is called.
X
X  30!:1 (NORM) (dyad) (0 2)
X
X  OPTIONS
X
X  'M' 30!:1 y
X  '1' 30!:1 y
X  'I' 30!:1 y
X  'F' 30!:1 y
X
X   The same functions which are used in the implementation of the
X   monad 30!:1 are used in the implementation of the dyad 30!:1
X  
X  =====
X  ('M' 30!:1 y) returns the atom of largest absolute value of y
X
X  =====
X  ('1' 30!:1 y) returns the maximum column sum of y
X
X  =====
X  ('I' 30!:1 y) returns the maximum row sum of y
X
X  =====
X  ('F' 30!:1 y) returns the Forbenius norm (square root of sum of
X   squares) of y
SHAR_EOF
chmod 0444 doc.norm ||
echo 'restore of doc.norm failed'
Wc_c="`wc -c < 'doc.norm'`"
test 801 -eq "$Wc_c" ||
        echo 'doc.norm: original size 801, current size' "$Wc_c"
fi
# ============= doc.lu ==============
if test -f 'doc.lu' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.lu (File already exists)'
else
echo 'x - extracting doc.lu (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.lu' &&
X
X 30!:2 (PLU) (monad) (2)
X
X (30!:2 y) computes the PLU factorization of y using partial pivoting
X and row exchanges.
X
X If :
X
X ('p';'l';'u';'info') =. 30!:2 y
X
X then (p +/ .* l +/ .* u) is y.
X
X If the storage type of y is boolean, integer, or float
X dgetrf computes l and u. If the storage type of y is
X complex zgetrf is used.
X
X info  = 0 -> successful exit from dgetrf or zgetrf.
X
X info  > 0 -> if info = k, (<:k) { (<:k) { u is exactly zero. This indicates
X              a successful exit from dlange or zlange but that u, the upper
X              triangular factor, is singular.
X
X info < 0 ->  non successful exit from dgetrf or zgetrf.
X              
X 30!:2 (LU) (dyad) (0 2)
X
X (x 30!:2 y) computes the PLU factorization of y using partial pivoting
X and row exchanges.
X
X OPTIONS
X
X 0 30!:2 y
X 1 30!:2 y
X
X =====
X (0 (30!:2) y) computes the in-place PLU factorization of y using partial
X pivoting and row exchanges.
X
X If :
X
X ('lu';'piv';'info') =. 0 30!:2 y
X
X then lu is the 'in place' LU factorization is with the lower and
X upper triangular portions of lu corresponding to the factors  L
X and U in the factorization. The diagonal elements of L (all ones)
X are not stored. ipiv is a row permutation vector of y such that
X row i of y was swapped with row ipiv.
X
X =====
X (1 (30!:2) y)
X
X (1 (30!:2) y) is the same as the monad 30!:2 y.
X
SHAR_EOF
chmod 0444 doc.lu ||
echo 'restore of doc.lu failed'
Wc_c="`wc -c < 'doc.lu'`"
test 1340 -eq "$Wc_c" ||
        echo 'doc.lu: original size 1340, current size' "$Wc_c"
fi
# ============= doc.hess ==============
if test -f 'doc.hess' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.hess (File already exists)'
else
echo 'x - extracting doc.hess (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.hess' &&
X
X 30!:5 (HESS) (monad) (2)
X
X If :
X
X ('h';'p';'infoh';'infop') =. 30!:5 y
X
X then :
X
X p +/ .* h +/ .* (|:p) is y.
X
X If the storage type of y is boolean, integer, or float dgehrd
X computes h and dorghr computes p. If the storage type of y is
X complex zgehrd and zunghr are used.
X
X infoh =  0 -> successful exit from dgehrd or zgehrd
X infoh >  0 -> unsuccessful exit from dgehrd or zgehrd
X
X infop =  0 -> successful exit from dorghr or zunghr
X infop >  0 -> unsuccessful exit from dorghr or zunghr
X
X
SHAR_EOF
chmod 0444 doc.hess ||
echo 'restore of doc.hess failed'
Wc_c="`wc -c < 'doc.hess'`"
test 497 -eq "$Wc_c" ||
        echo 'doc.hess: original size 497, current size' "$Wc_c"
fi
# ============= doc.evev ==============
if test -f 'doc.evev' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.evev (File already exists)'
else
echo 'x - extracting doc.evev (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.evev' &&
X
X 30!:3 (EVEV) (monad) (2)
X
X (30!:3 y) computes the eigenvalues n-by-n y.
X
X If
X
X ('e';'info') =. 30!:3 y
X
X then the atoms of e are the eigenvalues of y.
X
X If the storage type of y is boolean, integer, or float
X dgetrf computes e . If y is complex complex zgetrf is used.
X
X info =  0 -> successful exit from dgeev or zgeev
X
X info >  0 -> info specifies how many superdiagonals of an
X              intermediate bidiagonal form did not converge
X              to zero.
X
X 30!:3 (EVEV) (dyad) (1 2)
X
X (x 30!:3 y) computes the eigenvalues and optionally the right
X eigenvectors and the left eigenvectors of n-by-n y.
X
X OPTIONS
X
X 'NN' 30!:3 y    NB. computes eigenvalues only
X 'NV' 30!:3 y    NB. computes eigenvalues and right eigenvectors
X 'VN' 30!:3 y    NB. computes eigenvalues and left eigenvectors
X 'VV' 30!:3 y    NB. computes eigenvalues and both right and left
X                      eigenvectors
X
X In 'NV','VN','VV' options the eigenvalues are returned in a diagonal
X n-by-n table.
X
X In the general case, 'VV', the following holds :
X
X If
X
X ('vl';'e';'vr';'info') =. 'VV' 30!:3 y
X
X then
X
X vl are the left eigenvectors of y
X e  are the eigenvalues of y
X vr are the right eigenvectors of y
X
X and the interpretation of info is the same as for info in the monad 30!:3.
X
X Note that each of the following yield the eigenvalues of y :
X
X    {.   (vl +/ .* e) % vl
X    {."1 (vr +/ .* e) % vr
X    (<0 1)&|: e
X
X 30!:3 y is the same as ('NN') 30!:3 y.  
SHAR_EOF
chmod 0444 doc.evev ||
echo 'restore of doc.evev failed'
Wc_c="`wc -c < 'doc.evev'`"
test 1454 -eq "$Wc_c" ||
        echo 'doc.evev: original size 1454, current size' "$Wc_c"
fi
# ============= doc.gevev ==============
if test -f 'doc.gevev' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.gevev (File already exists)'
else
echo 'x - extracting doc.gevev (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.gevev' &&
X
X 30!:10 (GEVEV) (monad) (2)
X
X (30!:10 (y0;y1)) computes the eigenvalues and the eigenvectors of a
X general eigenproblem of the form A*x=(lambda)*B*x where y0 and y1
X are representations of A and B. A is assumed to be symmetric if it
X is real or Hermitian if it is complex. B is assumed to be positive
X definite and symmetric if it is real or Hermitian if it is complex.
X
X If
X
X ('e';'v';'info') =. 30!:10 (y0;y1)
X
X then the atoms of e are the eigenvalues and v is a set of eigenvectors
X
X If the storage type of both y0 and y1 are not complex then
X dsygv is called. If either y0 or y1 is complex zhegv is called.
X
X info =  0 -> successful exit from dsygv or zhegv
X
X info <  0 -> unsuccessful exit from dsygv or zhegv
X
X info >  (i+>:#y) -> for 1 <= i <= n, then the leading
X                     minor of order i of B is not positive definite.
X                     The factorization of B could not be completed and
X                     no eigenvalues or eigenvectors were computed.
X
X 30!:10 y is the same as ('1VU') 30!:10 y.  
X
X 30!:10 (EVEV) (dyad) (1 2)
X
X (x 30!:10 (y0;y1)) computes the eigenvalues and the eigenvectors of a
X general eigenproblem of one of the following forms :
X
X A*x=(lambda)*B*x
X A*Bx=(lambda)*x
X B*A*x=(lambda)*x
X
X where y0 and y1 are representations of A and B. A is assumed to be
X symmetric if it is real or Hermitian if it is complex. B is assumed to
X be positive definite and symmetric if it is real or Hermitian if it
X is complex.
X
X OPTIONS
X
X (x 30!:10 y0;y1) is one of the following :
X
X '1NL' 30!:10 (y0;y1)
X '1NH' 30!:10 (y0;y1)
X '1VL' 30!:10 (y0;y1)
X '1VH' 30!:10 (y0;y1)
X '2NL' 30!:10 (y0;y1)
X '2NH' 30!:10 (y0;y1)
X '2VL' 30!:10 (y0;y1)
X '2VH' 30!:10 (y0;y1)
X '3NL' 30!:10 (y0;y1)
X '3NH' 30!:10 (y0;y1)
X '3VL' 30!:10 (y0;y1)
X '3VH' 30!:10 (y0;y1)
X    
X  Where :
X
X    (0{x) Specifies the problem type to be solved:
X          = 1:  A*x = (lambda)*B*x
X          = 2:  A*B*x = (lambda)*x
X          = 3:  B*A*x = (lambda)*x
X
X    (1{x) Specifies whether or not to compute the eigenvectors:
X          = 'N':  Compute eigenvalues only.
X          = 'V':  Compute eigenvalues and eigenvectors.
X
X    (2{x) Specifies whether the upper or lower triangular part of the
X          symmetric matrices A and B are stored.
X          = 'U':  Upper triangular
X          = 'L':  Lower triangular
X
X  If :
X
X  ('e';'v';'info') =. x 30!:10 y
X
X  then
X
X  the atoms of e are the eigenvalues and v consists of the eigenvectors
X
X  the interpretation for info is the same as for info in the monad 30!:10.
X
SHAR_EOF
chmod 0444 doc.gevev ||
echo 'restore of doc.gevev failed'
Wc_c="`wc -c < 'doc.gevev'`"
test 2526 -eq "$Wc_c" ||
        echo 'doc.gevev: original size 2526, current size' "$Wc_c"
fi
# ============= doc.chol ==============
if test -f 'doc.chol' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.chol (File already exists)'
else
echo 'x - extracting doc.chol (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.chol' &&
X
X 30!:8 (CHOL) (monad) (2)
X
X (30!:8 y) computes the Cholesky factorization of n-by-n y. For this to
X be defined y must represent a real positive definite matrix or a complex
X hermitian positive definite matrix.
X
X If :
X
X ('u';'info') =. 30!:8 y
X
X then :
X
X  (|: u) +/ .* u is y
X
X
X The specifics of the computation are as follows:
X
X    If the storage type of y is boolean or integer, y is converted
X    into a floating storage type, and dpotrf computes u.
X
X    If y has a floating storage type dpotrf computes u.
X
X    If y has a floating storage type zpotrf computes u.
X
X Thus :
X
X info = 0 ->  successful exit from dpotrf or zpotrf
X
X info > 0 ->  the leading minor of order k is not positive definite,
X               and the factorization could not be completed.
X
X 30!:8 (CHOL) (dyad) (2)
X
X (x 30!:8 y) computes the Cholesky factorization of n-by-n y. For this to
X be defined y must represent a real positive definite matrix or a complex
X hermitian positive definite matrix.
X
X The functions which implement the dyad of 30!:8 are the same as the
X functions which implement the monad 30!:8.
X
X OPTIONS
X
X 'U' 30!:8 y
X 'L' 30!:8 y
X
X =====
X ('L' 30!:8 y)
X
X If :
X
X ('l';'info') =. 30!:8 y
X
X then
X
X  l +/ .* (|:l) is y
X
X the interpretation for info is that same as for the monad 30!:8.
X
X =====
X ('U' 30!:8 y)
X
X  'U' 30!:8 y is the same as 30!:8 y.
SHAR_EOF
chmod 0444 doc.chol ||
echo 'restore of doc.chol failed'
Wc_c="`wc -c < 'doc.chol'`"
test 1342 -eq "$Wc_c" ||
        echo 'doc.chol: original size 1342, current size' "$Wc_c"
fi
# ============= doc.bal ==============
if test -f 'doc.bal' -a X"$1" != X"-c"; then
        echo 'x - skipping doc.bal (File already exists)'
else
echo 'x - extracting doc.bal (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'doc.bal' &&
X
X (30!:4 y) (BALANCE) (monad) (2)
X
X Balancing may reduce the 1-norm of the matrix, and improve
X the accuracy of the computed eigenvalues and/or eigenvectors.
X
X
X If :
X
X ('ybal';'t';'info') =. 30!:4 y
X
X then
X

X
X If the storage type of y is boolean, integer, or float
X dgebal computes ybal and t. If the storage type of y is
X complex zgebal is used.
X
X info  = 0 -> successful exit from dgebal or zgebal.
X
X info  < 0 ->  non successful exit from dgebal or zgebal.
X  
SHAR_EOF
chmod 0444 doc.bal ||
echo 'restore of doc.bal failed'
Wc_c="`wc -c < 'doc.bal'`"
test 522 -eq "$Wc_c" ||
        echo 'doc.bal: original size 522, current size' "$Wc_c"
fi
exit 0



Sun, 28 Jan 1996 07:26:14 GMT  
 
 [ 1 post ] 

 Relevant Pages 

1. New Release of LAPACK and ScaLAPACK planned

2. JS-EAI with *JS*-callback

3. js.exception 3279.js

4. Vds doc V5.3 ( To sell doc v5.3 )

5. Logo1.doc and Math1.doc in cyberspace

6. grafting DOM doc [as a fragment] into another DOM doc [node]

7. PROPOSAL: [].__doc__, "".__doc__, ...

8. doc string substition and overloading __doc__

9. Patches for tcl8.0/doc/* and tk8.0/doc/*

10. tcl8.0b1/doc and tk8.0b1/doc patches

11. [Doc-SIG] [development doc updates]

12. NB. gray.js: a J verb that generates a grayscale postscript image from a 2d array

 

 
Powered by phpBB® Forum Software