You can subscribe to this list here.
2001 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}
(20) 
_{Dec}
(17) 

2002 
_{Jan}
(39) 
_{Feb}
(21) 
_{Mar}
(33) 
_{Apr}
(135) 
_{May}
(53) 
_{Jun}
(88) 
_{Jul}
(47) 
_{Aug}
(59) 
_{Sep}
(207) 
_{Oct}
(40) 
_{Nov}
(7) 
_{Dec}
(26) 
2003 
_{Jan}
(49) 
_{Feb}
(39) 
_{Mar}
(117) 
_{Apr}
(50) 
_{May}
(62) 
_{Jun}
(6) 
_{Jul}
(19) 
_{Aug}
(24) 
_{Sep}
(11) 
_{Oct}
(11) 
_{Nov}
(49) 
_{Dec}
(9) 
2004 
_{Jan}
(29) 
_{Feb}
(123) 
_{Mar}
(32) 
_{Apr}
(53) 
_{May}
(52) 
_{Jun}
(19) 
_{Jul}
(33) 
_{Aug}
(10) 
_{Sep}
(76) 
_{Oct}
(86) 
_{Nov}
(171) 
_{Dec}
(163) 
2005 
_{Jan}
(147) 
_{Feb}
(121) 
_{Mar}
(120) 
_{Apr}
(126) 
_{May}
(120) 
_{Jun}
(213) 
_{Jul}
(76) 
_{Aug}
(79) 
_{Sep}
(140) 
_{Oct}
(83) 
_{Nov}
(156) 
_{Dec}
(202) 
2006 
_{Jan}
(181) 
_{Feb}
(171) 
_{Mar}
(157) 
_{Apr}
(98) 
_{May}
(96) 
_{Jun}
(97) 
_{Jul}
(193) 
_{Aug}
(76) 
_{Sep}
(130) 
_{Oct}
(63) 
_{Nov}
(196) 
_{Dec}
(253) 
2007 
_{Jan}
(256) 
_{Feb}
(293) 
_{Mar}
(276) 
_{Apr}
(258) 
_{May}
(181) 
_{Jun}
(91) 
_{Jul}
(108) 
_{Aug}
(69) 
_{Sep}
(107) 
_{Oct}
(179) 
_{Nov}
(137) 
_{Dec}
(121) 
2008 
_{Jan}
(124) 
_{Feb}
(129) 
_{Mar}
(192) 
_{Apr}
(201) 
_{May}
(90) 
_{Jun}
(86) 
_{Jul}
(115) 
_{Aug}
(142) 
_{Sep}
(49) 
_{Oct}
(91) 
_{Nov}
(95) 
_{Dec}
(218) 
2009 
_{Jan}
(230) 
_{Feb}
(149) 
_{Mar}
(118) 
_{Apr}
(72) 
_{May}
(77) 
_{Jun}
(68) 
_{Jul}
(102) 
_{Aug}
(72) 
_{Sep}
(89) 
_{Oct}
(76) 
_{Nov}
(125) 
_{Dec}
(86) 
2010 
_{Jan}
(75) 
_{Feb}
(90) 
_{Mar}
(89) 
_{Apr}
(121) 
_{May}
(111) 
_{Jun}
(66) 
_{Jul}
(75) 
_{Aug}
(66) 
_{Sep}
(66) 
_{Oct}
(166) 
_{Nov}
(121) 
_{Dec}
(73) 
2011 
_{Jan}
(74) 
_{Feb}

_{Mar}

