[Maxima-commits] CVS: maxima/doc/info Constants.texi,1.5,1.6 Limits.texi,1.3,1.4 Lists.texi,1.11,1.12 Logarithms.texi,1.4,1.5

[Vadim V. Z. <vv...@us...>]

Update of /cvsroot/maxima/maxima/doc/info
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv7418

Modified Files:
	Constants.texi Limits.texi Lists.texi Logarithms.texi 
Log Message:
Update according to new Maxima .texi conventions


Index: Constants.texi
===================================================================
RCS file: /cvsroot/maxima/maxima/doc/info/Constants.texi,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- Constants.texi	21 Nov 2004 17:31:53 -0000	1.5
+++ Constants.texi	2 Dec 2004 19:19:40 -0000	1.6
@@ -1,49 +1,42 @@
-@c end concepts Constants
+
 @menu
 * Definitions for Constants::   
 @end menu
 
 @node Definitions for Constants,  , Constants, Constants
 @section Definitions for Constants
-@c @node e
-@c @unnumberedsec phony
+
 @defvar %e
  - The base of natural logarithms, e, is represented in Maxima
 as @code{%e}.
 
 @end defvar
-@c @node false
-@c @unnumberedsec phony
+
 @defvar false
  - the Boolean constant, false. (NIL in Lisp)
 
 @end defvar
-@c @node inf
-@c @unnumberedsec phony
+
 @defvar %inf
  - real positive infinity.
 
 @end defvar
-@c @node infinity
-@c @unnumberedsec phony
+
 @defvar %infinity
  - complex infinity.
 
 @end defvar
-@c @node minf
-@c @unnumberedsec phony
+
 @defvar %minf
  - real minus infinity.
 
 @end defvar
-@c @node pi
-@c @unnumberedsec phony
+
 @defvar pi
  - "pi" is represented in Maxima as @code{%pi}.
 
 @end defvar
-@c @node true
-@c @unnumberedsec phony
+
 @defvar true
  - the Boolean constant, true. (T in Lisp)
 

Index: Limits.texi
===================================================================
RCS file: /cvsroot/maxima/maxima/doc/info/Limits.texi,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- Limits.texi	21 Nov 2004 10:11:21 -0000	1.3
+++ Limits.texi	2 Dec 2004 19:19:40 -0000	1.4
@@ -1,23 +1,23 @@
-@c end concepts Limits
+
 @menu
 * Definitions for Limits::      
 @end menu
 
 @node Definitions for Limits,  , Limits, Limits
 @section Definitions for Limits
-@c @node lhospitallim
-@c @unnumberedsec phony
+
 @defvar lhospitallim
- default: @code{[4]} - the maximum number of times L'Hospital's
+ default: 4 - the maximum number of times L'Hospital's
 rule is used in @code{limit}.  This prevents infinite looping in cases like
 @code{limit(cot(x)/csc(x),x,0)}.
 
 @end defvar
-@c @node limit
-@c @unnumberedsec phony
+
 @defun limit (exp, var, val, dir)
+@defunx limit (exp, var, val)
+@defunx limit (exp)
 finds the limit of @code{exp} as the real variable
-@code{var} approaches the value @code{val} from the direction @code{dir}.  @code{Dir} may have the
+@code{var} approaches the value @code{val} from the direction @code{dir}.  @code{dir} may have the
 value @code{plus} for a limit from above, @code{minus} for a limit from below, or
 may be omitted (implying a two-sided limit is to be computed).  For
 the method see Wang, P., "Evaluation of Definite Integrals by Symbolic
@@ -25,40 +25,44 @@
 following special symbols: @code{inf} (positive infinity) and @code{minf} (negative
 infinity).  On output it may also use @code{und} (undefined), @code{ind} (indefinite
 but bounded) and @code{infinity} (complex infinity).
