Screenshot instructions:
Windows
Mac
Red Hat Linux
Ubuntu
Click URL instructions:
Rightclick on ad, choose "Copy Link", then paste here →
(This may not be possible with some types of ads)
From: Robert Dodier <robert_dodier@us...>  20050227 16:43:58

Update of /cvsroot/maxima/maxima/doc/info In directory sc8prcvs1.sourceforge.net:/tmp/cvsserv12643 Modified Files: Series.texi Differentiation.texi Log Message: Change uppercase to lowercase, enclose some names in @code or @var as appropriate, adjust white space. Still needs work. Index: Series.texi =================================================================== RCS file: /cvsroot/maxima/maxima/doc/info/Series.texi,v retrieving revision 1.5 retrieving revision 1.6 diff u d r1.5 r1.6  Series.texi 5 Jan 2005 17:05:48 0000 1.5 +++ Series.texi 27 Feb 2005 16:43:47 0000 1.6 @@ 11,51 +11,48 @@ @c end concepts Series @node Definitions for Series, , Introduction to Series, Series @section Definitions for Series @... @node CAUCHYSUM @... @unnumberedsec phony @... CAUCHYSUM  default: [FALSE]  When multiplying together sums with INF as their upper limit, if SUMEXPAND is TRUE and CAUCHYSUM is set to TRUE then the Cauchy product will be used rather than the usual + +@defvar cauchysum + default: @code{false}  When multiplying together sums with @code{inf} +as their upper limit, if @code{sumexpand} is @code{true} and @code{cauchysum} is set to +@code{true} then the Cauchy product will be used rather than the usual product. In the Cauchy product the index of the inner summation is a function of the index of the outer one rather than varying independently. That is: SUM(F(I),I,0,INF)*SUM(G(J),J,0,INF) becomes SUM(SUM(F(I)*G(JI),I,0,J),J,0,INF) +independently. That is: @code{sum(f(i),i,0,inf)*sum(g(j),j,0,inf)} becomes +@code{sum(sum(f(i)*g(ji),i,0,j),j,0,inf)} @end defvar @... @node DEFTAYLOR @... @unnumberedsec phony @... DEFTAYLOR (function, exp) + +@defun deftaylor (function, exp) allows the user to define the Taylor series (about 0) of an arbitrary function of one variable as exp which may be a polynomial in that variable or which may be given implicitly as a power series using the SUM function.  In order to display the information given to DEFTAYLOR one can use POWERSERIES(F(X),X,0). (see below). +power series using the @code{sum} function. + + In order to display the information given to @code{deftaylor} one can use +@code{powerseries(f(x),x,0).} (see below). + @example (%i1) DEFTAYLOR(F(X),X**2+SUM(X**I/(2**I*I!**2),  I,4,INF)); (%o1) [F] (%i2) TAYLOR(%E**SQRT(F(X)),X,0,4); +(%i1) deftaylor(f(x),x**2+sum(x**i/(2**i*i!**2), + i,4,inf)); +(%o1) [f] +(%i2) taylor(%e**sqrt(f(x)),x,0,4); 2 3 4  X 3073 X 12817 X (%o2)/R/ 1 + X +  +  +  + . . . + x 3073 x 12817 x +(%o2)/r/ 1 + x +  +  +  + . . . 2 18432 307200   @end example + @end defun @... @node MAXTAYORDER @... @unnumberedsec phony @... MAXTAYORDER  default: [TRUE]  if TRUE, then during algebraic manipulation of (truncated) Taylor series, TAYLOR will try to retain + +@defvar maxtayorder + default: @code{true}  if @code{true,} then during algebraic +manipulation of (truncated) Taylor series, @code{taylor} will try to retain as many terms as are certain to be correct. @end defvar @... @node NICEINDICES @... @unnumberedsec phony @... NICEINDICES (expr) + +@defun niceindices (expr) will take the expression and change all the indices of sums and products to something easily understandable. It makes each index it can "I" , unless "I" is in the internal @@ 63,22 +60,20 @@ J,K,L,M,N,I0,I1,I2,I3,I4,... until it finds a legal index. @end defun @... @node NICEINDICESPREF @... @unnumberedsec phony @... NICEINDICESPREF  default: [I,J,K,L,M,N]  the list which NICEINDICES + +@defvar niceindicespref + default: [I,J,K,L,M,N]  the list which @code{niceindices} uses to find indices for sums and products. This allows the user to set the order of preference of how NICEINDICES finds the "nice indices". E.g. NICEINDICESPREF:[Q,R,S,T,INDEX]$. Then if NICEINDICES finds that it cannot use any of these as indices in a +set the order of preference of how @code{niceindices} finds the "nice +indices". E.g. @code{niceindicespref:[q,r,s,t,index]$.} Then if +@code{niceindices} finds that it cannot use any of these as indices in a particular summation, it uses the first as a base to try and tack on numbers. Here, if the list is exhausted, Q0, then Q1, etc, will be tried. @end defvar @... @node NUSUM @... @unnumberedsec phony @... NUSUM (exp,var,low,high) + +@defun nusum (exp,var,low,high) performs indefinite hypergeometric summation of exp with respect to var using a decision procedure due to R.W. Gosper. exp and the potential answer must be expressible as products of nth powers, @@ 87,7 +82,7 @@ "indefinite integration". To sum indefinitely means to give a closed form for the sum over intervals of variable length, not just e.g. 0 to inf. Thus, since there is no formula for the general partial sum of the binomial series, NUSUM can't do it. +the binomial series, @code{nusum} can't do it. @code{nusum} and @code{unsum} know a little about sums and differences of finite products. See also @code{unsum}. @@ 128,9 +123,8 @@ @end example @end defun @... @node PADE @... @unnumberedsec phony @... PADE (taylorseries,numdegbound,denomdegbound) + +@defun pade (taylorseries,numdegbound,denomdegbound) returns a list of all rational functions which have the given taylorseries expansion where the sum of the degrees of the numerator and the denominator is @@ 139,8 +133,8 @@ degree bounds. Its first argument must be a univariate taylorseries; the second and third are positive integers specifying degree bounds on the numerator and denominator. PADE's first argument can also be a Laurent series, and the degree bounds can be INF which causes all rational functions whose total +@code{pade}'s first argument can also be a Laurent series, and the degree +bounds can be @code{inf} which causes all rational functions whose total degree is less than or equal to the length of the power series to be returned. Total degree is numdegree + denomdegree. Length of a power series is "truncation level" + 1  minimum(0,"order of series"). @@ 148,19 +142,19 @@ @example (%i15) ff:taylor(1+x+x^2+x^3,x,0,3); 2 3 (%o15)/T/ 1 + X + X + X + . . . +(%o15)/t/ 1 + x + x + x + . . . (%i16) pade(ff,1,1); 1 (%o16) [ ]  X  1 (%i1) ff:taylor((83787*X^1045552*X^9187296*X^8  +387072*X^7+86016*X^61507328*X^5  +1966080*X^4+4194304*X^325165824*X^2  +67108864*X134217728) + x  1 +(%i1) ff:taylor((83787*x^1045552*x^9187296*x^8 + +387072*x^7+86016*x^61507328*x^5 + +1966080*x^4+4194304*x^325165824*x^2 + +67108864*x134217728) /134217728,x,0,10); @c EXAMPLE FAILS HERE WITH ERROR MESSAGE: !!! @c CDR: 134217728 is not a LIST !!! (%i25) PADE(ff,4,4); +(%i25) pade(ff,4,4); (%o25) [] @end example There is no rational function of degree 4 numerator/denominator, with this @@ 170,253 +164,239 @@ @example @c EXAMPLE FAILS HERE WITH ERROR MESSAGE: !!! @c CDR: 134217728 is not a LIST !!! (%i26) PADE(ff,5,5); (%o26) [(520256329*X^596719020632*X^4489651410240*X^3  1619100813312*X^2 2176885157888*X2386516803584)  /(47041365435*X^5+381702613848*X^4+1360678489152*X^3  +2856700692480*X^2  +3370143559680*X+2386516803584)]  +(%i26) pade(ff,5,5); +(%o26) [(520256329*x^596719020632*x^4489651410240*x^3 + 1619100813312*x^2 2176885157888*x2386516803584) + /(47041365435*x^5+381702613848*x^4+1360678489152*x^3 + +2856700692480*x^2 + +3370143559680*x+2386516803584)] @end example @end defun @... @node POWERDISP @... @unnumberedsec phony @... POWERDISP  default: [FALSE]  if TRUE will cause sums to be displayed + +@defvar powerdisp + default: @code{false}  if @code{true} will cause sums to be displayed with their terms in the reverse order. Thus polynomials would display as truncated power series, i.e., with the lowest power first. @end defvar @... @node POWERSERIES @... @unnumberedsec phony @... POWERSERIES (exp, var, pt) + +@defun powerseries (exp, var, pt) generates the general form of the power series expansion for exp in the variable var about the point pt (which may be INF for infinity). If POWERSERIES is unable to expand exp, the TAYLOR function may give the first several terms of the series. VERBOSE[FALSE]  if TRUE will cause comments about the progress of POWERSERIES to be printed as the execution of it proceeds. +may be @code{inf} for infinity). If @code{powerseries} is unable to expand exp, the +@code{taylor} function may give the first several terms of the series. +@code{verbose}  if @code{true} will cause comments about the progress of +@code{powerseries} to be printed as the execution of it proceeds. + @example (%i1) VERBOSE:TRUE$ (%i2) POWERSERIES(LOG(SIN(X)/X),X,0); Can't expand  LOG(SIN(X)) So we'll try again after applying the rule: +(%i1) verbose:true$ +(%i2) powerseries(log(sin(x)/x),x,0); +can't expand + log(sin(x)) +so we'll try again after applying the rule: d  /  (SIN(X))  [ dX  LOG(SIN(X)) = I  dX  ] SIN(X) + /  (sin(x)) + [ dx + log(sin(x)) = i  dx + ] sin(x) / In the first simplification we have returned: +in the first simplification we have returned: / [  I COT(X) dX  LOG(X) + i cot(x) dx  log(x) ] /  INF  ==== I1 2 I1 2 I1  \ ( 1) 2 BERN(2 I1) X + inf + ==== i1 2 i1 2 i1 + \ ( 1) 2 bern(2 i1) x >   / I1 (2 I1)! + / i1 (2 i1)! ====  I1 = 1 + i1 = 1 (%o2)  2   @end example + @end defun @... @node PSEXPAND @... @unnumberedsec phony @... PSEXPAND  default: [FALSE]  if TRUE will cause extended rational function expressions to display fully expanded. (RATEXPAND will also cause this.) If FALSE, multivariate expressions will be displayed just as in the rational function package. If PSEXPAND:MULTI, then + +@defvar psexpand + default: @code{false}  if @code{true} will cause extended rational +function expressions to display fully expanded. (@code{ratexpand} will also +cause this.) If @code{false,} multivariate expressions will be displayed +just as in the rational function package. If @code{psexpand:multi,} then terms with the same total degree in the variables are grouped together. @end defvar @... @node REVERT @... @unnumberedsec phony @... REVERT (expression,variable) + +@defun revert (expression,variable) Does reversion of Taylor Series. "Variable" is the variable the original Taylor expansion is in. Do LOAD(REVERT) to access this function. Try +@code{load(revert)} to access this function. Try @example REVERT2(expression,variable,hipower) +revert2(expression,variable,hipower) @end example  also. REVERT only works on + +also. @code{revert} only works on expansions around 0. @end defun @... @node SRRAT @... @unnumberedsec phony @... SRRAT (exp) this command has been renamed to TAYTORAT. + +@defun srrat (exp) +this command has been renamed to @code{taytorat.} @end defun @... @node TAYLOR @... @unnumberedsec phony @... TAYLOR (exp, var, pt, pow) + +@defun taylor (exp, var, pt, pow) expands the expression exp in a truncated Taylor series (or Laurent series, if required) in the variable var around the point pt. The terms through (varpt)**pow are generated. If exp is of the form f(var)/g(var) and g(var) has no terms up to degree pow then TAYLOR will try to expand g(var) up to degree 2*pow. If there are still no nonzero terms TAYLOR will keep doubling the +degree pow then @code{taylor} will try to expand g(var) up to degree 2*pow. +If there are still no nonzero terms @code{taylor} will keep doubling the degree of the expansion of g(var) until reaching pow*2**n where n is the value of the variable TAYLORDEPTH[3]. If MAXTAYORDER[FALSE] is set to TRUE, then during algebraic manipulation of (truncated) Taylor series, TAYLOR will try to retain as many terms as are certain to be correct. Do EXAMPLE(TAYLOR); for examples. TAYLOR(exp,[var1,pt1,ord1],[var2,pt2,ord2],...) returns a truncated +the value of the variable @code{taylordepth} [3]. If @code{maxtayorder} [FALSE] is +set to @code{true,} then during algebraic manipulation of (truncated) Taylor +series, @code{taylor} will try to retain as many terms as are certain to be +correct. Do @code{example(taylor);} for examples. + +@code{taylor(exp,[var1,pt1,ord1],[var2,pt2,ord2],...)} returns a truncated power series in the variables vari about the points pti, truncated at ordi. PSEXPAND[FALSE] if TRUE will cause extended rational function expressions to display fully expanded. (RATEXPAND will also cause this.) If FALSE, multivariate expressions will be displayed just as in the rational function package. If PSEXPAND:MULTI, then terms with the + +@code{psexpand} [FALSE] if @code{true} will cause extended rational function +expressions to display fully expanded. (@code{ratexpand} will also cause +this.) If @code{false,} multivariate expressions will be displayed just as in +the rational function package. If @code{psexpand:multi,} then terms with the same total degree in the variables are grouped together. TAYLOR(exp, [var1, var2, . . .], pt, ord) where each of pt and ord + +@code{taylor(exp, [var1, var2, . . .], pt, ord)} where each of pt and ord may be replaced by a list which will correspond to the list of variables. that is, the nth items on each of the lists will be associated together. TAYLOR(exp, [x,pt,ord,ASYMP]) will give an expansion of exp in + +@code{taylor(exp, [x,pt,ord,ASYMP])} will give an expansion of exp in negative powers of (xpt). The highest order term will be (xpt)^(ord). The ASYMP is a syntactic device and not to be assigned to. See also the TAYLOR_LOGEXPAND switch for controlling expansion. +The @code{asymp} is a syntactic device and not to be assigned to. +See also the @code{taylor_logexpand} switch for controlling expansion. @end defun @... @node TAYLORDEPTH @... @unnumberedsec phony @... TAYLORDEPTH + +@defvar taylordepth default: [3]  If there are still no nonzero terms TAYLOR will keep doubling the degree of the expansion of g(var) until reaching pow*2**n where n is the value of the variable TAYLORDEPTH[3]. +@code{taylor} will keep doubling the degree of the expansion of g(var) until +reaching pow*2**n where n is the value of the variable @code{taylordepth} [3]. @end defvar @... @node TAYLORINFO @... @unnumberedsec phony @... TAYLORINFO (exp) returns FALSE if exp is not a Taylor series. + +@defun taylorinfo (exp) +returns @code{false} if exp is not a Taylor series. Otherwise, a list of lists is returned describing the particulars of the Taylor expansion. For example, + @example (%i3) TAYLOR((1Y^2)/(1X),X,0,3,[Y,A,INF]); +(%i3) taylor((1y^2)/(1x),x,0,3,[y,a,inf]); 2 2 (%o3)/R/ 1  A  2 A (Y  A)  (Y  A) +(%o3)/r/ 1  a  2 a (y  a)  (y  a) 2 2  + (1  A  2 A (Y  A)  (Y  A) ) X + + (1  a  2 a (y  a)  (y  a) ) x 2 2 2  + (1  A  2 A (Y  A)  (Y  A) ) X + + (1  a  2 a (y  a)  (y  a) ) x 2 2 3  + (1  A  2 A (Y  A)  (Y  A) ) X + + (1  a  2 a (y  a)  (y  a) ) x + . . . (%i4) TAYLORINFO(%o3); (%o4) [[Y, A, INF], [X, 0, 3]]   +(%i4) taylorinfo(%o3); +(%o4) [[y, a, inf], [x, 0, 3]] @end example + @end defun @... @node TAYLORP @... @unnumberedsec phony @... TAYLORP (exp) a predicate function which returns TRUE if and only if + +@defun taylorp (exp) +a predicate function which returns @code{true} if and only if the expression 'exp' is in Taylor series representation. @end defun @... @node TAYLOR_LOGEXPAND @... @unnumberedsec phony @... TAYLOR_LOGEXPAND  default: [TRUE] controls expansions of logarithms in TAYLOR series. When TRUE all log's are expanded fully so that + +@defvar taylor_logexpand + default: @code{true} controls expansions of logarithms in +@code{taylor} series. When @code{true} all log's are expanded fully so that zerorecognition problems involving logarithmic identities do not disturb the expansion process. However, this scheme is not always mathematically correct since it ignores branch information. If TAYLOR_LOGEXPAND is set to FALSE, then the only expansion of log's +@code{taylor_logexpand} is set to @code{false,} then the only expansion of log's that will occur is that necessary to obtain a formal power series. @end defvar @... @node TAYLOR_ORDER_COEFFICIENTS @... @unnumberedsec phony @... TAYLOR_ORDER_COEFFICIENTS  default: [TRUE] controls the ordering of coefficients in the expression. The default (TRUE) is that + +@defvar taylor_order_coefficients + default: @code{true} controls the ordering of +coefficients in the expression. The default @code{true} is that coefficients of taylor series will be ordered canonically. @end defvar @... @node TAYLOR_SIMPLIFIER @... @unnumberedsec phony @... TAYLOR_SIMPLIFIER   A function of one argument which TAYLOR uses to + +@defun taylor_simplifier +  A function of one argument which @code{taylor} uses to simplify coefficients of power series. @end defun @... @node TAYLOR_TRUNCATE_POLYNOMIALS @... @unnumberedsec phony @... TAYLOR_TRUNCATE_POLYNOMIALS  default: [TRUE] When FALSE polynomials input to TAYLOR are considered to have infinite precison; otherwise + +@defvar taylor_truncate_polynomials + default: @code{true} When @code{false} polynomials +input to @code{taylor} are considered to have infinite precison; otherwise (the default) they are truncated based upon the input truncation levels. @end defvar @... @node TAYTORAT @... @unnumberedsec phony @... TAYTORAT (exp) converts exp from TAYLOR form to CRE form, i.e. it is like RAT(RATDISREP(exp)) although much faster. + +@defun taytorat (exp) +converts exp from @code{taylor} form to CRE form, i.e. it is +like @code{rat(ratdisrep(exp))} although much faster. @end defun @... @node TRUNC @... @unnumberedsec phony @... TRUNC (exp) + +@defun trunc (exp) causes exp which is in general representation to be displayed as if its sums were truncated Taylor series. E.g. compare EXP1:X^2+X+1; with EXP2:TRUNC(X^2+X+1); . Note that IS(EXP1=EXP2); gives TRUE. +@code{exp1:x^2+x+1;} with @code{exp2:trunc(x^2+x+1);} . Note that @code{is(exp1=exp2);} +gives @code{true.} @end defun @... @node UNSUM @... @unnumberedsec phony @... UNSUM (fun,n) + +@defun unsum (fun,n) is the first backward difference fun(n)  fun(n1). Thus @code{unsum} in a sense is the inverse of @code{sum}. See also @code{nusum}. @example (%i1) G(P):=P*4^N/BINOMIAL(2*N,N);  N  P 4 (%o1) G(P) :=   BINOMIAL(2 N, N) (%i2) G(N^4);  4 N  N 4 +(%i1) g(p):=p*4^n/binomial(2*n,n); + n + p 4 +(%o1) g(p) :=  + binomial(2 n, n) +(%i2) g(n^4); + 4 n + n 4 (%o2)   BINOMIAL(2 N, N) (%i3) NUSUM(%o2,N,0,N);  4 3 2 N  2 (N + 1) (63 N + 112 N + 18 N  22 N + 3) 4 2 + binomial(2 n, n) +(%i3) nusum(%o2,n,0,n); + 4 3 2 n + 2 (n + 1) (63 n + 112 n + 18 n  22 n + 3) 4 2 (%o3)     693 BINOMIAL(2 N, N) 3 11 7 (%i4) UNSUM(%,N);  4 N  N 4 + 693 binomial(2 n, n) 3 11 7 +(%i4) unsum(%,n); + 4 n + n 4 (%o4)   BINOMIAL(2 N, N)   + binomial(2 n, n) @end example + @end defun @... @node VERBOSE @... @unnumberedsec phony @... VERBOSE  default: [FALSE]  if TRUE will cause comments about the progress of POWERSERIES to be printed as the execution of it proceeds. + +@defvar verbose + default: @code{false}  if @code{true} will cause comments about the +progress of @code{powerseries} to be printed as the execution of it proceeds. @end defvar Index: Differentiation.texi =================================================================== RCS file: /cvsroot/maxima/maxima/doc/info/Differentiation.texi,v retrieving revision 1.11 retrieving revision 1.12 diff u d r1.11 r1.12  Differentiation.texi 11 Dec 2004 16:00:41 0000 1.11 +++ Differentiation.texi 27 Feb 2005 16:43:47 0000 1.12 @@ 6,63 +6,63 @@ @node Definitions for Differentiation, , Differentiation, Differentiation @section Definitions for Differentiation @... @node ANTID, ANTIDIFF, Differentiation, Differentiation @... @unnumberedsec phony @... ANTID (G,X,U(X)) + +@defun antid (@var{g}, @var{x}, @var{u(x)}) A routine for evaluating integrals of expressions involving an arbitrary unspecified function and its derivatives. It may be used by LOAD(ANTID); , after which, the function ANTIDIFF may be used. E.g. ANTIDIFF(G,X,U(X)); where G is the expression involving U(X) +by @code{load(antid)} , after which, the function @code{antidiff} may be used. +E.g. @code{antidiff(g,x,u(x))} where G is the expression involving U(X) (U(X) arbitrary) and its derivatives, whose integral with respect to X is desired. The functions NONZEROANDFREEOF and LINEAR are also defined, as well as ANTID. ANTID is the same as ANTIDIFF except that it returns a list of + +The functions @code{nonzeroandfreeof} and @code{linear} are also defined, as well as +@code{antid}. @code{antid} is the same as @code{antidiff} except that it returns a list of two parts, the first part is the integrated part of the expression and the second part of the list is the nonintegrable remainder. @end defun @... @node ANTIDIFF, property, ANTID, Differentiation @... @unnumberedsec phony @... ANTIDIFF  See ANTID. + +@defun antidiff  +See @code{antid}. @end defun @... @node property, ATVALUE, ANTIDIFF, Differentiation @... @unnumberedsec phony @... property ATOMGRAD + +@defvr property atomgrad  the atomic gradient property of an expression. May be set by GRADEF. +May be set by @code{gradef}. @end defvr @... @node ATVALUE, CARTAN, property, Differentiation @... @unnumberedsec phony @... ATVALUE (form, list, value) + +@defun atvalue (@var{form}, @var{list}, @var{value}) enables the user to assign the boundary value value to form at the points specified by list. @... (%i1) ATVALUE(F(X,Y),[X=0,Y=1],A**2)$  The form must be a function, f(v1,v2,...), or a derivative, +@example +(%i1) atvalue(f(x,y),[x=0,y=1],a**2)$ @end example DIFF(f(v1,v2,...),vi,ni,vj,nj,...) in which the functional arguments + +The form must be a function, f(v1,v2,...), or a derivative, +@code{diff(f(v1,v2,...),vi,ni,vj,nj,...)} in which the functional arguments explicitly appear (ni is the order of differentiation with respect vi).  The list of equations determine the "boundary" at which the value + +The list of equations determine the "boundary" at which the value is given; list may be a list of equations, as above, or a single equation, vi = expr.  The symbols @@1, @@2,... will be used to represent the functional + +The symbols @@1, @@2,... will be used to represent the functional variables v1,v2,... when atvalues are displayed.  PRINTPROPS([f1, f2,...], ATVALUE) will display the atvalues of + +@code{printprops([f1, f2,...], atvalue)} will display the atvalues of the functions f1,f2,... as specified in previously given uses of the ATVALUE function. If the list contains just one element then the +@code{atvalue} function. If the list contains just one element then the element can be given without being in a list. If a first argument of ALL is given then atvalues for all functions which have them will be displayed. Do EXAMPLE(ATVALUE); for an example. +@code{all} is given then atvalues for all functions which have them will be +displayed. Do @code{example(atvalue)} for an example. @end defun @... @node CARTAN, DELTA, ATVALUE, Differentiation @... @unnumberedsec phony @... CARTAN  + +@defun cartan  The exterior calculus of differential forms is a basic tool of differential geometry developed by Elie Cartan and has important applications in the theory of partial differential equations. The @@ 73,10 +73,12 @@ description of these commands along with examples. @end defun @... DEL (v) + +@defun del (@var{v}) This is the differential of the variable @math{v}. This commonly occurs when DIFF is called without the dependent variable being given. Then +when @code{diff} is called without the dependent variable being given. Then the differential of the expression is computed. For example: + @example (%i1) diff (x); (%o1) del(x) @@ 88,309 +90,325 @@ @end example @end defun @... @node DELTA, DEPENDENCIES, CARTAN, Differentiation @... @unnumberedsec phony @... DELTA (t) This is the Dirac Delta function. Currently only LAPLACE knows about the DELTA function: @... (%i1) LAPLACE(DELTA(TA)*SIN(B*T),T,S); Is A positive, negative or zero? POS;   A S (%o1) SIN(A B) %E +@defun delta (@var{t}) +This is the Dirac Delta function. Currently only @code{laplace} +knows about the @code{delta} function: +@example +(%i1) laplace(delta(ta)*sin(b*t),t,s); +is a positive, negative or zero? +pos; +  a s +(%o1) sin(a b) %e @end example + @end defun @... @node DEPENDENCIES, DEPENDS, DELTA, Differentiation @... @unnumberedsec phony @... DEPENDENCIES + +@defvar dependencies default: []  the list of atoms which have functional dependencies (set up by the DEPENDS or GRADEF functions). The command DEPENDENCIES has been replaced by the DEPENDS command. Do DESCRIBE(DEPENDS); +dependencies (set up by the @code{depends} or @code{gradef} functions). The command +@code{dependencies} has been replaced by the @code{depends} command. Do +@code{describe(depends)} @end defvar @... @node DEPENDS, DERIVABBREV, DEPENDENCIES, Differentiation @... @unnumberedsec phony @... DEPENDS (funlist1,varlist1,funlist2,varlist2,...) + +@defun depends (@var{funlist1}, @var{varlist1}, @var{funlist2}, @var{varlist2}, ...) declares functional dependencies for variables to be used by DIFF. +dependencies for variables to be used by @code{diff}. @example DEPENDS([F,G],[X,Y],[R,S],[U,V,W],U,T) +depends([f,g],[x,y],[r,s],[u,v,w],u,t) @end example informs DIFF that F and G + +informs @code{diff} that F and G depend on X and Y, that R and S depend on U,V, and W, and that U depends on T. The arguments to DEPENDS are evaluated. The variables +depends on T. The arguments to @code{depends} are evaluated. The variables in each funlist are declared to depend on all the variables in the next varlist. A funlist can contain the name of an atomic variable or array. In the latter case, it is assumed that all the elements of the array depend on all the variables in the succeeding varlist. Initially, DIFF(F,X) is 0; executing DEPENDS(F,X) causes future +Initially, @code{diff(f,x)} is 0; executing @code{depends(f,x)} causes future differentiations of F with respect to X to give dF/dX or Y (if DERIVABBREV:TRUE). +@code{derivabbrev:true)}. + @example (%i1) DEPENDS([F,G],[X,Y],[R,S],[U,V,W],U,T); (%o1) [F(X, Y), G(X, Y), R(U, V, W), S(U, V, W), U(T)] (%i2) DEPENDENCIES; (%o2) [F(X, Y), G(X, Y), R(U, V, W), S(U, V, W), U(T)] (%i3) DIFF(R.S,U);  dR dS (%o3)  . S + R .   dU dU +(%i1) depends([f,g],[x,y],[r,s],[u,v,w],u,t); +(%o1) [f(x, y), g(x, y), r(u, v, w), s(u, v, w), u(t)] +(%i2) dependencies; +(%o2) [f(x, y), g(x, y), r(u, v, w), s(u, v, w), u(t)] +(%i3) diff(r.s,u); + dr ds +(%o3)  . s + r .  + du du @end example + Since Maxima knows the chain rule for symbolic derivatives, it takes advantage of the given dependencies as follows: + @example (%i4) DIFF(R.S,T);  dR dU dS dU (%o4) ( ) . S + R . ( )  dU dT dU dT If we set (%i5) DERIVABBREV:TRUE; (%o5) TRUE +(%i4) diff(r.s,t); + dr du ds du +(%o4) ( ) . s + r . ( ) + du dt du dt +if we set +(%i5) derivabbrev:true; +(%o5) true +@end example + then reexecuting the command %i4, we obtain + +@example (%i6) '@w{}'%i4; (%o6) (R U ) . S + R . (S U )  U T U T +(%o6) (r u ) . s + r . (s u ) + u t u t @end example To eliminate a previously declared dependency, the REMOVE command can + +To eliminate a previously declared dependency, the @code{remove} command can be used. For example, to say that R no longer depends on U as declared in %i1, the user can type + @example REMOVE(R,DEPENDENCY) +remove(r,dependency) @end example + This will eliminate all dependencies that may have been declared for R. + @example (%i7) REMOVE(R,DEPENDENCY); (%o7) DONE +(%i7) remove(r,dependency); +(%o7) done (%i8) '@w{}'%i4; (%o8) R . (S U )  U T  +(%o8) r . (s u ) + u t @end example CAVEAT: DIFF is the only Maxima command which uses DEPENDENCIES information. The arguments to INTEGRATE, LAPLACE, etc. must be given their dependencies explicitly in the command, e.g., INTEGRATE(F(X),X). + +CAVEAT: @code{diff} is the only Maxima command which uses @code{dependencies} +information. The arguments to @code{integrate}, @code{laplace}, etc. must be given +their dependencies explicitly in the command, e.g., @code{integrate(f(x),x)}. @end defun @... @node DERIVABBREV, DERIVDEGREE, DEPENDS, Differentiation @... @unnumberedsec phony @... DERIVABBREV  default: [FALSE] if TRUE will cause derivatives to + +@defvar derivabbrev + default: @code{false} if @code{true} will cause derivatives to display as subscripts. @end defvar @... @node DERIVDEGREE, DERIVLIST, DERIVABBREV, Differentiation @... @unnumberedsec phony @... DERIVDEGREE (exp, dv, iv) + +@defun derivdegree (@var{expr}, @var{dv}, @var{iv}) finds the highest degree of the derivative of the dependent variable dv with respect to the independent variable iv occuring in exp. + @example (%i1) 'DIFF(Y,X,2)+'DIFF(Y,Z,3)*2+'DIFF(Y,X)*X**2$ (%i2) DERIVDEGREE(%,Y,X); +(%i1) 'diff(y,x,2)+'diff(y,z,3)*2+'diff(y,x)*x**2$ +(%i2) derivdegree(%,y,x); (%o2) 2   @end example + @end defun @... @node DERIVLIST, DERIVSUBST, DERIVDEGREE, Differentiation @... @unnumberedsec phony @... DERIVLIST (var1,...,vark) + +@defun derivlist (@var{var_1}, ..., @var{var_k}) causes only differentiations with respect to the indicated variables, within the EV command. +the indicated variables, within the @code{ev} command. @end defun @... @node DERIVSUBST, {special symbol}, DERIVLIST, Differentiation @... @unnumberedsec phony @... DERIVSUBST  default: [FALSE]  controls nonsyntactic substitutions + +@defvar derivsubst + default: @code{false}  controls nonsyntactic substitutions such as + @example SUBST(X,'DIFF(Y,T),'DIFF(Y,T,2)); +subst(x,'diff(y,t),'diff(y,t,2)); @end example If DERIVSUBST is set to true, this gives 'DIFF(X,T). + +If @code{derivsubst} is set to +true, this gives @code{'diff(x,t)}. @end defvar @... @node DIFF, DSCALAR, {special symbol}, Differentiation @... @unnumberedsec phony @... DIFF (exp, v1, n1, v2, n2, ...) DIFF differentiates exp with respect to + +@defun diff (@var{expr}, @var{v1}, @var{n1}, @var{v2}, @var{n2}, ...) +@code{diff} differentiates exp with respect to each vi, ni times. If just the first derivative with respect to one variable is desired then the form DIFF(exp,v) may be used. If the +variable is desired then the form @code{diff(exp,v)} may be used. If the noun form of the function is required (as, for example, when writing a differential equation), 'DIFF should be used and this will display in +differential equation), @code{'diff} should be used and this will display in a two dimensional format. DERIVABBREV[FALSE] if TRUE will cause derivatives to display as + +@code{derivabbrev} if @code{true} will cause derivatives to display as subscripts. DIFF(exp) gives the "total differential", that is, the sum of the + +@code{diff(exp)} gives the "total differential", that is, the sum of the derivatives of exp with respect to each of its variables times the function DEL of the variable. No further simplification of DEL is +function @code{del} of the variable. No further simplification of @code{del} is offered. + @example (%i1) DIFF(EXP(F(X)),X,2); +(%i1) diff(exp(f(x)),x,2); 2  F(X) d F(X) d 2 (%o1) %E ( F(X)) + %E ( (F(X)))  2 dX  dX (%i2) DERIVABBREV:TRUE$ (%i3) 'INTEGRATE(F(X,Y),Y,G(X),H(X));  H(X) + f(x) d f(x) d 2 +(%o1) %e ( f(x)) + %e ( (f(x))) + 2 dx + dx +(%i2) derivabbrev:true$ +(%i3) 'integrate(f(x,y),y,g(x),h(x)); + h(x) / [ (%o3) I F(X, Y) dY +(%o3) i f(x, y) dy ] /  G(X) (%i4) DIFF(%,X);  H(X) + g(x) +(%i4) diff(%,x); + h(x) / [ (%o4) I F(X, Y) dY + F(X, H(X)) H(X)  F(X, G(X)) G(X)  ] X X X +(%o4) i f(x, y) dy + f(x, h(x)) h(x)  f(x, g(x)) g(x) + ] x x x /  G(X)  + g(x) @end example + For the tensor package, the following modifications have been incorporated: + 1) the derivatives of any indexed objects in exp will have the variables vi appended as additional arguments. Then all the derivative indices will be sorted. + 2) the vi may be integers from 1 up to the value of the variable DIMENSION[default value: 4]. This will cause the differentiation to be carried out wrt the vith member of the list COORDINATES which +@code{dimension} [default value: 4]. This will cause the differentiation to +be carried out wrt the vith member of the list @code{coordinates} which should be set to a list of the names of the coordinates, e.g., [x,y,z,t]. If COORDINATES is bound to an atomic variable, then that +[x,y,z,t]. If @code{coordinates} is bound to an atomic variable, then that variable subscripted by vi will be used for the variable of differentiation. This permits an array of coordinate names or subscripted names like X[1], X[2],... to be used. If COORDINATES has +subscripted names like X[1], X[2],... to be used. If @code{coordinates} has not been assigned a value, then the variables will be treated as in 1) above. @end defun @... @node DIFF @... @unnumberedsec phony @... {special symbol} DIFF + +@defvr {special symbol} diff [flag] for ev causes all differentiations indicated in exp to be performed. @end defvr @... @node DSCALAR, EXPRESS, DIFF, Differentiation @... @unnumberedsec phony @... DSCALAR (function) + +@defun dscalar (@var{function}) applies the scalar d'Alembertian to the scalar function. + @example (%i41) DEPENDENCIES(FIELD(R)); (%o41) [FIELD(R)] (%i42) DSCALAR(FIELD); +(%i41) dependencies(field(r)); +(%o41) [field(r)] +(%i42) dscalar(field); (%o43)  M  %E ((FIELD N  FIELD M + 2 FIELD ) R + 4 FIELD )  R R R R R R R + m + %e ((field n  field m + 2 field ) r + 4 field ) + r r r r r r r    2 R  + 2 r @end example + @end defun @... @node EXPRESS, GENDIFF, DSCALAR, Differentiation @... @unnumberedsec phony @... EXPRESS (expression) + +@defun express (@var{expr}) The result uses the noun form of any derivatives arising from expansion of the vector differential operators. To force evaluation of these derivatives, the builtin EV function can be used together with the DIFF evflag, after using the builtin DEPENDS function to establish any new implicit dependencies. +operators. To force evaluation of these derivatives, the builtin @code{ev} +function can be used together with the @code{diff} evflag, after using the +builtin @code{depends} function to establish any new implicit dependencies. @end defun @... @node GENDIFF, GRADEF, EXPRESS, Differentiation @... @unnumberedsec phony @... GENDIFF Sometimes DIFF(E,X,N) can be reduced even though N is + +@defun gendiff +Sometimes @code{diff(e,x,n)} can be reduced even though N is symbolic. + @example batch("gendif")$ @end example + and you can try, for example, @example DIFF(%E^(A*X),X,Q) +diff(%e^(a*x),x,q) @end example by using GENDIFF rather than DIFF. Unevaluable items come out quoted. Some items are in terms of "GENFACT", which + +by using @code{gendiff} rather than @code{diff}. Unevaluable +items come out quoted. Some items are in terms of @code{genfact}, which see. @end defun @... @node GRADEF, GRADEFS, GENDIFF, Differentiation @... @unnumberedsec phony @... GRADEF (f(x1, ..., xn), g1, ..., gn) + +@defun gradef (@var{f(x1, ..., xn)}, @var{g_1}, ..., @var{g_n}) defines the derivatives of the function f with respect to its n arguments. That is, df/dxi = gi, etc. If fewer than n gradients, say i, are given, then they refer to the first i arguments of f. The xi are merely dummy variables as in function definition headers and are used to indicate the ith argument of f. All arguments to GRADEF except the first are evaluated so that +of f. All arguments to @code{gradef} except the first are evaluated so that if g is a defined function then it is invoked and the result is used. +It is not permissible to use @code{gradef} on subscripted functions. + Gradients are needed when, for example, a function is not known explicitly but its first derivatives are and it is desired to obtain higher order derivatives. GRADEF may also be used to redefine the +higher order derivatives. + +@code{gradef} may also be used to redefine the derivatives of Maxima's predefined functions (e.g. GRADEF(SIN(X),SQRT(1SIN(X)**2)) ). It is not permissible to use GRADEF on subscripted functions. GRADEFS is a list of the functions which have been given gradients by use of the GRADEF command (i.e. GRADEF(f(x1, ..., xn), g1, ..., gn)). PRINTPROPS([f1,f2,...],GRADEF) may be used to display the gradefs of +@code{gradef(sin(x),sqrt(1sin(x)**2)))} . + +@code{gradefs} is a list of the functions which have been given gradients by +use of the @code{gradef} command (i.e. @code{gradef(f(x1,...,xn),g1, ..., gn))} . + +@code{printprops([f1,f2,...],gradef)} may be used to display the gradefs of the functions f1,f2,.. GRADEF(a,v,exp) may be used to state that the derivative of the atomic + +@code{gradef(a,v,exp)} may be used to state that the derivative of the atomic variable a with respect to v is exp. This automatically does a DEPENDS(a,v). PRINTPROPS([a1,a2,...],ATOMGRAD) may be used to display the atomic +@code{depends(a,v)}. + +@code{printprops([a1,a2,...],atomgrad)} may be used to display the atomic gradient properties of a1,a2,... @end defun @... @node GRADEFS, LAPLACE, GRADEF, Differentiation @... @unnumberedsec phony @... GRADEFS + +@defvar gradefs default: []  a list of the functions which have been given gradients by use of the GRADEF command (i.e. GRADEF(f(x1, ..., xn), g1, ..., gn).) +gradients by use of the @code{gradef} command (i.e. @code{gradef(f(x1, ..., xn), g1, ..., gn)}.) @end defvar @... @node LAPLACE, GRADEFS, Differentiation @... @unnumberedsec phony @... LAPLACE (exp, ovar, lvar) + +@defun laplace (@var{expr}, @var{ovar}, @var{lvar}) takes the Laplace transform of exp with respect to the variable ovar and transform parameter lvar. Exp may only involve the functions EXP, LOG, SIN, COS, SINH, COSH, and ERF. +respect to the variable ovar and transform parameter lvar. + +@var{expr} may +only involve the functions @code{exp}, @code{log}, @code{sin}, @code{cos}, @code{sinh}, @code{cosh}, and @code{erf}. It may also be a linear, constant coefficient differential equation in which case ATVALUE of the dependent variable will be used. These may +which case @code{atvalue} of the dependent variable will be used. These may be supplied either before or after the transform is taken. Since the initial conditions must be specified at zero, if one has boundary conditions imposed elsewhere he can impose these on the general solution and eliminate the constants by solving the general solution for them and substituting their values back. Exp may also involve convolution integrals. Functional relationships must be explicitly represented in order for LAPLACE to work properly. That is, if F +represented in order for @code{laplace} to work properly. That is, if F depends on X and Y it must be written as F(X,Y) wherever F occurs as in LAPLACE('DIFF(F(X,Y),X),X,S). LAPLACE is not affected by DEPENDENCIES set up with the DEPENDS command. +in @code{laplace('diff(f(x,y),x),x,s)}. @code{laplace} is not affected by @code{dependencies} +set up with the @code{depends} command. + @example (%i1) LAPLACE(%E**(2*T+A)*SIN(T)*T,T,S);  A  2 %E (S  2) +(%i1) laplace(%e**(2*t+a)*sin(t)*t,t,s); + a + 2 %e (s  2) (%o1)  2 2  ((S  2) + 1)   + ((s  2) + 1) @end example + @end defun 