_{Apr}
(14) 
_{May}
(22) 
_{Jun}
(31) 
_{Jul}
(53) 
_{Aug}
(37) 
_{Sep}
(23) 
_{Oct}
(25) 
_{Nov}
(31) 
_{Dec}
(28) 
2012 
_{Jan}
(18) 
_{Feb}
(11) 
_{Mar}
(32) 
_{Apr}
(17) 
_{May}
(48) 
_{Jun}
(37) 
_{Jul}
(23) 
_{Aug}
(54) 
_{Sep}
(15) 
_{Oct}
(11) 
_{Nov}
(19) 
_{Dec}
(22) 
2013 
_{Jan}
(11) 
_{Feb}
(32) 
_{Mar}
(24) 
_{Apr}
(37) 
_{May}
(31) 
_{Jun}
(14) 
_{Jul}
(26) 
_{Aug}
(33) 
_{Sep}
(40) 
_{Oct}
(21) 
_{Nov}
(36) 
_{Dec}
(84) 
2014 
_{Jan}
(23) 
_{Feb}
(20) 
_{Mar}
(27) 
_{Apr}
(24) 
_{May}
(31) 
_{Jun}
(27) 
_{Jul}
(34) 
_{Aug}
(26) 
_{Sep}
(21) 
_{Oct}
(45) 
_{Nov}
(23) 
_{Dec}
(73) 
2015 
_{Jan}
(33) 
_{Feb}
(8) 
_{Mar}
(24) 
_{Apr}
(45) 
_{May}
(27) 
_{Jun}
(19) 
_{Jul}
(21) 
_{Aug}
(51) 
_{Sep}
(43) 
_{Oct}
(29) 
_{Nov}
(61) 
_{Dec}
(86) 
2016 
_{Jan}
(99) 
_{Feb}
(52) 
_{Mar}
(80) 
_{Apr}
(61) 
_{May}
(24) 
_{Jun}
(23) 
_{Jul}
(36) 
_{Aug}
(30) 
_{Sep}
(41) 
_{Oct}
(43) 
_{Nov}
(27) 
_{Dec}
(46) 
2017 
_{Jan}
(57) 
_{Feb}
(34) 
_{Mar}
(40) 
_{Apr}
(31) 
_{May}
(78) 
_{Jun}
(49) 
_{Jul}
(72) 
_{Aug}
(33) 
_{Sep}
(26) 
_{Oct}
(82) 
_{Nov}
(69) 
_{Dec}
(16) 
S  M  T  W  T  F  S 



1
(1) 
2
(3) 
3
(2) 
4
(6) 
5
(2) 
6
(8) 
7
(4) 
8
(7) 
9
(8) 
10
(1) 
11
(7) 
12
(2) 
13
(23) 
14
(1) 
15
(3) 
16
(1) 
17

18
(2) 
19
(1) 
20
(1) 
21
(2) 
22
(3) 
23
(5) 
24
(1) 
25
(1) 
26
(2) 
27
(17) 
28
(7) 





From: Robert Dodier <robert_dodier@us...>  20050201 06:34:08