-@code{lhospitallim[4]} is the maximum number of times L'Hospital's rule
+
+@code{lhospitallim} is the maximum number of times L'Hospital's rule
 is used in @code{limit}.  This prevents infinite looping in cases like
 @code{limit(cot(x)/csc(x),x,0)}.
-@code{tlimswitch[false]} when true will cause the limit package to use
+
+@code{tlimswitch} when true will cause the limit package to use
 Taylor series when possible.
-@code{limsubst[false]} prevents @code{limit} from attempting substitutions on
+
+@code{limsubst} prevents @code{limit} from attempting substitutions on
 unknown forms.  This is to avoid bugs like @code{limit(f(n)/f(n+1),n,inf);}
-giving 1.  Setting @code{limsubst} to @code{true} will allow such substitutions.
-Since @code{limit} is often called upon to simplify constant expressions,
-for example, @code{inf-1}, @code{limit} may be used in such cases with only one
-argument, e.g. @code{limit(inf-1);}
+giving 1.  Setting @code{limsubst} to @code{true} will allow such
+substitutions.
+
+@code{limit} with one argument is often called upon to simplify constant expressions,
+for example, @code{limit(inf-1);} .
+
 Do @code{example(limit);} for examples.
 
 @end defun
-@c @node limsubst
-@c @unnumberedsec phony
+
 @defvar limsubst
-default: @code{[false]} prevents @code{limit} from attempting substitutions on
+default value: @code{false} - prevents @code{limit} from attempting substitutions on
 unknown forms.  This is to avoid bugs like @code{limit(f(n)/f(n+1),n,inf);}
 giving 1.  Setting @code{limsubst} to @code{true} will allow such
 substitutions.
 
 @end defvar
-@c @node tlimit
-@c @unnumberedsec phony
-@defun tlimit (exp,var,val,dir)
+
+@defun tlimit (exp, var, val, dir)
+@defunx tlimit (exp, var, val)
+@defunx tlimit (exp)
 is just the function @code{limit} with @code{tlimswitch}
 set to @code{true}.
 
 @end defun
-@c @node tlimswitch
-@c @unnumberedsec phony
+
 @defvar tlimswitch
- default: @code{[false]} - if true will cause the limit package to
+default: @code{false} - if @code{true} will cause the limit package to
 use Taylor series when possible.
 
 @end defvar

Index: Lists.texi
===================================================================
RCS file: /cvsroot/maxima/maxima/doc/info/Lists.texi,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- Lists.texi	28 Nov 2004 17:20:14 -0000	1.11
+++ Lists.texi	2 Dec 2004 19:19:40 -0000	1.12
@@ -32,25 +32,24 @@
 @end example
 
 
-@c end concepts Lists
 
 @node Definitions for Lists,  , Introduction to Lists, Lists
 @section Definitions for Lists
 
-@c @node append, assoc, Lists, Lists
-@c @unnumberedsec 
 @defun append (list1, list2, ...)
-returns a single list of the elements of
-@code{list1} followed by the elements of @code{list2},...  APPEND also works on
-general expressions, e.g. @code{append(F(A,B), F(C,D,E)); -> F(A,B,C,D,E)}.
+returns a single list of the elements of @code{list1} followed 
+by the elements of @code{list2},...  @code{append} also works on
+general expressions, e.g. @code{append(f(a,b), f(c,d,e));} -> 
+@code{f(a,b,c,d,e)}.
+
 Do @code{example(append);} for an example.
 
 @end defun
-@c @node assoc, atom, append, Lists
-@c @unnumberedsec 
+
 @defun assoc (key, list, default)
+@defunx assoc (key, list)
 This function searches for the @code{key} in the left hand side of the input @code{list}
-of the form @code{[x,y,z...]} where each of the @code{list} elements is an expression of
+of the form @code{[x,y,z,...]} where each of the @code{list} elements is an expression of
 a binary operand and 2 elements.  For example @code{x=1}, @code{2^3}, @code{[a,b]} etc.
 The @code{key} is checked againts the first operand.  @code{assoc} returns the second
 operand if the @code{key} is found.  If the @code{key} is not found it
