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}
(59) 
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: Wolfgang Jenkner <wjenkner@us...>  20050202 14:33:40

Update of /cvsroot/maxima/maxima/tests In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv9405 Modified Files: testsuite.lisp rtest14.mac Log Message: Clarify test 52. Index: testsuite.lisp =================================================================== RCS file: /cvsroot/maxima/maxima/tests/testsuite.lisp,v retrieving revision 1.3 retrieving revision 1.4 diff u d r1.3 r1.4  testsuite.lisp 31 Jan 2005 17:45:44 0000 1.3 +++ testsuite.lisp 2 Feb 2005 14:33:29 0000 1.4 @@ 9,7 +9,7 @@ '("rtest1.mac" "rtest1a.mac" "rtest2.mac" "rtest4.mac" "rtest5.mac" "rtest6.mac" "rtest6a.mac" "rtest6b.mac" "rtest7.mac" "rtest9.mac" "rtest9a.mac" "rtest10.mac" "rtest11.mac" "rtest13.mac" "rtest13s.mac"  ("rtest14.mac" 52 60) + ("rtest14.mac" 61) ("rtest15.mac" 4) ("rtest16.mac" 4) "rtestode.mac" "rtestode_zp.mac" "rtestflatten.mac" Index: rtest14.mac =================================================================== RCS file: /cvsroot/maxima/maxima/tests/rtest14.mac,v retrieving revision 1.15 retrieving revision 1.16 diff u d r1.15 r1.16  rtest14.mac 31 Jan 2005 17:43:49 0000 1.15 +++ rtest14.mac 2 Feb 2005 14:33:30 0000 1.16 @@ 151,12 +151,19 @@ factor(ratsimp(specint(t^2*bessel_j(1,a*t)*%e^(p*t),t))); 3*a*p/(p^2+a^2)^(5/2) $ /*  * I (rtoy) think this is incorrect, but I haven't found any reference  * to gives this integral.  */ radcan(specint(t*hstruve[1](t)*%e^(p*t),t)); 16*(2*p*sqrt(p^2+1)+2*p^2)/(9*%pi^(3/2)*p^4*(2*p*sqrt(p^2+1)+2*p^2+1)) $ +(/* This is the Laplace transform of the Struve H_1 function, see + http://dlmf.nist.gov/Draft/ST/about_ST.8.13.html */ + 2/(%pi*p)2*p*log(p/(sqrt(p^2+1)1))/(%pi*sqrt(p^2+1)), + /* And this should be the same as the specint of the next test below */ + diff(%%,p), + ev(fullratsimp(%%),logexpand:all)); +(sqrt(p^2+1)*(2*p^2*log(sqrt(p^2+1)1)2*p^2*log(p))2*p^22) + /(%pi*p^6+2*%pi*p^4+%pi*p^2)$ + +(ev(fullratsimp(specint(t*hstruve[1](t)*%e^(p*t),t)),logexpand:all), + ratsimp(%%/%)); +/* Well, except for a fishy constant factor... */ +4/(3*sqrt(%pi))$ /* * I (rtoy) also have doubts about this integral, but I haven't found 
From: Robert Dodier <robert_dodier@us...>  20050202 07:23:17

Update of /cvsroot/maxima/maxima/doc/info In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv17017 Modified Files: Rules.texi Log Message: Change most uppercase to lowercase and enclose in @code or @var as appropriate, cut out obsolete, commentedout @unnumberedsec and @node tags. Still needs a lot of work. Index: Rules.texi =================================================================== RCS file: /cvsroot/maxima/maxima/doc/info/Rules.texi,v retrieving revision 1.5 retrieving revision 1.6 diff u d r1.5 r1.6  Rules.texi 22 Nov 2004 00:13:02 0000 1.5 +++ Rules.texi 2 Feb 2005 07:23:06 0000 1.6 @@ 7,18 +7,17 @@ @section Introduction to Rules and Patterns This section discusses user defined pattern matching and simplification rules (set up by TELLSIMP, TELLSIMPAFTER, DEFMATCH, or, DEFRULE.) You may affect the main simplification procedures, or else have your rules applied explicityly using APPLY1 and APPLY2.  There are additional mechanisms for polynomials rules under TELLRAT, and for commutative and non commutative algebra in chapter on AFFINE. +simplification rules (set up by @code{tellsimp}, @code{tellsimpafter}, @code{defmatch}, or, +@code{defrule}.) You may affect the main simplification procedures, or +else have your rules applied explicityly using @code{apply1} and @code{apply2}. + There are additional mechanisms for polynomials rules under @code{tellrat}, +and for commutative and non commutative algebra in chapter on @code{affine}. @c end concepts Rules and Patterns @node Definitions for Rules and Patterns, , Introduction to Rules and Patterns, Rules and Patterns @section Definitions for Rules and Patterns @... @node APPLY1 @... @unnumberedsec phony @... APPLY1 (exp, rule1, ..., rulen) + +@defun apply1 (@var{expr}, @var{rule_1}, ..., @var{rule_n}) repeatedly applies the first rule to exp until it fails, then repeatedly applies the same rule to all subexpressions of exp, lefttoright, until the first rule has failed @@ 28,105 +27,100 @@ subexpression, the application is finished. @end defun @... @node APPLY2 @... @unnumberedsec phony @... APPLY2 (exp, rule1, ..., rulen) differs from APPLY1 in that if the + +@defun apply2 (@var{expr}, @var{rule_1}, ..., @var{rule_n}) +differs from @code{apply1} in that if the first rule fails on a given subexpression, then the second rule is repeatedly applied, etc. Only if they all fail on a given subexpression is the whole set of rules repeatedly applied to the next subexpression. If one of the rules succeeds, then the same subexpression is reprocessed, starting with the first rule. MAXAPPLYDEPTH[10000] is the maximum depth to which APPLY1 and APPLY2 +@code{maxapplydepth}[10000] is the maximum depth to which @code{apply1} and @code{apply2} will delve. @end defun @... @node APPLYB1 @... @unnumberedsec phony @... APPLYB1 (exp, rule1, ..., rulen) is similar to APPLY1 but works from + +@defun applyb1 (@var{expr}, @var{rule_1}, ..., @var{rule_n}) +is similar to @code{apply1} but works from the "bottom up" instead of from the "top down". That is, it processes the smallest subexpression of exp, then the next smallest, etc. MAXAPPLYHEIGHT[10000]  is the maximum height to which APPLYB1 will +@code{maxapplyheight}[10000]  is the maximum height to which @code{applyb1} will reach before giving up. @end defun @... @node CURRENT_LET_RULE_PACKAGE @... @unnumberedsec phony @... CURRENT_LET_RULE_PACKAGE  default:[DEFAULT_LET_RULE_PACKAGE]  the + +@defvar current_let_rule_package + default:[@code{default_let_rule_package}]  the name of the rule package that is presently being used. The user may reset this variable to the name of any rule package previously defined via the LET command. Whenever any of the functions comprising the let +via the @code{let} command. Whenever any of the functions comprising the let package are called with no package name the value of @example CURRENT_LET_RULE_PACKAGE +current_let_rule_package @end example is used. If a call such as LETSIMP(expr,rule_pkg_name); is made, the rule package rule_pkg_name is used for that LETSIMP command only, i.e. the value of CURRENT_LET_RULE_PACKAGE is not changed. +@code{letsimp (expr, rule_pkg_name)} is made, the rule package rule_pkg_name +is used for that @code{letsimp} command only, i.e. the value of +@code{current_let_rule_package} is not changed. @end defvar @... @node DEFAULT_LET_RULE_PACKAGE @... @unnumberedsec phony @... DEFAULT_LET_RULE_PACKAGE + +@defvar default_let_rule_package  the name of the rule package used when one is not explicitly set by the user with LET or by changing the value of CURRENT_LET_RULE_PACKAGE. +is not explicitly set by the user with @code{let} or by changing the value of +@code{current_let_rule_package}. @end defvar @... @node DEFMATCH @... @unnumberedsec phony @... DEFMATCH (progname, pattern, parm1, ..., parmn) + +@defun defmatch (@var{progname}, @var{pattern}, @var{param_1}, ..., @var{param_n}) creates a function of n+1 arguments with the name progname which tests an expression to see if it can match a particular pattern. The pattern is some expression containing pattern variables and parameters. The parms are given explicitly as arguments to DEFMATCH while the pattern variables (if supplied) were given implicitly in a previous MATCHDECLARE function. +explicitly as arguments to @code{defmatch} while the pattern variables (if +supplied) were given implicitly in a previous @code{matchdeclare} function. The first argument to the created function progname, is an expression to be matched against the "pattern" and the other n arguments are the actual variables occurring in the expression which are to take the place of dummy variables occurring in the "pattern". Thus the parms in the DEFMATCH are like the dummy arguments to the SUBROUTINE statement in FORTRAN. When the function is "called" the actual +in the @code{defmatch} are like the dummy arguments to the @code{subroutine} +statement in Fortran. When the function is "called" the actual arguments are substituted. For example: + @example (%i1) NONZEROANDFREEOF(X,E):= IF E#0 AND FREEOF(X,E)  THEN TRUE ELSE FALSE$ (IS(E#0 AND FREEOF(X,E)) is an equivalent function +(%i1) nonzeroandfreeof(x,e):= if e#0 and freeof(x,e) + then true else false$ +(is(e#0 and freeof(x,e)) is an equivalent function definition) (%i2) MATCHDECLARE(A,NONZEROANDFREEOF(X),B,FREEOF(X))$ (%i3) DEFMATCH(LINEAR,A*X+B,X)$  This has caused the function LINEAR(exp,var1) to be defined. It  +(%i2) matchdeclare(a,nonzeroandfreeof(x),b,freeof(x))$ +(%i3) defmatch(linear,a*x+b,x)$ @end example + @noindent + This has caused the function @code{linear (expr, var_1)} to be defined. It tests exp to see if it is of the form A*var1+B where A and B do not contain var1 and A is not zero. DEFMATCHed functions return (if the +contain var1 and A is not zero. @code{defmatch}'ed functions return (if the match is successful) a list of equations whose left sides are the pattern variables and parms and whose right sides are the expressions which the pattern variables and parameters matched. The pattern variables, but not the parameters, are set to the matched expressions. If the match fails, the function returns FALSE. Thus +If the match fails, the function returns @code{false}. Thus LINEAR(3*Z+(Y+1)*Z+Y**2,Z) would return [B=Y**2, A=Y+4, X=Z]. Any variables not declared as pattern variables in MATCHDECLARE or as parameters in DEFMATCH which occur in pattern will match only themselves so that if the third argument to the DEFMATCH in (%i4) had been omitted, then LINEAR would only match expressions linear in X, +variables not declared as pattern variables in @code{matchdeclare} or as +parameters in @code{defmatch} which occur in pattern will match only +themselves so that if the third argument to the @code{defmatch} in (%i4) had +been omitted, then @code{linear} would only match expressions linear in X, not in any other variable. A pattern which contains no parameters or pattern variables returns TRUE if the match succeeds. Do EXAMPLE(DEFMATCH); for more examples. +returns @code{true} if the match succeeds. +Do @code{example (defmatch)} for more examples. @end defun @... @node DEFRULE @... @unnumberedsec phony @... DEFRULE (rulename, pattern, replacement) + +@defun defrule (@var{rulename}, @var{pattern}, @var{replacement}) defines and names a replacement rule for the given pattern. If the rule named rulename is applied to an expression (by one of the APPLY functions below), every +applied to an expression (by one of the @code{apply} functions below), every subexpression matching the pattern will be replaced by the replacement. All variables in the replacement which have been assigned values by the pattern match are assigned those values in the @@ 136,134 +130,127 @@ the original expression is returned. @end defun @... @node DISPRULE @... @unnumberedsec phony @... DISPRULE (rulename1, rulename2, ...) + +@defun disprule (@var{rulename_1}, @var{rulename_2}, ...) will display rules with the names rulename1, rulename2, as were given by DEFRULE, TELLSIMP, or TELLSIMPAFTER or a pattern defined by DEFMATCH. For example, the first rule modifying SIN will be called SINRULE1. DISPRULE(ALL); +rulename1, rulename2, as were given by @code{defrule}, @code{tellsimp}, or +@code{tellsimpafter} or a pattern defined by @code{defmatch}. For example, the +first rule modifying @code{sin} will be called @code{sinrule1}. @code{disprule (all)} will display all rules. @end defun @... @node LET @... @unnumberedsec phony @... LET (prod, repl, predname, arg1, arg2, ..., argn) + +@defun let (@var{prod}, @var{repl}, @var{predname}, @var{arg_1}, ..., @var{arg_n}) defines a substitution rule for LETSIMP such that prod gets replaced by repl. +substitution rule for @code{letsimp} such that prod gets replaced by repl. prod is a product of positive or negative powers of the following types of terms: @itemize @bullet @item  (1) Atoms which LETSIMP will search for literally unless previous to calling LETSIMP the MATCHDECLARE function is used to associate a predicate with the atom. In this case LETSIMP will match the atom to + (1) Atoms which @code{letsimp} will search for literally unless previous +to calling @code{letsimp} the @code{matchdeclare} function is used to associate a +predicate with the atom. In this case @code{letsimp} will match the atom to any term of a product satisfying the predicate. @item (2) Kernels such as SIN(X), N!, F(X,Y), etc. As with atoms above LETSIMP will look for a literal match unless MATCHDECLARE is used to +@code{letsimp} will look for a literal match unless @code{matchdeclare} is used to associate a predicate with the argument of the kernel. A term to a positive power will only match a term having at least that power in the expression being LETSIMPed. A term to a negative power +power in the expression being @code{letsimp}'ed. A term to a negative power on the other hand will only match a term with a power at least as negative. In the case of negative powers in "product" the switch LETRAT must be set to TRUE (see below). If a predicate is included in the LET function followed by a list of +@code{letrat} must be set to @code{true} (see below). +If a predicate is included in the @code{let} function followed by a list of arguments, a tentative match (i.e. one that would be accepted if the predicate were omitted) will be accepted only if predname(arg1',...,argn') evaluates to TRUE where argi' is the value +predname(arg1',...,argn') evaluates to @code{true} where argi' is the value matched to argi. The argi may be the name of any atom or the argument of any kernel appearing in prod. repl may be any rational expression. If any of the atoms or arguments from prod appear in repl the appropriate substitutions will be made. @end itemize  LETRAT[FALSE] when FALSE, LETSIMP will simplify the numerator and + @code{letrat}[@code{false}] when @code{false}, @code{letsimp} will simplify the numerator and denominator of expr independently and return the result. Substitutions such as N!/N goes to (N1)! will fail. To handle such situations LETRAT should be set to TRUE, then the numerator, +situations @code{letrat} should be set to @code{true}, then the numerator, denominator, and their quotient will be simplified in that order. These substitution functions allow you to work with several rulepackages at once. Each rulepackage can contain any number of LETed +rulepackages at once. Each rulepackage can contain any number of @code{let}'ed rules and is referred to by a user supplied name. To insert a rule into the rulepackage name, do LET([prod,repl,pred,arg1,...],name). To apply the rules in rulepackage name, do LETSIMP(expr, name). The function LETSIMP(expr,name1,name2,...) is equivalent to doing LETSIMP(expr,name1) followed by LETSIMP(%,name2) etc. CURRENT_LET_RULE_PACKAGE is the name of the rule package that is +@code{current_let_rule_package} is the name of the rule package that is presently being used. The user may reset this variable to the name of any rule package previously defined via the LET command. Whenever any +any rule package previously defined via the @code{let} command. Whenever any of the functions comprising the let package are called with no package name the value of CURRENT_LET_RULE_PACKAGE is used. If a call such as +name the value of @code{current_let_rule_package} is used. If a call such as LETSIMP(expr,rule_pkg_name); is made, the rule package rule_pkg_name is used for that LETSIMP command only, i.e. the value of CURRENT_LET_RULE_PACKAGE is not changed. There is a DEFAULT_LET_RULE_PACKAGE which is assumed when no other name is supplied to any of the functions. Whenever a LET includes a rulepackage name that is used as the CURRENT_LET_RULE_PACKAGE. +is used for that @code{letsimp} command only, i.e. the value of +@code{current_let_rule_package} is not changed. +There is a @code{default_let_rule_package} which is assumed when no other +name is supplied to any of the functions. Whenever a @code{let} includes a +rulepackage name that is used as the @code{current_let_rule_package}. @end defun @... @node LETRAT @... @unnumberedsec phony @... LETRAT  default: [FALSE]  when FALSE, LETSIMP will simplify the + +@defvar letrat + default: [@code{false}]  when @code{false}, @code{letsimp} will simplify the numerator and denominator of expr independently and return the result. Substitutions such as N!/N goes to (N1)! will fail. To handle such situations LETRAT should be set to TRUE, then the numerator, +situations @code{letrat} should be set to @code{true}, then the numerator, denominator, and their quotient will be simplified in that order. @end defvar @... @node LETRULES @... @unnumberedsec phony @... LETRULES () + +@defun letrules () displays the rules in the current rulepackage. LETRULES(name) displays the rules in the named rulepackage. The current rulepackage is the value of @example CURRENT_LET_RULE_PACKAGE +current_let_rule_package @end example The initial value of the rules is @example DEFAULT_LET_RULE_PACKAGE +default_let_rule_package @end example @end defun @... @node LETSIMP @... @unnumberedsec phony @... LETSIMP (exp) + +@defun letsimp (@var{expr}) will continually apply the substitution rules previously defined by the function LET until no further change is made to exp. +defined by the function @code{let} until no further change is made to exp. LETSIMP(expr,rule_pkg_name); will cause the rule package rule_pkg_name to be used for that LETSIMP command only, i.e. the value of CURRENT_LET_RULE_PACKAGE is not changed. +to be used for that @code{letsimp} command only, i.e. the value of +@code{current_let_rule_package} is not changed. @end defun @... @node LET_RULE_PACKAGES @... @unnumberedsec phony @... LET_RULE_PACKAGES  default:[DEFAULT_LET_RULE_PACKAGE]  The value of LET_RULE_PACKAGES is a list of all the userdefined let rule packages + +@defvar let_rule_packages + default:[@code{default_let_rule_package}]  The value of +@code{let_rule_packages} is a list of all the userdefined let rule packages plus the special package @example DEFAULT_LET_RULE_PACKAGE +default_let_rule_package @end example This is the name of the rule package used when one is not explicitly set by the user. @end defvar @... @node MATCHDECLARE @... @unnumberedsec phony @... MATCHDECLARE (patternvar, predicate, ...) + +@defun matchdeclare (@var{patternvar}, @var{predicate}, ...) associates a predicate with a pattern variable so that the variable will only match expressions for which the predicate is not FALSE. (The matching is accomplished +for which the predicate is not @code{false}. (The matching is accomplished by one of the functions described below). For example after @example MATCHDECLARE(Q,FREEOF(X,%E)) +matchdeclare(q,freeof(x,%e)) @end example is executed, Q will match any expression not containing X or %E. If the match succeeds then the variable is set to the matched expression. The predicate (in this case FREEOF) is +set to the matched expression. The predicate (in this case @code{freeof}) is written without the last argument which should be the one against which the pattern variable is to be tested. Note that the patternvar and the arguments to the predicate are evaluated at the time the match @@ 272,19 +259,18 @@ of which are to have the associated predicate. Any even number of arguments may be given. For pattern matching, predicates refer to functions which are either FALSE or not FALSE (any non FALSE value acts like TRUE). +@code{false} or not @code{false} (any non @code{false} value acts like @code{true}). MATCHDECLARE(var,TRUE) will permit var to match any expression. @end defun @... @node MATCHFIX (leftOperator, rightMatchingOperator, [BP 180], [ARGSPOS , $any] [POS,ANY] @... @unnumberedsec phony @... MATCHFIX   MATCHFIX operators are used to denote functions of any + +@defun matchfix +  @code{matchfix} operators are used to denote functions of any number of arguments which are passed to the function as a list. The arguments occur between the main operator and its "matching" delimiter. The MATCHFIX("x",...) function is a syntax extension function which declares x to be a MATCHFIX operator. The default binding power is 180, and the ARGS inside may be anything. +function which declares x to be a @code{matchfix} operator. The default +binding power is 180, and the args inside may be anything. @example (%i1) matchfix ("", ""); @@ 308,49 +294,45 @@ @end example @end defun @... @node REMLET @... @unnumberedsec phony @... REMLET (prod, name) + +@defun remlet (@var{prod}, @var{name}) deletes the substitution rule, prod > repl, most recently defined by the LET function. If name is supplied the rule is +recently defined by the @code{let} function. If name is supplied the rule is deleted from the rule package name. REMLET() and REMLET(ALL) delete all substitution rules from the current rulepackage. If the name of a rulepackage is supplied, e.g. REMLET(ALL,name), the rulepackage, name, is also deleted. If a substitution is to be changed using the same product, REMLET need not be called, just redefine the substitution using the same product (literally) with the LET function and the new +product, @code{remlet} need not be called, just redefine the substitution +using the same product (literally) with the @code{let} function and the new replacement and/or predicate name. Should REMLET(product) now be called the original substitution rule will be revived. @end defun @... @node REMRULE @... @unnumberedsec phony @... REMRULE (function, rulename) + +@defun remrule (@var{function}, @var{rulename}) will remove a rule with the name rulename from the function which was placed there by DEFRULE, DEFMATCH, TELLSIMP, or TELLSIMPAFTER. If rulename is ALL, then all rules will +from the function which was placed there by @code{defrule}, @code{defmatch}, +@code{tellsimp}, or @code{tellsimpafter}. If rulename is @code{all}, then all rules will be removed. @end defun @... @node TELLSIMP @... @unnumberedsec phony @... TELLSIMP (pattern, replacement) is similar to TELLSIMPAFTER but places + +@defun tellsimp (@var{pattern}, @var{replacement}) +is similar to @code{tellsimpafter} but places new information before old so that it is applied before the builtin simplification rules. TELLSIMP is used when it is important to modify +simplification rules. @code{tellsimp} is used when it is important to modify the expression before the simplifier works on it, for instance if the simplifier "knows" something about the expression, but what it returns is not to your liking. If the simplifier "knows" something about the main operator of the expression, but is simply not doing enough for you, you probably want to use TELLSIMPAFTER. The pattern may not be a sum, product, single variable, or number. RULES is a list of names having simplification rules added to them by DEFRULE, DEFMATCH, TELLSIMP, or TELLSIMPAFTER. Do EXAMPLE(TELLSIMP); for examples. +you, you probably want to use @code{tellsimpafter}. The pattern may not be a +sum, product, single variable, or number. @code{rules} is a list of names +having simplification rules added to them by @code{defrule}, @code{defmatch}, +@code{tellsimp}, or @code{tellsimpafter}. Do EXAMPLE(TELLSIMP); for examples. @end defun @... @node TELLSIMPAFTER @... @unnumberedsec phony @... TELLSIMPAFTER (pattern, replacement) + +@defun tellsimpafter (@var{pattern}, @var{replacement}) defines a replacement for pattern which the Maxima simplifier uses after it applies the builtin simplification rules. The pattern may be anything but a single 
From: Robert Dodier <robert_dodier@us...>  20050202 07:02:00

Update of /cvsroot/maxima/maxima/doc/info In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv13200 Modified Files: Matrices.texi Log Message: Revised some items, added examples, introduced @code and @var as appropriate. Still needs work. Index: Matrices.texi =================================================================== RCS file: /cvsroot/maxima/maxima/doc/info/Matrices.texi,v retrieving revision 1.9 retrieving revision 1.10 diff u d r1.9 r1.10  Matrices.texi 1 Feb 2005 06:33:59 0000 1.9 +++ Matrices.texi 2 Feb 2005 07:01:49 0000 1.10 @@ 14,30 +14,55 @@ @node DOT, VECTORS, Introduction to Matrices and Linear Algebra, Introduction to Matrices and Linear Algebra @subsection DOT   . The dot operator, for matrix (noncommutative) multiplication. When "." is used in this way, spaces should be left on both sides of it, e.g. A . B. This distinguishes it plainly from a decimal point in a floating point number. Do APROPOS(DOT); for a list of the switches which affect the dot operator. +The operator @code{.} represents noncommutative multiplication and scalar product. +When the operands are 1column or 1row matrices @code{a} and @code{b}, +the expression @code{a.b} is equivalent to @code{sum (a[i]*b[i], i, 1, length(a))}. +If @code{a} and @code{b} are not complex, this is the scalar product, +also called the inner product or dot product, of @code{a} and @code{b}. +The scalar product is defined as @code{conjugate(a).b} when @code{a} and @code{b} are complex; +@code{innerproduct} in the @code{eigen} package provides the complex scalar product. + +When the operands are more general matrices, +the product is the matrix product @code{a} and @code{b}. +The number of rows of @code{b} must equal the number of columns of @code{a}, +and the result has number of rows equal to the number of rows of @code{a} +and number of columns equal to the number of columns of @code{b}. + +To distinguish @code{.} as an arithmetic operator from +the decimal point in a floating point number, +it may be necessary to leave spaces on either side. +For example, @code{5.e3} is @code{5000.0} but @code{5 . e3} is @code{5} times @code{e3}. + +There are several flags which govern the simplification of +expressions involving @code{.}, namely +@code{dot}, @code{dot0nscsimp}, @code{dot0simp}, @code{dot1simp}, @code{dotassoc}, +@code{dotconstrules}, @code{dotdistrib}, @code{dotexptsimp}, @code{dotident}, +and @code{dotscrules}. @node VECTORS, eigen, DOT, Introduction to Matrices and Linear Algebra @subsection VECTORS   The file SHARE;VECT > contains a vector analysis package, share/vect.dem contains a corresponding demonstration, and SHARE;VECT ORTH contains definitions of various orthogonal curvilinear coordinate systems. LOAD(VECT); will load this package for you. +@code{vect} is a package of functions for vector analysis. +@code{load ("vect")} loads this package, and @code{demo ("vect")} displays a demonstration. +@c find maxima name \*orth\* YIELDS NOTHING; ARE THESE FUNCTIONS IN ANOTHER FILE NOW ?? +@c and SHARE;VECT ORTH contains definitions of various orthogonal curvilinear coordinate systems. + The vector analysis package can combine and simplify symbolic expressions including dot products and cross products, together with the gradient, divergence, curl, and Laplacian operators. The distribution of these operators over sums or products is under user control, as are various other expansions, including expansion +distribution of these operators over sums or products is governed +by several flags, as are various other expansions, including expansion into components in any specific orthogonal coordinate systems. There is also a capability for deriving the scalar or vector potential +There are also functions for deriving the scalar or vector potential of a field. The package contains the following commands: VECTORSIMP, SCALEFACTORS, EXPRESS, POTENTIAL, and VECTORPOTENTIAL. Do DESCRIBE(cmd) on these command names, or PRINTFILE(VECT,USAGE,SHARE); for details. Warning: The VECT package declares "." to be a commutative operator. + +The @code{vect} package contains these functions: +@code{vectorsimp}, @code{scalefactors}, +@code{express}, @code{potential}, and @code{vectorpotential}. +@c REVIEW vect.usg TO ENSURE THAT TEXINFO HAS WHATEVER IS THERE +@c PRINTFILE(VECT,USAGE,SHARE); for details. + +Warning: the @code{vect} package declares the dot operator @code{.} +to be a commutative operator. @node eigen, , VECTORS, Introduction to Matrices and Linear Algebra @subsection eigen @@ 722,7 +747,7 @@ @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}, +Returns the inner product (also called the scalar product or dot 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. @@ 984,77 +1009,197 @@ @end defun @... matrixmap (fn, m) will map the function fn onto each element of the matrix M. +@defun matrixmap (@var{f}, @var{m}) +Returns a matrix with element @code{i,j} equal to @code{@var{f}(@var{m}[i,j])}. +See also @code{map}, @code{fullmap}, @code{fullmapl}, and @code{apply}. + +@c NEED EXAMPLE HERE @end defun @... matrixp (exp) is @code{true} if exp is a matrix else @code{false}. +@defun matrixp (@var{expr}) +Returns @code{true} if @var{expr} is a matrix, otherwise @code{false}. @end defun @defvar matrix_element_add  default: [+]  May be set to "?"; may also be the name of a function, or a LAMBDA expression. In this way, a rich variety of algebraic structures may be simulated. For more details, do DEMO("matrix.dem1"); and DEMO("matrix.dem2");. +Default value: @code{+} + +@code{matrix_element_add} is the operation +invoked in place of addition in a matrix multiplication. +@code{matrix_element_add} can be assigned any nary operator +(that is, a function which handles any number of arguments). +The assigned value may be the name of an operator enclosed in quote marks, +the name of a function, +or a lambda expression. + +See also @code{matrix_element_mult} and @code{matrix_element_transpose}. + +Example: + +@example +(%i1) matrix_element_add: "*"$ +(%i2) matrix_element_mult: "^"$ +(%i3) aa: matrix ([a, b, c], [d, e, f]); + [ a b c ] +(%o3) [ ] + [ d e f ] +(%i4) bb: matrix ([u, v, w], [x, y, z]); + [ u v w ] +(%o4) [ ] + [ x y z ] +(%i5) aa . transpose (bb); + [ u v w x y z ] + [ a b c a b c ] +(%o5) [ ] + [ u v w x y z ] + [ d e f d e f ] +@end example @end defvar @defvar matrix_element_mult  default: [*]  May be set to "."; may also be the name of a function, or a LAMBDA expression. In this way, a rich variety of algebraic structures may be simulated. For more details, do DEMO("matrix.dem1"); and DEMO("matrix.dem2"); +Default value: @code{*} + +@code{matrix_element_mult} is the operation +invoked in place of multiplication in a matrix multiplication. +@code{matrix_element_mult} can be assigned any binary operator. +The assigned value may be the name of an operator enclosed in quote marks, +the name of a function, +or a lambda expression. + +The dot operator @code{.} is a useful choice in some contexts. + +See also @code{matrix_element_add} and @code{matrix_element_transpose}. + +Example: + +@example +(%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$ +(%i2) matrix_element_mult: lambda ([x, y], (x  y)^2)$ +(%i3) [a, b, c] . [x, y, z]; + 2 2 2 +(%o3) sqrt((c  z) + (b  y) + (a  x) ) +(%i4) aa: matrix ([a, b, c], [d, e, f]); + [ a b c ] +(%o4) [ ] + [ d e f ] +(%i5) bb: matrix ([u, v, w], [x, y, z]); + [ u v w ] +(%o5) [ ] + [ x y z ] +(%i6) aa . transpose (bb); + [ 2 2 2 ] + [ sqrt((c  w) + (b  v) + (a  u) ) ] +(%o6) Col 1 = [ ] + [ 2 2 2 ] + [ sqrt((f  w) + (e  v) + (d  u) ) ] + + [ 2 2 2 ] + [ sqrt((c  z) + (b  y) + (a  x) ) ] + Col 2 = [ ] + [ 2 2 2 ] + [ sqrt((f  z) + (e  y) + (d  x) ) ] +@end example @end defvar @defvar matrix_element_transpose  default: @code{false}  Other useful settings are TRANSPOSE and NONSCALARS; may also be the name of a function, or a LAMBDA expression. In this way, a rich variety of algebraic structures may be simulated. For more details, do DEMO("matrix.dem1"); and DEMO("matrix.dem2");. +Default value: @code{false} + +@code{matrix_element_transpose} is the operation +applied to each element of a matrix when it is transposed. +@code{matrix_element_mult} can be assigned any unary operator. +The assigned value may be the name of an operator enclosed in quote marks, +the name of a function, +or a lambda expression. + +When @code{matrix_element_transpose} equals @code{transpose}, +the @code{transpose} function is applied to every element. +When @code{matrix_element_transpose} equals @code{nonscalars}, +the @code{transpose} function is applied to every nonscalar element. +If some element is an atom, the @code{nonscalars} option applies +@code{transpose} only if the atom is declared nonscalar, +while the @code{transpose} option always applies @code{transpose}. + +The default value, @code{false}, means no operation is applied. + +See also @code{matrix_element_add} and @code{matrix_element_mult}. + +Examples: + +@example +(%i1) declare (a, nonscalar)$ +(%i2) transpose ([a, b]); + [ transpose(a) ] +(%o2) [ ] + [ b ] +(%i3) matrix_element_transpose: nonscalars$ +(%i4) transpose ([a, b]); + [ transpose(a) ] +(%o4) [ ] + [ b ] +(%i5) matrix_element_transpose: transpose$ +(%i6) transpose ([a, b]); + [ transpose(a) ] +(%o6) [ ] + [ transpose(b) ] +(%i7) matrix_element_transpose: lambda ([x], realpart(x)  %i*imagpart(x))$ +(%i8) m: matrix ([1 + 5*%i, 3  2*%i], [7*%i, 11]); + [ 5 %i + 1 3  2 %i ] +(%o8) [ ] + [ 7 %i 11 ] +(%i9) transpose (m); + [ 1  5 %i  7 %i ] +(%o9) [ ] + [ 2 %i + 3 11 ] +@end example @end defvar @... mattrace (m) computes the trace [sum of the elements on the main diagonal] of the square matrix M. It is used by NCHARPOLY, an alternative to Maxima's CHARPOLY. It is used by doing LOADFILE("nchrpl"); +@defun mattrace (@var{m}) +Returns the trace (that is, the sum of the elements on the main diagonal) of +the square matrix @var{m}. + +@code{mattrace} is called by @code{ncharpoly}, +an alternative to Maxima's @code{charpoly}. +@c UMM, HOW IS THAT RELEVANT HERE ?? + +@code{load ("nchrpl")} loads this function. @end defun @... minor (m, i, j) computes the i,j minor of the matrix M. That is, M with row i and column j removed. +@defun minor (@var{m}, @var{i}, @var{j}) +Returns the @var{i}, @var{j} minor of the matrix @var{m}. That is, @var{m} +with row @var{i} and column @var{j} removed. @end defun @... ncexpt (a,b) if an (noncommutative) exponential expression is too wide to be displayed as A^^B it will appear as NCEXPT(A,B). +@defun ncexpt (@var{a}, @var{b}) +If a noncommutative exponential expression is too +wide to be displayed as @code{@var{a}^^@var{b}} it appears as @code{ncexpt (@var{a},@var{b})}. @end defun @... ncharpoly (m,var) finds the characteristic polynomial of the matrix M with respect to var. This is an alternative to Maxima's CHARPOLY. NCHARPOLY works by computing traces of powers of the given matrix, +@defun ncharpoly (@var{m}, @var{x}) +Returns the characteristic polynomial of the matrix @var{m} +with respect to @var{x}. This is an alternative to Maxima's @code{charpoly}. + +@code{ncharpoly} works by computing traces of powers of the given matrix, which are known to be equal to sums of powers of the roots of the characteristic polynomial. From these quantities the symmetric functions of the roots can be calculated, which are nothing more than the coefficients of the characteristic polynomial. CHARPOLY works by forming the determinant of VAR * IDENT [N]  A. Thus NCHARPOLY wins, +the coefficients of the characteristic polynomial. @code{charpoly} works by +@c SHOULD THAT BE "m" INSTEAD OF "a" IN THE NEXT LINE ?? +forming the determinant of @code{@var{x} * ident [n]  a}. Thus @code{ncharpoly} wins, for example, in the case of large dense matrices filled with integers, since it avoids polynomial arithmetic altogether. It may be used by doing LOADFILE("nchrpl"); +since it avoids polynomial arithmetic altogether. + +@code{load ("nchrpl")} loads this file. @end defun @... newdet (m,n) +@defun newdet (@var{m}, @var{n}) also computes the determinant of M but uses the JohnsonGentleman tree minor algorithm. M may be the name of a matrix or array. The argument n is the order; it is optional if M is @@ 1068,34 +1213,38 @@ @end defvr @... nonscalarp (exp) is @code{true} if exp is a nonscalar, i.e. it contains +@defun nonscalarp (@var{expr}) +is @code{true} if @var{expr} is a nonscalar, i.e. it contains atoms declared as nonscalars, lists, or matrices. @end defun @... permanent (m,n) computes the permanent of the matrix M. A permanent +@defun permanent (@var{m}, @var{n}) +computes the permanent of the matrix @var{m}. A permanent is like a determinant but with no sign changes. @end defun @... rank (m) computes the rank of the matrix M. That is, the order of the largest nonsingular subdeterminant of M. Caveat: RANK may return the +@defun rank (@var{m}) +computes the rank of the matrix @var{m}. That is, the order of the +largest nonsingular subdeterminant of @var{m}. Caveat: RANK may return the wrong answer if it cannot determine that a matrix element that is equivalent to zero is indeed so. @end defun @defvar ratmx  default: @code{false}  if @code{false} will cause determinant and matrix addition, subtraction, and multiplication to be performed in the representation of the matrix elements and will cause the result of matrix inversion to be left in general representation. If it is @code{true}, the 4 operations mentioned above will be performed in CRE form and the result of matrix inverse will be in CRE form. Note that this may cause the elements to be expanded (depending on the setting of RATFAC) +Default value: @code{false} + +When @code{ratmx} is @code{false}, determinant and matrix +addition, subtraction, and multiplication are performed in the +representation of the matrix elements and cause the result of +matrix inversion to be left in general representation. + +When @code{ratmx} is @code{true}, +the 4 operations mentioned above are performed in CRE form and the +result of matrix inverse is in CRE form. Note that this may +cause the elements to be expanded (depending on the setting of @code{ratfac}) which might not always be desired. @end defvar @@ 1142,29 +1291,32 @@ @defun similaritytransform (mat) @defunx simtran (mat) a function in the EIGEN package. Do LOAD(EIGEN) to use it. SIMILARITYTRANSFORM takes a MATRIX as its +@code{similaritytransform} takes a @code{matrix} as its argument and returns a list which is the output of the UNITEIGENVECTORS command. In addition if the flag NONDIAGONALIZABLE is @code{false} two global matrices LEFTMATRIX and RIGHTMATRIX will be +@code{uniteigenvectors} command. In addition if the flag @code{nondiagonalizable} +is @code{false} two global matrices @code{leftmatrix} and @code{rightmatrix} will be generated. These matrices have the property that LEFTMATRIX.MAT.RIGHTMATRIX is a diagonal matrix with the eigenvalues of MAT on the diagonal. If NONDIAGONALIZABLE is @code{true} these two matrices will not be generated. If the flag HERMITIANMATRIX is @code{true} then LEFTMATRIX is the complex conjugate of the transpose of RIGHTMATRIX. Otherwise LEFTMATRIX is the inverse of RIGHTMATRIX. RIGHTMATRIX is the matrix the columns of which are the unit +of MAT on the diagonal. If @code{nondiagonalizable} is @code{true} these two +matrices will not be generated. If the flag @code{hermitianmatrix} is @code{true} +then @code{leftmatrix} is the complex conjugate of the transpose of +@code{rightmatrix}. Otherwise @code{leftmatrix} is the inverse of @code{rightmatrix}. +@code{rightmatrix} is the matrix the columns of which are the unit eigenvectors of MAT. The other flags (see DESCRIBE(EIGENVALUES); and DESCRIBE(EIGENVECTORS);) have the same effects since SIMILARITYTRANSFORM calls the other functions in the package in order to be able to form RIGHTMATRIX. +@code{similaritytransform} calls the other functions in the package in order +to be able to form @code{rightmatrix}. + +@code{load ("eigen")} loads this function. @code{simtran} is a synonym for @code{similaritytransform}. @end defun @defvar sparse  default: @code{false}  if @code{true} and if RATMX:TRUE then DETERMINANT +Default value: @code{false} + +When @code{sparse} is @code{true}, and if @code{ratmx} is @code{true}, then @code{determinant} will use special routines for computing sparse determinants. @end defvar @@ 1175,48 +1327,57 @@ @end defun @... transpose (m) produces the transpose of the matrix M. +@defun transpose (@var{m}) +Returns the transpose of @var{m}. + +If @var{m} is a matrix, the return value is another matrix @var{n} +such that @code{n[i,j] = m[j,i]}. + +Otherwise @var{m} is a list, and the return value is a matrix @var{n} +of @code{length (m)} rows and 1 column, such that @code{n[i,1] = m[i]}. @end defun @defun triangularize (m) produces the upper triangular form of the matrix M +Returns the upper triangular form of the matrix M which needn't be square. @end defun @defun uniteigenvectors (mat) @defunx ueivects (mat) a function in the EIGEN package. Do LOAD(EIGEN) to use it. UNITEIGENVECTORS takes a MATRIX as its +@code{uniteigenvectors} takes a matrix as its argument and returns a list of lists the first sublist of which is the output of the EIGENVALUES command and the other sublists of which are +output of the @code{eigenvalues} command and the other sublists of which are the unit eigenvectors of the matrix corresponding to those eigenvalues respectively. The flags mentioned in the description of the EIGENVECTORS command have the same effects in this one as well. In +@code{eigenvectors} command have the same effects in this one as well. In addition there is a flag which may be useful : KNOWNEIGVECTS  If set to @code{true} the EIGEN package will assume + +@code{knowneigvects}  If set to @code{true} the @code{eigen} package will assume that the eigenvectors of the matrix are known to the user and are stored under the global name LISTEIGVECTS. LISTEIGVECTS should be set to a list similar to the output of the EIGENVECTORS command. (If KNOWNEIGVECTS is set to @code{true} and the list of eigenvectors is given the setting of the flag NONDIAGONALIZABLE may not be correct. If that is +stored under the global name @code{listeigvects}. @code{listeigvects} should be set +to a list similar to the output of the @code{eigenvectors} command. (If +@code{knowneigvects} is set to @code{true} and the list of eigenvectors is given the +setting of the flag @code{nondiagonalizable} may not be correct. If that is the case please set it to the correct value. The author assumes that the user knows what he is doing and will not try to diagonalize a matrix the eigenvectors of which do not span the vector space of the appropriate dimension...) +@code{load ("eigen")} loads this function. + @code{ueivects} is a synonym for @code{uniteigenvectors}. @end defun @defun unitvector (x) @defunx uvect (x) a function in the EIGEN package. Do LOAD(EIGEN) to use it. UNITVECTOR takes a LIST as its argument and returns a unit +@code{unitvector} takes a list as its argument and returns a unit list. (i.e. a list with unit magnitude). +@code{load ("eigen")} loads this function. + @code{uvect} is a synonym for @code{unitvector}. @end defun @@ 1227,25 +1388,33 @@ expansions according to the settings of the following global flags: @example EXPANDALL, EXPANDDOT, EXPANDDOTPLUS, EXPANDCROSS, EXPANDCROSSPLUS, EXPANDCROSSCROSS, EXPANDGRAD, EXPANDGRADPLUS, EXPANDGRADPROD, EXPANDDIV, EXPANDDIVPLUS, EXPANDDIVPROD, EXPANDCURL, EXPANDCURLPLUS, EXPANDCURLCURL, EXPANDLAPLACIAN, EXPANDLAPLACIANPLUS, EXPANDLAPLACIANPROD. +expandall, expanddot, expanddotplus, expandcross, expandcrossplus, +expandcrosscross, expandgrad, expandgradplus, expandgradprod, +expanddiv, expanddivplus, expanddivprod, expandcurl, expandcurlplus, +expandcurlcurl, expandlaplacian, expandlaplacianplus, +expandlaplacianprod. @end example All these flags have default value @code{false}. The PLUS suffix refers to employing additivity or distributivity. The PROD suffix refers to the expansion for an operand that is any kind of product. EXPANDCROSSCROSS refers to replacing p~(q~r) with (p.r)*q(p.q)*r, and EXPANDCURLCURL refers to replacing CURL CURL p with GRAD DIV p + DIV + +@code{expandcrosscross} refers to replacing p~(q~r) with (p.r)*q(p.q)*r, and + +@code{expandcurlcurl} refers to replacing CURL CURL p with GRAD DIV p + DIV GRAD p. EXPANDCROSS:TRUE has the same effect as EXPANDCROSSPLUS:EXPANDCROSSCROSS:TRUE, etc. Two other flags, EXPANDPLUS and EXPANDPROD, have the same effect as setting all similarly suffixed flags true. When @code{true}, another flag named EXPANDLAPLACIANTODIVGRAD, replaces the LAPLACIAN operator with the composition DIV GRAD. All of these flags are initially @code{false}. For convenience, all of these flags have been declared EVFLAG. +EXPANDCROSSPLUS:EXPANDCROSSCROSS:TRUE, etc. + +Two other flags, +@code{expandplus} and @code{expandprod}, have the same effect as setting all +similarly suffixed flags true. + +When @code{true}, another flag named +@code{expandlaplaciantodivgrad}, replaces the Laplacian operator with the +composition DIV GRAD. + +For convenience, all of these flags have been declared @code{evflag}. + For orthogonal curvilinear coordinates, the global variables COORDINATES[[X,Y,Z]], DIMENSION[3], SF[[1,1,1]], and SFPROD[1] are set by the function invocation @@ 1253,18 +1422,51 @@ @end defun @defvar vect_cross  default:@code{false}  If @code{true} allows DIFF(X~Y,T) to work where +Default value: @code{false} + +@c WHAT DOES THIS MEAN EXACTLY ?? +When @code{vect_cross} is @code{true}, it allows DIFF(X~Y,T) to work where ~ is defined in SHARE;VECT (where VECT_CROSS is set to @code{true}, anyway.) @end defvar @... zeromatrix (m,n) takes integers m,n as arguments and returns an m by n matrix of 0's. +@defun zeromatrix (@var{m}, @var{n}) +Returns an @var{m} by @var{n} matrix, all elements of which are zero. @end defun @defvr {special symbol} "["   [ and ] are the characters which Maxima uses to delimit a list. +@code{[} and @code{]} mark the beginning and end, respectively, of a list. + +@code{[} and @code{]} also enclose the subscripts of +a list, array, hash array, or array function. + +Examples: + +@example +(%i1) x: [a, b, c]; +(%o1) [a, b, c] +(%i2) x[3]; +(%o2) c +(%i3) array (y, fixnum, 3); +(%o3) y +(%i4) y[2]: %pi; +(%o4) %pi +(%i5) y[2]; +(%o5) %pi +(%i6) z['foo]: 'bar; +(%o6) bar +(%i7) z['foo]; +(%o7) bar +(%i8) g[k] := 1/(k^2+1); + 1 +(%o8) g :=  + k 2 + k + 1 +(%i9) g[10]; + 1 +(%o9)  + 101 +@end example + @end defvr 