Update of /cvsroot/maxima/maxima/doc/info In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv1566 Modified Files: Matrices.texi Log Message: Revised text of several items, revised and expanded examples, changed names to lowercase and enclose in @code or @var as appropriate. Still needs work. Index: Matrices.texi =================================================================== RCS file: /cvsroot/maxima/maxima/doc/info/Matrices.texi,v retrieving revision 1.8 retrieving revision 1.9 diff u d r1.8 r1.9  Matrices.texi 31 Jan 2005 04:12:23 0000 1.8 +++ Matrices.texi 1 Feb 2005 06:33:59 0000 1.9 @@ 564,152 +564,423 @@ @end defun @... ematrix (m, n, x, i, j) will create an m by n matrix all of whose elements are zero except for the i,j element which is x. +@defun ematrix (@var{m}, @var{n}, @var{x}, @var{i}, @var{j}) +Returns an @var{m} by @var{n} matrix, all elements of which +are zero except for the @code{[@var{i}, @var{j}]} element which is @var{x}. +@c WOW, THAT SEEMS PRETTY SPECIALIZED ... @end defun @... entermatrix (m, n) allows one to enter a matrix element by element with Maxima requesting values for each of the m*n entries. @... (%i1) ENTERMATRIX(3,3); Is the matrix 1. Diagonal 2. Symmetric 3. Antisymmetric  4. General +@defun entermatrix (@var{m}, @var{n}) +Returns an @var{m} by @var{n} matrix, reading the elements interactively. Answer 1, 2, 3 or 4 1; Row 1 Column 1: A; Row 2 Column 2: B; Row 3 Column 3: C; Matrix entered.  [ A 0 0 ]  [ ] (%o1) [ 0 B 0 ]  [ ]  [ 0 0 C ] +If @var{n} is equal to @var{m}, +Maxima prompts for the type of the matrix (diagonal, symmetric, antisymmetric, or general) +and for each element. +Each response is terminated by a semicolon @code{;} or dollar sign @code{$}. + +If @var{n} is not equal to @var{m}, +Maxima prompts for each element. +The elements may be any expressions, which are evaluated. +@code{entermatrix} evaluates its arguments. + +@example +(%i1) n: 3$ +(%i2) m: entermatrix (n, n)$ + +Is the matrix 1. Diagonal 2. Symmetric 3. Antisymmetric 4. General +Answer 1, 2, 3 or 4 : +1$ +Row 1 Column 1: +(a+b)^n$ +Row 2 Column 2: +(a+b)^(n+1)$ +Row 3 Column 3: +(a+b)^(n+2)$ +Matrix entered. +(%i3) m; + [ 3 ] + [ (b + a) 0 0 ] + [ ] +(%o3) [ 4 ] + [ 0 (b + a) 0 ] + [ ] + [ 5 ] + [ 0 0 (b + a) ] @end example + @end defun @... genmatrix (array, i2, j2, i1, j1) generates a matrix from the array using array(i1,j1) for the first (upperleft) element and array(i2,j2) for the last (lowerright) element of the matrix. If j1=i1 then j1 may be omitted. If j1=i1=1 then i1 and j1 may both be omitted. If a selected element of the array doesn't exist a symbolic one will be used. @... (%i1) H[I,J]:=1/(I+J1)$ (%i2) GENMATRIX(H,3,3);  [ 1 1]  [1  ]  [ 2 3]  [ ]  [1 1 1] (%o2) [  ]  [2 3 4]  [ ]  [1 1 1]  [  ]  [3 4 5] +@defun genmatrix (@var{a}, @var{i_2}, @var{j_2}, @var{i_1}, @var{j_1}) +@defunx genmatrix (@var{a}, @var{i_2}, @var{j_2}, @var{i_1}) +@defunx genmatrix (@var{a}, @var{i_2}, @var{j_2}) +Returns a matrix generated from @var{a}, +taking element @code{@var{a}[@var{i_1},@var{j_1}]} +as the upperleft element and @code{@var{a}[@var{i_2},@var{j_2}]} +as the lowerright element of the matrix. +Here @var{a} is an array (created by @code{array} but not by @code{make_array}) +or an array function. +(An array function is created like other functions with @code{:=} or @code{define}, +but arguments are enclosed in square brackets instead of parentheses.) + +If @var{j_1} is omitted, it is assumed equal to @var{i_1}. +If both @var{j_1} and @var{i_1} are omitted, both are assumed equal to 1. +If a selected element @code{i,j} of the array is undefined, +the matrix will contain a symbolic element @code{@var{a}[i,j]}. +@example +(%i1) h[i,j] := 1/(i+j1)$ +(%i2) genmatrix (h, 3, 3); + [ 1 1 ] + [ 1   ] + [ 2 3 ] + [ ] + [ 1 1 1 ] +(%o2) [    ] + [ 2 3 4 ] + [ ] + [ 1 1 1 ] + [    ] + [ 3 4 5 ] +(%i3) array (a, fixnum, 2, 2)$ +(%i4) a[1,1]: %e$ +(%i5) a[2,2]: %pi$ +(%i6) kill (a[1,2], a[2,1])$ +(%i7) genmatrix (a, 2, 2); + [ %e a ] + [ 1, 2 ] +(%o7) [ ] + [ a %pi ] + [ 2, 1 ] @end example + @end defun @... gramschmidt (x) @... gschmit (x) a function in the EIGEN package. Do LOAD(EIGEN) to use it. GRAMSCHMIDT takes a LIST of lists the sublists of which are of equal length and not necessarily orthogonal (with respect to the innerproduct defined above) as its argument and returns a similar list each sublist of which is orthogonal to all others. (Returned results may contain integers that are factored. This is due to the fact that the function FACTOR is used to simplify each substage of the GramSchmidt algorithm. This prevents the expressions from getting very messy and helps to reduce the sizes of the numbers that are produced along the way.) +@defun gramschmidt (@var{x}) +@defunx gschmit (@var{x}) +Carries out the GramSchmidt orthogonalization algorithm on @var{x}, +which is either a matrix or a list of lists. +@var{x} is not modified by @code{gramschmidt}. + +If @var{x} is a matrix, the algorithm is applied to the rows of @var{x}. +If @var{x} is a list of lists, the algorithm is applied to the sublists, +which must have equal numbers of elements. +In either case, +the return value is a list of lists, the sublists of which are orthogonal +and span the same space as @var{x}. +If the dimension of the span of @var{x} is less than the number of rows or sublists, +some sublists of the return value are zero. + +@code{factor} is called at each stage of the algorithm to simplify intermediate results. +As a consequence, the return value may contain factored integers. @code{gschmit} (note spelling) is a synonym for @code{gramschmidt}. +@code{load ("eigen")} loads this function. + +Example: + +@example +(%i1) load ("eigen")$ +Warning  you are redefining the Macsyma function eigenvalues +Warning  you are redefining the Macsyma function eigenvectors +(%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]); + [ 1 2 3 ] + [ ] +(%o2) [ 9 18 30 ] + [ ] + [ 12 48 60 ] +(%i3) y: gramschmidt (x); + 2 2 4 3 + 3 3 3 5 2 3 2 3 +(%o3) [[1, 2, 3], [ ,  , ], [ , , 0]] + 2 7 7 2 7 5 5 +(%i4) i: innerproduct$ +(%i5) [i (y[1], y[2]), i (y[2], y[3]), i (y[3], y[1])]; +(%o5) [0, 0, 0] +@end example + @end defun @... hach (a,b,m,n,l) An implementation of Hacijan's linear programming algorithm is available by doing BATCH("kach.mc"$. Details of use are available by doing BATCH("kach.dem"); +@defun hach (@var{a}, @var{b}, @var{m}, @var{n}, @var{l}) +@code{hach} is an implementation of Hacijan's linear programming algorithm. + +@code{load ("kach")} loads this function. +@code{demo ("kach")} executes a demonstration of this function. +@c ACTUALLY BOTH kach.mac AND kach.dem APPEAR TO BE BROKEN AT THE MOMENT +@c DUNNO WHAT WE SHOULD DO ABOUT THAT HERE @end defun @... ident (n) produces an n by n identity matrix. +@defun ident (@var{n}) +Returns an @var{n} by @var{n} identity matrix. @end defun @... innerproduct (x,y) @... inprod (x, y) a function in the EIGEN package. Do LOAD(EIGEN) to use it. INNERPRODUCT takes two LISTS of equal length as its arguments and returns their inner (scalar) product defined by (Complex Conjugate of X).Y (The "dot" operation is the same as the usual one defined for vectors). +@defun innerproduct (@var{x}, @var{y}) +@defunx inprod (@var{x}, @var{y}) +Returns the inner product (also called the scalar product) of @var{x} and @var{y}, +which are lists of equal length, or both 1column or 1row matrices of equal length. +The return value is @code{conjugate (x) . y}, +where @code{.} is the noncommutative multiplication operator. + +@code{load ("eigen")} loads this function. @code{inprod} is a synonym for @code{innerproduct}. +@c NEED EXAMPLE HERE @end defun @... invert (matrix) finds the inverse of a matrix using the adjoint method. This allows a user to compute the inverse of a matrix with +@c THIS DESCRIPTION NEEDS WORK +@defun invert (@var{m}) +Returns the inverse of the matrix @var{m}. +The inverse is computed by the adjoint method. + +This allows a user to compute the inverse of a matrix with bfloat entries or polynomials with floating pt. coefficients without converting to creform. The DETERMINANT command is used to compute cofactors, so if RATMX is @code{false} (the default) the inverse is computed without changing the representation of the elements. The current +converting to creform. + +Cofactors are computed by the @code{determinant} function, +so if @code{ratmx} is @code{false} the inverse is computed +without changing the representation of the elements. + +The current implementation is inefficient for matrices of high order. The DETOUT flag if true keeps the determinant factored out of the + +When @code{detout} is @code{true}, the determinant is factored out of the inverse. Note: the results are not automatically expanded. If the matrix originally had polynomial entries, better appearing output can be generated by EXPAND(INVERT(mat)),DETOUT. If it is desirable to then divide through by the determinant this can be accomplished by XTHRU(%) + +The elements of the inverse are not automatically expanded. +If @var{m} has polynomial elements, better appearing output can be +generated by @code{expand (invert (m)), detout}. +If it is desirable to then +divide through by the determinant this can be accomplished by @code{xthru (%)} or alternatively from scratch by EXPAND(ADJOINT(mat))/EXPAND(DETERMINANT(mat)). INVERT(mat):=ADJOINT(mat)/DETERMINANT(mat). See also DESCRIBE("^^"); for another method of inverting a matrix. +@example +expand (adjoint (m)) / expand (determinant (m)) +invert (m) := adjoint (m) / determinant (m) +@end example + +See @code{^^} (noncommutative exponent) for another method of inverting a matrix. + +@c NEED EXAMPLE HERE @end defun @defvar lmxchar  default: [[]  The character used to display the (left) delimiter of a matrix (see also RMXCHAR). +Default value: @code{[} + +@code{lmxchar} is the character displayed as the left +delimiter of a matrix. +See also @code{rmxchar}. + +Example: + +@example +(%i1) lmxchar: ""$ +(%i2) matrix ([a, b, c], [d, e, f], [g, h, i]); +  a b c ] +  ] +(%o2)  d e f ] +  ] +  g h i ] +@end example @end defvar @... matrix (row1, ..., rown) defines a rectangular matrix with the indicated rows. Each row has the form of a list of expressions, e.g. [A, X**2, Y, 0] is a list of 4 elements. There are a number of commands which deal with matrices, for example: DETERMINANT, CHARPOLY, GENMATRIX, ADDCOL, ADDROW, COPYMATRIX, TRANSPOSE, ECHELON, and RANK. There is also a package on the SHARE directory for computing EIGENVALUES. Try DESCRIBE on these for more information. Matrix multiplication is effected by using the dot operator, ".", which is also convenient if the user wishes to represent other noncommutative algebraic operations. The exponential of the "." operation is "^^" . Thus, for a matrix A, A.A = A^^2 and, if it exists, A^^1 is the inverse of A. The operations +,,*,** are all elementbyelement operations; all operations are normally carried out in full, including the . (dot) operation. Many switches exist for controlling simplification rules +@defun matrix (@var{row_1}, ..., @var{row_n}) +Returns a rectangular matrix which has the rows @var{row_1}, ..., @var{row_n}. +Each row is a list of expressions. +All rows must be the same length. + +The operations @code{+} (addition), @code{} (subtraction), @code{*} (multiplication), +and @code{/} (division), are carried out element by element +when the operands are two matrices, a scalar and a matrix, or a matrix and a scalar. +The operation @code{^} (exponentiation, equivalently @code{**}) +is carried out element by element +if the operands are a scalar and a matrix or a matrix and a scalar, +but not if the operands are two matrices. +@c WHAT DOES THIS NEXT PHRASE MEAN EXACTLY ?? +All operations are normally carried out in full, +including @code{.} (noncommutative multiplication). + +Matrix multiplication is represented by the noncommutative multiplication operator @code{.}. +The corresponding noncommutative exponentiation operator is @code{^^}. +For a matrix @code{@var{A}}, @code{@var{A}.@...{A} = @var{A}^^2} and +@code{@var{A}^^1} is the inverse of @var{A}, if it exists. + +There are switches for controlling simplification of expressions involving dot and matrixlist operations. Options Relating to Matrices: LMXCHAR, RMXCHAR, RATMX, LISTARITH, DETOUT, DOALLMXOPS, DOMXEXPT DOMXMXOPS, DOSCMXOPS, DOSCMXPLUS, SCALARMATRIX, and SPARSE. Do DESCRIBE(option) for details on them. +These are +@code{doallmxops}, @code{domxexpt} +@code{domxmxops}, @code{doscmxops}, and @code{doscmxplus}. +@c CHECK  WE PROBABLY WANT EXHAUSTIVE LIST HERE + +There are additional options which are related to matrices. These are: +@code{lmxchar}, @code{rmxchar}, @code{ratmx}, @code{listarith}, @code{detout}, +@code{scalarmatrix}, +and @code{sparse}. +@c CHECK  WE PROBABLY WANT EXHAUSTIVE LIST HERE + +There are a number of +functions which take matrices as arguments or yield matrices as return values. +See @code{eigenvalues}, @code{eigenvectors}, +@code{determinant}, +@code{charpoly}, @code{genmatrix}, @code{addcol}, @code{addrow}, +@code{copymatrix}, @code{transpose}, @code{echelon}, +and @code{rank}. +@c CHECK  WE PROBABLY WANT EXHAUSTIVE LIST HERE + +Examples: + +@itemize @bullet +@item +Construction of matrices from lists. +@end itemize +@example +(%i1) x: matrix ([17, 3], [8, 11]); + [ 17 3 ] +(%o1) [ ] + [  8 11 ] +(%i2) y: matrix ([%pi, %e], [a, b]); + [ %pi %e ] +(%o2) [ ] + [ a b ] +@end example +@itemize @bullet +@item +Addition, element by element. +@end itemize +@example +(%i3) x + y; + [ %pi + 17 %e + 3 ] +(%o3) [ ] + [ a  8 b + 11 ] +@end example +@itemize @bullet +@item +Subtraction, element by element. +@end itemize +@example +(%i4) x  y; + [ 17  %pi 3  %e ] +(%o4) [ ] + [  a  8 11  b ] +@end example +@itemize @bullet +@item +Multiplication, element by element. +@end itemize +@example +(%i5) x * y; + [ 17 %pi 3 %e ] +(%o5) [ ] + [  8 a 11 b ] +@end example +@itemize @bullet +@item +Division, element by element. +@end itemize +@example +(%i6) x / y; + [ 17  1 ] + [  3 %e ] + [ %pi ] +(%o6) [ ] + [ 8 11 ] + [    ] + [ a b ] +@end example +@itemize @bullet +@item +Matrix to a scalar exponent, element by element. +@end itemize +@example +(%i7) x ^ 3; + [ 4913 27 ] +(%o7) [ ] + [  512 1331 ] +@end example +@itemize @bullet +@item +Scalar base to a matrix exponent, element by element. +@end itemize +@example +(%i8) exp(y); + [ %pi %e ] + [ %e %e ] +(%o8) [ ] + [ a b ] + [ %e %e ] +@end example +@itemize @bullet +@item +Matrix base to a matrix exponent. This is not carried out element by element. +@c WHAT IS THIS ?? +@end itemize +@example +(%i9) x ^ y; + [ %pi %e ] + [ ] + [ a b ] + [ 17 3 ] +(%o9) [ ] + [  8 11 ] +@end example +@itemize @bullet +@item +Noncommutative matrix multiplication. +@end itemize +@example +(%i10) x . y; + [ 3 a + 17 %pi 3 b + 17 %e ] +(%o10) [ ] + [ 11 a  8 %pi 11 b  8 %e ] +(%i11) y . x; + [ 17 %pi  8 %e 3 %pi + 11 %e ] +(%o11) [ ] + [ 17 a  8 b 11 b + 3 a ] +@end example +@itemize @bullet +@item +Noncommutative matrix exponentiation. +A scalar base @code{b} to a matrix power @code{m} +is carried out element by element and so @code{b^^m} is the same as @code{b^m}. +@end itemize +@example +(%i12) x ^^ 3; + [ 3833 1719 ] +(%o12) [ ] + [  4584 395 ] +(%i13) %e ^^ y; + [ %pi %e ] + [ %e %e ] +(%o13) [ ] + [ a b ] + [ %e %e ] +@end example +@itemize @bullet +@item +A matrix raised to a 1 exponent with noncommutative exponentiation is the matrix inverse, +if it exists. +@end itemize +@example +(%i14) x ^^ 1; + [ 11 3 ] + [    ] + [ 211 211 ] +(%o14) [ ] + [ 8 17 ] + [   ] + [ 211 211 ] +(%i15) x . (x ^^ 1); + [ 1 0 ] +(%o15) [ ] + [ 0 1 ] +@end example @end defun 