@@ -58,34 +57,31 @@
 and defaults to @code{false}.
 
 @end defun
-@c @node atom, cons, append, Lists
-@c @unnumberedsec 
+
 @defun atom (exp)
 is @code{true} if @code{exp} is atomic (i.e. a number, name or string) else
-FALSE.  Thus @code{atom(5)} is @code{true} while @code{atom(a[1])} and @code{atom(sin(x))} are
+@code{false}.  Thus @code{atom(5)} is @code{true} while @code{atom(a[1])} and @code{atom(sin(x))} are
 @code{false} (asuming @code{a[1]} and @code{x} are unbound).
 
 @end defun
-@c @node cons, copylist, atom, Lists
-@c @unnumberedsec 
+ 
 @defun cons (exp, list)
 returns a new list constructed of the element @code{exp} as
 its first element, followed by the elements of @code{list}.  @code{cons} also works
 on other expressions, e.g. @code{cons(x, f(a,b,c));}  ->  @code{f(x,a,b,c)}.
 
 @end defun
-@c @node copylist, delete, cons, Lists
-@c @unnumberedsec 
+
 @defun copylist (list)
 creates a copy of the list @code{list}.
 
 @end defun
-@c @node delete, endcons, copylist, Lists
-@c @unnumberedsec 
+
 @defun delete (exp1, exp2)
+@defunx delete (exp1, exp2, n)
 removes all occurrences of @code{exp1} from @code{exp2}.  @code{exp1}
-may be a term of @code{exp2} (if it is a sum) or a factor of @code{exp2} (if it is a
-product).
+may be a term of @code{exp2} (if it is a sum) or a factor of @code{exp2} 
+(if it is a product).
 @example
 (%i1)  delete(sin(x),x+sin(x)+y);
 (%o1)               y + x
@@ -102,16 +98,14 @@
 
 @end example
 @end defun
-@c @node endcons, every, delete, Lists
-@c @unnumberedsec 
+ 
 @defun endcons (exp, list)
 returns a new list consisting of the elements of
 @code{list} followed by @code{exp}.  @code{endcons} also works on general expressions, e.g.
 @code{endcons(x, f(a,b,c));}  ->  @code{f(a,b,c,x)}.
 
 @end defun
-@c @node every, first, delete, Lists
-@c @unnumberedsec 
+
 @defun every (exp)
 This function takes a list, or a positive number of arguments and returns
 @code{true} if all its arguments are not @code{false}.
@@ -128,7 +122,7 @@
 input.  If the variable @code{inflag [false]} is set to @code{true} however, these
 functions will look at the internal form of @code{exp}.  Note that the
 simplifier re-orders expressions.  Thus @code{first(x+y)} will be @code{x} if @code{inflag}
-is @code{TRUE} and @code{Y} if @code{inflag} is @code{false} (@code{first(y+x)} gives the same
+is @code{true} and @code{y} if @code{inflag} is @code{false} (@code{first(y+x)} gives the same
 results).  The functions @code{second} .. @code{tenth} yield the second through the
 tenth part of their input argument.
 
@@ -186,7 +180,7 @@
 @c @node listarith, listp, length, Lists
 @c @unnumberedsec 
 @defvar listarith
- default: @code{[true]} - if @code{false} causes any arithmetic operations
+ default value: @code{true} - if @code{false} causes any arithmetic operations
 with lists to be suppressed; when @code{true}, list-matrix operations are
 contagious causing lists to be converted to matrices yielding a result
 which is always a matrix.  However, list-list operations should return

Index: Logarithms.texi
===================================================================
RCS file: /cvsroot/maxima/maxima/doc/info/Logarithms.texi,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- Logarithms.texi	17 Nov 2004 18:50:34 -0000	1.4
+++ Logarithms.texi	2 Dec 2004 19:19:40 -0000	1.5
@@ -1,43 +1,50 @@
-@c end concepts Logarithms
+
 @menu
 * Definitions for Logarithms::  
 @end menu
 
 @node Definitions for Logarithms,  , Logarithms, Logarithms
 @section Definitions for Logarithms
-@c @node log
-@c @unnumberedsec phony
+
+@defvar %e_to_numlog 
+when @code{true}, @code{r} some rational number, and
+@code{x} some expression, @code{%e^(r*log(x))} will be simplified into @code{x^r} .  It
+should be noted that the @code{radcan} command also does this transformation,
+and more complicated transformations of this ilk as well.
+The @code{logcontract} command "contracts" expressions containing @code{log}.
+
+@end defvar
+
 @defun log (x)
 the natural logarithm.
 
-  @code{logexpand[true]} - causes @code{log(a^b)} to become @code{b*log(a)}.  
+  @code{logexpand} - causes @code{log(a^b)} to become @code{b*log(a)}.  
 If it is set to @code{all}, @code{log(a*b)} will also simplify to @code{log(a)+log(b)}.  
 If it is set to @code{super}, then @code{log(a/b)} will also simplify to @code{log(a)-log(b)} for rational
 numbers @code{a/b}, @code{a#1}.  (@code{log(1/b)}, for @code{b} integer, always simplifies.)  If
 it is set to @code{false}, all of these simplifications will be turned off.
 
-  @code{logsimp[true]} - if @code{false} then no simplification of @code{%e} to a power
+  @code{logsimp} - if @code{false} then no simplification of @code{%e} to a power
 containing @code{log}'s is done.
 
-  @code{lognumer[false]} - if @code{true} then negative floating point arguments to
+  @code{lognumer} - if @code{true} then negative floating point arguments to
 @code{log} will always be converted to their absolute value before the @code{log} is
 taken.  If @code{numer} is also @code{true}, then negative integer arguments to @code{log}
 will also be converted to their absolute value.
 
-  @code{lognegint[false]} - if @code{true} implements the rule @code{log(-n)} ->
+  @code{lognegint} - if @code{true} implements the rule @code{log(-n)} ->
 @code{log(n)+%i*%pi} for @code{n} a positive integer.
 
-  @code{%e_to_numlog[false]} - when @code{true}, @code{r} some rational number, and
+  @code{%e_to_numlog} - when @code{true}, @code{r} some rational number, and
 @code{x} some expression, @code{%e^(r*log(x))} will be simplified into @code{x^r} .  It
 should be noted that the @code{radcan} command also does this transformation,
 and more complicated transformations of this ilk as well.
 The @code{logcontract} command "contracts" expressions containing @code{log}.
 
 @end defun
-@c @node logabs
-@c @unnumberedsec phony
+
 @defvar logabs
- default: @code{[false]} - when doing indefinite integration where
+ default value: @code{false} - when doing indefinite integration where
 logs are generated, e.g. @code{integrate(1/x,x)}, the answer is given in
 terms of @code{log(abs(...))} if @code{logabs} is @code{true}, but in terms of @code{log(...)} if
 @code{logabs} is @code{false}.  For definite integration, the @code{logabs:true} setting is
@@ -45,19 +52,17 @@
 endpoints is often needed.
 
 @end defvar
-@c @node logarc
-@c @unnumberedsec phony
+
 @defvar logarc
- default: @code{[false]} - if @code{true} will cause the inverse circular and
+ default value: @code{false} - if @code{true} will cause the inverse circular and
 hyperbolic functions to be converted into logarithmic form.
 @code{logarc(exp)} will cause this conversion for a particular expression without
 setting the switch or having to re-evaluate the expression with @code{ev}.
 
 @end defvar
-@c @node logconcoeffp
-@c @unnumberedsec phony
+
 @defvar logconcoeffp
- default: @code{[false]} - controls which coefficients are
+ default value: @code{false} - controls which coefficients are
 contracted when using @code{logcontract}.  It may be set to the name of a
 predicate function of one argument.  E.g. if you like to generate
 SQRTs, you can do @code{logconcoeffp:'logconfun$
@@ -65,34 +70,32 @@
 @code{logcontract(1/2*log(x));} will give @code{log(sqrt(x))}.
 
 @end defvar
-@c @node logcontract
-@c @unnumberedsec phony
+
 @defun logcontract (exp)
-recursively scans an exp, transforming
+recursively scans an @code{exp}, transforming
 subexpressions of the form @code{a1*log(b1) + a2*log(b2) + c} into
 @code{log(ratsimp(b1^a1 * b2^a2)) + c}
 @example
 (%i1) 2*(a*log(x) + 2*a*log(y))$
 (%i2) logcontract(%);
-                                         2  4
-(%o3)                             a log(x  y )
+                                     2  4
+(%o3)                         a log(x  y )
 
 @end example
 If you do @code{declare(n,integer);} then @code{logcontract(2*a*n*log(x));} gives
 @code{a*log(x^(2*n))}.  The coefficients that "contract" in this manner are
 those such as the 2 and the @code{n} here which satisfy
 @code{featurep(coeff,integer)}.  The user can control which coefficients are
-contracted by setting the option @code{logconcoeffp[false]} to the name of a
+contracted by setting the option @code{logconcoeffp} to the name of a
 predicate function of one argument.  E.g. if you like to generate
 SQRTs, you can do @code{logconcoeffp:'logconfun$
 logconfun(m):=featurep(m,integer) or ratnump(m)$} .  Then
 @code{logcontract(1/2*log(x));} will give @code{log(sqrt(x))}.
 
 @end defun
-@c @node logexpand
-@c @unnumberedsec phony
+
 @defvar logexpand
- default: @code{[true]} - causes @code{log(a^b)} to become @code{b*log(a)}.  If
+ default value: @code{true} - causes @code{log(a^b)} to become @code{b*log(a)}.  If
 it is set to @code{all}, @code{log(a*b)} will also simplify to @code{log(a)+log(b)}.  If it
 is set to @code{super}, then @code{log(a/b)} will also simplify to @code{log(a)-log(b)} for
 rational numbers @code{a/b}, @code{a#1}.  (@code{log(1/b)}, for integer @code{b}, always
@@ -100,38 +103,33 @@
 be turned off.
 
 @end defvar
-@c @node lognegint
-@c @unnumberedsec phony
+
 @defvar lognegint
- default: @code{[false]} - if @code{true} implements the rule 
+ default value: @code{false} - if @code{true} implements the rule 
 @code{log(-n)} -> @code{log(n)+%i*%pi} for @code{n} a positive integer.
 
 @end defvar
-@c @node lognumer
-@c @unnumberedsec phony
+
 @defvar lognumer
- default: @code{[false]} - if @code{true} then negative floating point
+ default value: @code{false} - if @code{true} then negative floating point
 arguments to @code{log} will always be converted to their absolute value
 before the @code{log} is taken.  If @code{numer} is also @code{true}, then negative integer
 arguments to @code{log} will also be converted to their absolute value.
 
 @end defvar
-@c @node logsimp
-@c @unnumberedsec phony
+
 @defvar logsimp
- default: @code{[true]} - if @code{false} then no simplification of @code{%e} to a
+ default value: @code{true} - if @code{false} then no simplification of @code{%e} to a
 power containing @code{log}'s is done.
 
 @end defvar
-@c @node plog
-@c @unnumberedsec phony
+
 @defun plog (x)
 the principal branch of the complex-valued natural
 logarithm with @code{-%pi} < @code{carg(x)} <= @code{+%pi} .
 
 @end defun
-@c @node polarform
-@c @unnumberedsec phony
+
 @defun polarform (exp)
 returns @code{r*%e^(%i*theta)} where @code{r} and @code{theta} are purely
 real.