Menu
▾
▴
[Maxima-commits] Maxima, A Computer Algebra System branch, master, updated. d804f9872d64dcb93a6405b91d9181dd9526c30d
|
From: Dieter K. <cra...@us...> - 2011-06-10 17:34:51
|
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Maxima, A Computer Algebra System".
The branch, master has been updated
via d804f9872d64dcb93a6405b91d9181dd9526c30d (commit)
via 9aae478fdbf4e596d6a02520ea4ab55aae685dd2 (commit)
via a4a4344c991b8de6118f0f60c6c1ff710dcbad85 (commit)
via 2880dea418908cd08fef48f10f4f55beb73a4976 (commit)
via b2dc057581f98222d7dc9387ce65985e41332995 (commit)
via d354a646233d6345aa26a67bd67ab38d6a23b263 (commit)
via 96a22ac12610bf87f399576e3742dbfdbeebb904 (commit)
via e79dc7753882bebea0719abf085915b3693ccce6 (commit)
via d2e001aaf6aada381ec80dec81c75e046502156e (commit)
from 2c3efda3ea0f0c40062dfcdc6cf516fd21ace723 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit d804f9872d64dcb93a6405b91d9181dd9526c30d
Author: crategus <cra...@us...>
Date: Fri Jun 10 19:26:51 2011 +0200
Moving documentation to the following files:
to Database.texi:
constant
constantp
nonarray
to Simplification.texi:
distrib
multthru
to MathFunctions.texi:
%emode
%enumer
exp
to Operators.texi:
infix
to Polynomials.texi:
powers
to Series.texi:
product
lsum
sum
Adding cross references.
diff --git a/doc/info/Expressions.texi b/doc/info/Expressions.texi
index f7711d0..bb9718d 100644
--- a/doc/info/Expressions.texi
+++ b/doc/info/Expressions.texi
@@ -48,7 +48,7 @@ return is the not too useful @code{done}.
(%o2) done
@end example
-whereas what you really want is probably to include a third
+Whereas what you really want is probably to include a third
term in the @i{comma expression} which actually gives back the value.
@example
@@ -66,19 +66,20 @@ Maxima distinguishes between operators which are "nouns" and operators which are
"verbs". A verb is an operator which can be executed. A noun is an operator
which appears as a symbol in an expression, without being executed. By default,
function names are verbs. A verb can be changed into a noun by quoting the
-function name or applying the @code{nounify} function. A noun can be changed
-into a verb by applying the @code{verbify} function. The evaluation flag
-@code{nouns} causes @code{ev} to evaluate nouns in an expression.
+function name or applying the @mref{nounify} function. A noun can be changed
+into a verb by applying the @mref{verbify} function. The evaluation flag
+@mref{nouns} causes @mref{ev} to evaluate nouns in an expression.
The verb form is distinguished by a leading dollar sign @code{$} on the
corresponding Lisp symbol. In contrast, the noun form is distinguished by a
leading percent sign @code{%} on the corresponding Lisp symbol. Some nouns have
special display properties, such as @code{'integrate} and @code{'derivative}
-(returned by @code{diff}), but most do not. By default, the noun and verb forms
-of a function are identical when displayed. The global flag @code{noundisp}
+(returned by @mref{diff}), but most do not. By default, the noun and verb forms
+of a function are identical when displayed. The global flag @mref{noundisp}@w{}
causes Maxima to display nouns with a leading quote mark @code{'}.
-See also @code{noun}, @code{nouns}, @code{nounify}, and @code{verbify}.
+See also @mrefcomma{noun} @mrefcomma{nouns} @mrefcomma{nounify} and
+@mrefdot{verbify}
Examples:
@@ -177,7 +178,6 @@ Examples:
@c :lisp (defvar *my-lisp-variable* '$foo)
@c ?\*my\-lisp\-variable\*;
@c ===end===
-
@example
(%i1) %an_ordinary_identifier42;
(%o1) %an_ordinary_identifier42
@@ -337,7 +337,7 @@ Operator lbp rbp
; -1
@end example
-@code{remove} and @code{kill} remove operator properties from an atom.
+@mref{remove} and @mref{kill} remove operator properties from an atom.
@code{remove ("@var{a}", op)} removes only the operator properties of @var{a}.
@code{kill ("@var{a}")} removes all properties of @var{a}, including the
operator properties. Note that the name of the operator must be enclosed in
@@ -416,23 +416,24 @@ etc. Any even number of arguments may be used.
Default value: @code{[]}
@code{aliases} is the list of atoms which have a user defined alias (set up by
-the @code{alias}, @code{ordergreat}, @code{orderless} functions or by declaring
-the atom a @code{noun} with @code{declare}).
+the @mrefcomma{alias} @mrefcomma{ordergreat} @mref{orderless} functions or by
+declaring the atom a @mref{noun} with @mrefdot{declare})
@opencatbox
@category{Declarations and inferences} @category{Global variables}
@closecatbox
@end defvr
-@c NEEDS TO BE REWORKED. NOT CONVINCED THIS SYMBOL NEEDS ITS OWN ITEM
+@c NEEDS TO BE REWORKED. NOT CONVINCED THIS SYMBOL NEEDS ITS OWN ITEM
@c (SHOULD BE DESCRIBED IN CONTEXT OF EACH FUNCTION WHICH RECOGNIZES IT)
@c -----------------------------------------------------------------------------
@anchor{allbut}
@defvr {Keyword} allbut
-works with the @code{part} commands (i.e. @code{part}, @code{inpart},
-@code{substpart}, @code{substinpart}, @code{dpart}, and @code{lpart}).
+works with the @code{part} commands (i.e. @mrefcomma{part}@w{}
+@mrefcomma{inpart} @mrefcomma{substpart} @mrefcomma{substinpart}@w{}
+@mrefcomma{dpart} and @mref{lpart}).
For example,
@c ===beg===
@@ -459,7 +460,7 @@ while
(%o2) e + c + b
@end example
-@code{allbut} is also recognized by @code{kill}.
+@code{allbut} is also recognized by @mrefdot{kill}
@c ===beg===
@c [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
@@ -475,24 +476,25 @@ while
(%o1) [aa, bb, 33, 44]
@end example
-@code{kill(allbut(@var{a_1}, @var{a_2}, ...))} has the effect of @code{kill(all)}
-except that it does not kill the symbols @var{a_1}, @var{a_2}, @dots{}
+@code{kill(allbut(@var{a_1}, @var{a_2}, ...))} has the effect of
+@code{kill(all)} except that it does not kill the symbols @var{a_1}, @var{a_2},
+@dots{}
@end defvr
@c -----------------------------------------------------------------------------
@anchor{args}
@deffn {Function} args (@var{expr})
-Returns the list of arguments of @code{expr},
-which may be any kind of expression other than an atom.
-Only the arguments of the top-level operator are extracted;
-subexpressions of @code{expr} appear as elements or subexpressions of elements
-of the list of arguments.
+Returns the list of arguments of @code{expr}, which may be any kind of
+expression other than an atom. Only the arguments of the top-level operator
+are extracted; subexpressions of @code{expr} appear as elements or
+subexpressions of elements of the list of arguments.
-The order of the items in the list may depend on the global flag @code{inflag}.
+The order of the items in the list may depend on the global flag
+@mrefdot{inflag}
@code{args (@var{expr})} is equivalent to @code{substpart ("[", @var{expr}, 0)}.
-See also @code{substpart}, and @code{op}.
+See also @mrefcomma{substpart} and @mrefdot{op}
@c NEEDS EXAMPLES
@opencatbox
@@ -504,11 +506,12 @@ See also @code{substpart}, and @code{op}.
@c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION
@c -----------------------------------------------------------------------------
+@anchor{atom}
@deffn {Function} atom (@var{expr})
Returns @code{true} if @var{expr} is atomic (i.e. a number, name or string) else
@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
+@code{atom(sin(x))} are @code{false} (assuming @code{a[1]} and @code{x} are
unbound).
@opencatbox
@@ -533,8 +536,8 @@ box.
evaluate to its content, so boxed expressions are effectively excluded from
computations.
-@code{boxchar} is the character used to draw the box in @code{box} and in the
-@code{dpart} and @code{lpart} functions.
+@mref{boxchar} is the character used to draw the box in @code{box} and in the
+@mref{dpart} and @mref{lpart} functions.
Examples:
@@ -590,8 +593,8 @@ Examples:
@defvr {Option variable} boxchar
Default value: @code{"}
-@code{boxchar} is the character used to draw the box in the @code{box}
-and in the @code{dpart} and @code{lpart} functions.
+@code{boxchar} is the character used to draw the box in the @mref{box}@w{}
+and in the @mref{dpart} and @mref{lpart} functions.
All boxes in an expression are drawn with the current value of @code{boxchar};
the drawing character is not stored with the box expression.
@@ -609,8 +612,8 @@ the drawing character is not stored with the box expression.
Collapses @var{expr} by causing all of its common (i.e., equal) subexpressions
to share (i.e., use the same cells), thereby saving space. (@code{collapse} is
-a subroutine used by the @code{optimize} command.) Thus, calling
-@code{collapse} may be useful after loading in a @code{save} file. You can
+a subroutine used by the @mref{optimize} command.) Thus, calling
+@code{collapse} may be useful after loading in a @mref{save} file. You can
collapse several expressions together by using
@code{collapse ([@var{expr_1}, ..., @var{expr_n}])}. Similarly, you can
collapse the elements of the array @code{A} by doing
@@ -621,76 +624,10 @@ collapse the elements of the array @code{A} by doing
@closecatbox
@end deffn
-@c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
-@c CROSS REF declare, properties, ETC
-
-@c -----------------------------------------------------------------------------
-@anchor{constant}
-@deffn {Special operator} constant
-
-@code{declare (@var{a}, constant)} declares @var{a} to be a constant.
-See @code{declare}.
-@c WHAT EXACTLY ARE THE CONSEQUENCES OF DECLARING AN ATOM TO BE CONSTANT ??
-
-@opencatbox
-@category{Declarations and inferences} @category{Constants}
-@closecatbox
-@end deffn
-
-@c -----------------------------------------------------------------------------
-@anchor{constantp}
-@deffn {Function} constantp (@var{expr})
-
-Returns @code{true} if @var{expr} is a constant expression, otherwise returns
-@code{false}.
-@c WHAT DOES MAXIMA KNOW ABOUT CONSTANT EXPRESSIONS ??
-
-An expression is considered a constant expression if its arguments are
-numbers (including rational numbers, as displayed with @code{/R/}),
-symbolic constants such as @code{%pi}, @code{%e}, and @code{%i},
-variables bound to a constant or declared constant by @code{declare},
-or functions whose arguments are constant.
-
-@code{constantp} evaluates its arguments.
-
-Examples:
-
-@c ===beg===
-@c constantp (7 * sin(2));
-@c constantp (rat (17/29));
-@c constantp (%pi * sin(%e));
-@c constantp (exp (x));
-@c declare (x, constant);
-@c constantp (exp (x));
-@c constantp (foo (x) + bar (%e) + baz (2));
-@c ===end===
-@example
-(%i1) constantp (7 * sin(2));
-(%o1) true
-(%i2) constantp (rat (17/29));
-(%o2) true
-(%i3) constantp (%pi * sin(%e));
-(%o3) true
-(%i4) constantp (exp (x));
-(%o4) false
-(%i5) declare (x, constant);
-(%o5) done
-(%i6) constantp (exp (x));
-(%o6) true
-(%i7) constantp (foo (x) + bar (%e) + baz (2));
-(%o7) false
-(%i8)
-@end example
-
-@opencatbox
-@category{Predicate functions} @category{Constants}
-@closecatbox
-@end deffn
-
@c NEEDS WORK
@c -----------------------------------------------------------------------------
-@anchor{disoloate}
+@anchor{disolate}
@deffn {Function} disolate (@var{expr}, @var{x_1}, @dots{}, @var{x_n})
is similar to @code{isolate (@var{expr}, @var{x})} except that it enables the
@@ -716,7 +653,7 @@ Returns the external representation of @var{expr}.
the main (top-level) operator. @code{dispform(@var{expr}, all)} returns the
external representation with respect to all operators in @var{expr}.
-See also @code{part}, @code{inpart}, and @code{inflag}.
+See also @mrefcomma{part} @mrefcomma{inpart} and @mrefdot{inflag}
Examples:
@@ -791,43 +728,10 @@ Use of the optional argument @code{all}.
@c NEEDS WORK
@c -----------------------------------------------------------------------------
-@anchor{function_distrib}
-@deffn {Function} distrib (@var{expr})
-
-Distributes sums over products. It differs from @code{expand} in that it works
-at only the top level of an expression, i.e., it doesn't recurse and it is
-faster than @code{expand}. It differs from @code{multthru} in that it expands
-all sums at that level.
-
-Examples:
-
-@example
-(%i1) distrib ((a+b) * (c+d));
-(%o1) b d + a d + b c + a c
-(%i2) multthru ((a+b) * (c+d));
-(%o2) (b + a) d + (b + a) c
-(%i3) distrib (1/((a+b) * (c+d)));
- 1
-(%o3) ---------------
- (b + a) (d + c)
-(%i4) expand (1/((a+b) * (c+d)), 1, 0);
- 1
-(%o4) ---------------------
- b d + a d + b c + a c
-@end example
-
-@opencatbox
-@category{Expressions}
-@closecatbox
-@end deffn
-
-@c NEEDS WORK
-
-@c -----------------------------------------------------------------------------
@anchor{dpart}
@deffn {Function} dpart (@var{expr}, @var{n_1}, @dots{}, @var{n_k})
-Selects the same subexpression as @code{part}, but instead of just returning
+Selects the same subexpression as @mrefcomma{part} but instead of just returning
that subexpression as its value, it returns the whole expression with the
selected subexpression displayed inside a box. The box is actually part of the
expression.
@@ -847,76 +751,6 @@ expression.
@closecatbox
@end deffn
-@c PROBABLY MORE TO BE SAID HERE
-
-@c -----------------------------------------------------------------------------
-@anchor{exp}
-@deffn {Function} exp (@var{x})
-
-Represents the exponential function. Instances of @code{exp (@var{x})} in input
-are simplified to @code{%e^@var{x}}; @code{exp} does not appear in simplified
-expressions.
-
-@code{demoivre} if @code{true} causes @code{%e^(a + b %i)} to simplify to
-@code{%e^(a (cos(b) + %i sin(b)))} if @code{b} is free of @code{%i}.
-See @code{demoivre}.
-
-@code{%emode}, when @code{true}, causes @code{%e^(%pi %i x)} to be simplified.
-See @code{%emode}.
-
-@code{%enumer}, when @code{true} causes @code{%e} to be replaced by
-2.718@dots{} whenever @code{numer} is @code{true}. See @code{%enumer}.
-
-@c NEED EXAMPLES HERE
-@opencatbox
-@category{Exponential and logarithm functions}
-@closecatbox
-@end deffn
-
-@c -----------------------------------------------------------------------------
-@anchor{%emode}
-@defvr {Option variable} %emode
-Default value: @code{true}
-
-When @code{%emode} is @code{true}, @code{%e^(%pi %i x)} is simplified as
-follows.
-
-@code{%e^(%pi %i x)} simplifies to @code{cos (%pi x) + %i sin (%pi x)} if
-@code{x} is a floating point number, an integer, or a multiple of 1/2, 1/3, 1/4,
-or 1/6, and then further simplified.
-
-For other numerical @code{x}, @code{%e^(%pi %i x)} simplifies to
-@code{%e^(%pi %i y)} where @code{y} is @code{x - 2 k} for some integer @code{k}
-such that @code{abs(y) < 1}.
-
-When @code{%emode} is @code{false}, no special simplification of
-@code{%e^(%pi %i x)} is carried out.
-
-@c NEED EXAMPLES HERE
-@opencatbox
-@category{Exponential and logarithm functions} @category{Simplification flags and variables}
-@closecatbox
-@end defvr
-
-@c -----------------------------------------------------------------------------
-@anchor{%enumer}
-@defvr {Option variable} %enumer
-Default value: @code{false}
-
-When @code{%enumer} is @code{true}, @code{%e} is replaced by its numeric value
-2.718@dots{} whenever @code{numer} is @code{true}.
-
-When @code{%enumer} is @code{false}, this substitution is carried out
-only if the exponent in @code{%e^x} evaluates to a number.
-
-See also @code{ev} and @code{numer}.
-
-@c NEED EXAMPLES HERE
-@opencatbox
-@category{Exponential and logarithm functions} @category{Evaluation flags}
-@closecatbox
-@end defvr
-
@c -----------------------------------------------------------------------------
@anchor{exptisolate}
@defvr {Option variable} exptisolate
@@ -971,10 +805,10 @@ the original form of @var{expr}.
A variable is a dummy variable in an expression if it has no binding outside of
the expression. Dummy variables recognized by @code{freeof} are the index of a
-sum or product, the limit variable in @code{limit}, the integration variable in
-the definite integral form of @code{integrate}, the original variable in
-@code{laplace}, formal variables in @code{at} expressions, and arguments in
-@code{lambda} expressions.
+sum or product, the limit variable in @mrefcomma{limit} the integration variable
+in the definite integral form of @mref{integrate}, the original variable in
+@mrefcomma{laplace} formal variables in @mref{at} expressions, and arguments in
+@mref{lambda} expressions.
The indefinite form of @code{integrate} is @i{not} free of its variable of
integration.
@@ -1052,135 +886,6 @@ An indefinite integral is not free of its variable of integration.
@end deffn
@c -----------------------------------------------------------------------------
-@anchor{infix}
-@deffn {Function} infix (@var{op})
-@deffnx {Function} infix (@var{op}, @var{lbp}, @var{rbp})
-@deffnx {Function} infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})
-
-Declares @var{op} to be an infix operator. An infix operator is a function of
-two arguments, with the name of the function written between the arguments.
-For example, the subtraction operator @code{-} is an infix operator.
-
-@code{infix (@var{op})} declares @var{op} to be an infix operator with default
-binding powers (left and right both equal to 180) and parts of speech (left and
-right both equal to @code{any}).
-@c HOW IS pos DIFFERENT FROM lpos AND rpos ??
-
-@code{infix (@var{op}, @var{lbp}, @var{rbp})} declares @var{op} to be an infix
-operator with stated left and right binding powers and default parts of speech
-(left and right both equal to @code{any}).
-
-@code{infix (@var{op}, @var{lbp}, @var{rbp}, @var{lpos}, @var{rpos}, @var{pos})}
-declares @var{op} to be an infix operator with stated left and right binding
-powers and parts of speech @var{lpos}, @var{rpos}, and @var{pos} for the left
-operand, the right operand, and the operator result, respectively.
-
-"Part of speech", in reference to operator declarations, means expression type.
-Three types are recognized: @code{expr}, @code{clause}, and @code{any},
-indicating an algebraic expression, a Boolean expression, or any kind of
-expression, respectively. Maxima can detect some syntax errors by comparing the
-declared part of speech to an actual expression.
-
-The precedence of @var{op} with respect to other operators derives from the left
-and right binding powers of the operators in question. If the left and right
-binding powers of @var{op} are both greater the left and right binding powers of
-some other operator, then @var{op} takes precedence over the other operator.
-If the binding powers are not both greater or less, some more complicated
-relation holds.
-
-The associativity of @var{op} depends on its binding powers. Greater left
-binding power (@var{lbp}) implies an instance of @var{op} is evaluated before
-other operators to its left in an expression, while greater right binding power
-(@var{rbp}) implies an instance of @var{op} is evaluated before other operators
-to its right in an expression. Thus greater @var{lbp} makes @var{op}
-right-associative, while greater @var{rbp} makes @var{op} left-associative.
-If @var{lbp} is equal to @var{rbp}, @var{op} is left-associative.
-
-See also @code{Syntax}.
-
-Examples:
-
-If the left and right binding powers of @var{op} are both greater
-the left and right binding powers of some other operator,
-then @var{op} takes precedence over the other operator.
-
-@c ===beg===
-@c :lisp (get '$+ 'lbp)
-@c :lisp (get '$+ 'rbp)
-@c infix ("##", 101, 101);
-@c "##"(a, b) := sconcat("(", a, ",", b, ")");
-@c 1 + a ## b + 2;
-@c infix ("##", 99, 99);
-@c 1 + a ## b + 2;
-@c ===end===
-@example
-(%i1) :lisp (get '$+ 'lbp)
-100
-(%i1) :lisp (get '$+ 'rbp)
-100
-(%i1) infix ("##", 101, 101);
-(%o1) ##
-(%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
-(%o2) (a ## b) := sconcat("(", a, ",", b, ")")
-(%i3) 1 + a ## b + 2;
-(%o3) (a,b) + 3
-(%i4) infix ("##", 99, 99);
-(%o4) ##
-(%i5) 1 + a ## b + 2;
-(%o5) (a+1,b+2)
-@end example
-
-Greater @var{lbp} makes @var{op} right-associative,
-while greater @var{rbp} makes @var{op} left-associative.
-
-@c ===beg===
-@c infix ("##", 100, 99);
-@c "##"(a, b) := sconcat("(", a, ",", b, ")")$
-@c foo ## bar ## baz;
-@c infix ("##", 100, 101);
-@c foo ## bar ## baz;
-@c ===end===
-@example
-(%i1) infix ("##", 100, 99);
-(%o1) ##
-(%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
-(%i3) foo ## bar ## baz;
-(%o3) (foo,(bar,baz))
-(%i4) infix ("##", 100, 101);
-(%o4) ##
-(%i5) foo ## bar ## baz;
-(%o5) ((foo,bar),baz)
-@end example
-
-Maxima can detect some syntax errors by comparing the
-declared part of speech to an actual expression.
-
-@c ===beg===
-@c infix ("##", 100, 99, expr, expr, expr);
-@c if x ## y then 1 else 0;
-@c infix ("##", 100, 99, expr, expr, clause);
-@c if x ## y then 1 else 0;
-@c ===end===
-@example
-(%i1) infix ("##", 100, 99, expr, expr, expr);
-(%o1) ##
-(%i2) if x ## y then 1 else 0;
-Incorrect syntax: Found algebraic expression where logical
-expression expected
-if x ## y then
- ^
-(%i2) infix ("##", 100, 99, expr, expr, clause);
-(%o2) ##
-(%i3) if x ## y then 1 else 0;
-(%o3) if x ## y then 1 else 0
-@end example
-
-@opencatbox
-@category{Operators} @category{Declarations and inferences} @category{Syntax}
-@closecatbox
-@end deffn
-
-@c -----------------------------------------------------------------------------
@anchor{inflag}
@defvr {Option variable} inflag
Default value: @code{false}
@@ -1192,13 +897,14 @@ Note that the simplifier re-orders expressions. Thus @code{first (x + y)}
returns @code{x} if @code{inflag} is @code{true} and @code{y} if @code{inflag}
is @code{false}. (@code{first (y + x)} gives the same results.)
-Also, setting @code{inflag} to @code{true} and calling @code{part} or
-@code{substpart} is the same as calling @code{inpart} or @code{substinpart}.
+Also, setting @code{inflag} to @code{true} and calling @mref{part} or
+@mref{substpart} is the same as calling @mref{inpart} or @mrefdot{substinpart}
-Functions affected by the setting of @code{inflag} are: @code{part},
-@code{substpart}, @code{first}, @code{rest}, @code{last}, @code{length}, the
-@code{for} @dots{} @code{in} construct, @code{map}, @code{fullmap},
-@code{maplist}, @code{reveal} and @code{pickapart}.
+Functions affected by the setting of @code{inflag} are: @mrefcomma{part}@w{}
+@mrefcomma{substpart} @mrefcomma{first} @mrefcomma{rest} @mrefcomma{last}@w{}
+@mrefcomma{length} the @mref{for} @dots{} @code{in} construct,
+@mrefcomma{map} @mrefcomma{fullmap} @mrefcomma{maplist} @mref{reveal} and
+@mrefdot{pickapart}
@c NEED EXAMPLES HERE
@opencatbox
@@ -1212,7 +918,7 @@ Functions affected by the setting of @code{inflag} are: @code{part},
@anchor{inpart}
@deffn {Function} inpart (@var{expr}, @var{n_1}, @dots{}, @var{n_k})
-is similar to @code{part} but works on the internal representation of the
+is similar to @mref{part} but works on the internal representation of the
expression rather than the displayed form and thus may be faster since no
formatting is done. Care should be taken with respect to the order of
subexpressions in sums and products (since the order of variables in the
@@ -1247,7 +953,7 @@ Examples:
@c NEEDS WORK
@c -----------------------------------------------------------------------------
-@anchor{isoloate}
+@anchor{isolate}
@deffn {Function} isolate (@var{expr}, @var{x})
Returns @var{expr} with subexpressions which are sums and which do not contain
@@ -1257,12 +963,12 @@ unnecessary expansion of subexpressions which don't contain the variable of
interest. Since the intermediate labels are bound to the subexpressions they
can all be substituted back by evaluating the expression in which they occur.
-@code{exptisolate} (default value: @code{false}) if @code{true} will cause
+@mref{exptisolate} (default value: @code{false}) if @code{true} will cause
@code{isolate} to examine exponents of atoms (like @code{%e}) which contain
@var{var}.
@code{isolate_wrt_times} if @code{true}, then @code{isolate} will also isolate
-with respect to products. See @code{isolate_wrt_times}.
+with respect to products. See @mrefdot{isolate_wrt_times}
Do @code{example (isolate)} for examples.
@@ -1314,7 +1020,7 @@ with respect to products. E.g. compare both settings of the switch on
@defvr {Option variable} listconstvars
Default value: @code{false}
-When @code{listconstvars} is @code{true}, it will cause @code{listofvars} to
+When @code{listconstvars} is @code{true}, it will cause @mref{listofvars} to
include @code{%e}, @code{%pi}, @code{%i}, and any variables declared constant in
the list it returns if they appear in the expression @code{listofvars} is called
on. The default is to omit these.
@@ -1330,8 +1036,8 @@ on. The default is to omit these.
Default value: @code{true}
When @code{listdummyvars} is @code{false}, "dummy variables" in the expression
-will not be included in the list returned by @code{listofvars}. (The meaning
-of "dummy variables" is as given in @code{freeof}. "Dummy variables" are
+will not be included in the list returned by @mrefdot{listofvars} (The meaning
+of "dummy variables" is as given in @mrefdot{freeof} "Dummy variables" are
mathematical things like the index of a sum or product, the limit variable,
and the definite integration variable.)
@@ -1359,11 +1065,11 @@ Example:
Returns a list of the variables in @var{expr}.
-@code{listconstvars} if @code{true} causes @code{listofvars} to include
+@mref{listconstvars} if @code{true} causes @code{listofvars} to include
@code{%e}, @code{%pi}, @code{%i}, and any variables declared constant in the
list it returns if they appear in @var{expr}. The default is to omit these.
-See also the option variable @code{listdummyvars} to exclude or include
+See also the option variable @mref{listdummyvars} to exclude or include
"dummy variables" in the list of variables.
@example
@@ -1385,7 +1091,7 @@ See also the option variable @code{listdummyvars} to exclude or include
For each member @var{m} of @var{list}, calls
@code{freeof (@var{m}, @var{expr})}. It returns @code{false} if any call to
-@code{freeof} does and @code{true} otherwise.
+@mref{freeof} does and @code{true} otherwise.
@opencatbox
@category{Expressions}
@@ -1415,7 +1121,7 @@ Returns the lowest exponent of @var{x} which explicitly appears in
@anchor{lpart}
@deffn {Function} lpart (@var{label}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
-is similar to @code{dpart} but uses a labelled box. A labelled box is similar
+is similar to @mref{dpart} but uses a labelled box. A labelled box is similar
to the one produced by @code{dpart} but it has a name in the top line.
@opencatbox
@@ -1426,96 +1132,6 @@ to the one produced by @code{dpart} but it has a name in the top line.
@c NEEDS WORK
@c -----------------------------------------------------------------------------
-@anchor{multthru}
-@deffn {Function} multthru (@var{expr})
-@deffnx {Function} multthru (@var{expr_1}, @var{expr_2})
-
-Multiplies a factor (which should be a sum) of @var{expr} by the other factors
-of @var{expr}. That is, @var{expr} is @code{@var{f_1} @var{f_2} ... @var{f_n}}
-where at least one factor, say @var{f_i}, is a sum of terms. Each term in that
-sum is multiplied by the other factors in the product. (Namely all the factors
-except @var{f_i}). @code{multthru} does not expand exponentiated sums.
-This function is the fastest way to distribute products (commutative or
-noncommutative) over sums. Since quotients are represented as products
-@code{multthru} can be used to divide sums by products as well.
-
-@code{multthru (@var{expr_1}, @var{expr_2})} multiplies each term in
-@var{expr_2} (which should be a sum or an equation) by @var{expr_1}. If
-@var{expr_1} is not itself a sum then this form is equivalent to
-@code{multthru (@var{expr_1}*@var{expr_2})}.
-
-@example
-(%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
- 1 x f(x)
-(%o1) - ----- + -------- - --------
- x - y 2 3
- (x - y) (x - y)
-(%i2) multthru ((x-y)^3, %);
- 2
-(%o2) - (x - y) + x (x - y) - f(x)
-(%i3) ratexpand (%);
- 2
-(%o3) - y + x y - f(x)
-(%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
- 10 2 2 2
- (b + a) s + 2 a b s + a b
-(%o4) ------------------------------
- 2
- a b s
-(%i5) multthru (%); /* note that this does not expand (b+a)^10 */
- 10
- 2 a b (b + a)
-(%o5) - + --- + ---------
- s 2 a b
- s
-(%i6) multthru (a.(b+c.(d+e)+f));
-(%o6) a . f + a . c . (e + d) + a . b
-(%i7) expand (a.(b+c.(d+e)+f));
-(%o7) a . f + a . c . e + a . c . d + a . b
-@end example
-
-@opencatbox
-@category{Expressions}
-@closecatbox
-@end deffn
-
-@c -----------------------------------------------------------------------------
-@anchor{nonarray}
-@deffn {Property} nonarray
-
-The command @code{declare(a, nonarray)} tells Maxima to consider @var{a} not
-an array. This declaration prevents multiple evaluation, if @var{a} is a
-subscripted variable.
-
-Example:
-
-@c ===beg===
-@c a:'b$ b:'c$ c:'d$
-@c a[x];
-@c declare(a, nonarray);
-@c a[x];
-@c ===end===
-@example
-(%i1) a:'b$ b:'c$ c:'d$
-
-(%i4) a[x];
-(%o4) d
- x
-(%i5) declare(a, nonarray);
-(%o5) done
-(%i6) a[x];
-(%o6) a
- x
-@end example
-
-@opencatbox
-@category{Expressions}
-@closecatbox
-@end deffn
-
-@c NEEDS WORK
-
-@c -----------------------------------------------------------------------------
@anchor{nounify}
@deffn {Function} nounify (@var{f})
@@ -1525,6 +1141,8 @@ were a noun. Note that some verb functions will return their noun
forms if they can't be evaluated for certain arguments. This is also
the form returned if a function call is preceded by a quote.
+See also @mrefdot{verbify}
+
@opencatbox
@category{Nouns and verbs}
@closecatbox
@@ -1563,11 +1181,11 @@ returns the subscripted function; in this case the return value is not an atom.
Otherwise, @var{expr} is an array function or ordinary function expression,
and @code{op} returns a symbol.
-@code{op} observes the value of the global flag @code{inflag}.
+@code{op} observes the value of the global flag @mrefdot{inflag}
@code{op} evaluates it argument.
-See also @code{args}.
+See also @mrefdot{args}
Examples:
@@ -1664,7 +1282,7 @@ are shared. Do @code{example (optimize)} for examples.
Default value: @code{%}
@code{optimprefix} is the prefix used for generated symbols by
-the @code{optimize} command.
+the @mref{optimize} command.
@opencatbox
@category{Expressions}
@@ -1686,11 +1304,11 @@ such that @var{v_1} precedes @var{v_2} precedes @dots{} precedes @var{v_n},
and @var{v_n} precedes any other variable not mentioned as an argument.
The order established by @code{ordergreat} and @code{orderless} is dissolved
-by @code{unorder}. @code{ordergreat} and @code{orderless} can be called only
+by @mrefdot{unorder} @code{ordergreat} and @code{orderless} can be called only
once each, unless @code{unorder} is called; only the last call to
@code{ordergreat} and @code{orderless} has any effect.
-See also @code{ordergreatp}.
+See also @mrefdot{ordergreatp}
@opencatbox
@category{Expressions}
@@ -1718,9 +1336,9 @@ following.
(integers and floats) precede (bigfloats) precede
(declared constants) precede (strings) precede (declared scalars)
-precede (first argument to @code{orderless}) precedes @dots{} precedes
+precede (first argument to @mref{orderless}) precedes @dots{} precedes
(last argument to @code{orderless}) precedes (other symbols) precede
-(last argument to @code{ordergreat}) precedes @dots{} precedes
+(last argument to @mref{ordergreat}) precedes @dots{} precedes
(first argument to @code{ordergreat}) precedes (declared main variables)
For non-atomic expressions, the canonical ordering is derived from the ordering
@@ -1732,10 +1350,10 @@ function. In the case of subscripted expressions, the subscripted symbol is
considered the operator and the subscript is considered an argument.
The canonical ordering of expressions is modified by the functions
-@code{ordergreat} and @code{orderless}, and the @code{mainvar}, @code{constant},
-and @code{scalar} declarations.
+@mref{ordergreat} and @mrefcomma{orderless} and the @mrefcomma{mainvar}@w{}
+@mrefcomma{constant} and @code{scalar} declarations.
-See also @code{sort}.
+See also @mrefdot{sort}
Examples:
@@ -1836,16 +1454,16 @@ If the last argument to a @code{part} function is a list of indices then
several subexpressions are picked out, each one corresponding to an
index of the list. Thus @code{part (x + y + z, [1, 3])} is @code{z+x}.
-@code{piece} holds the last expression selected when using the @code{part}
+@mref{piece} holds the last expression selected when using the @code{part}
functions. It is set during the execution of the function and thus
may be referred to in the function itself as shown below.
-If @code{partswitch} is set to @code{true} then @code{end} is returned when a
+If @mref{partswitch} is set to @code{true} then @code{end} is returned when a
selected part of an expression doesn't exist, otherwise an error message is
given.
-See also @code{inpart}, @code{substpart}, @code{substinpart}, @code{dpart}, and
-@code{lpart}.
+See also @mrefcomma{inpart} @mrefcomma{substpart} @mrefcomma{substinpart}@w{}
+@mrefcomma{dpart} and @mrefdot{lpart}
Examples:
@@ -1873,6 +1491,7 @@ Examples:
@c NEEDS WORK
@c -----------------------------------------------------------------------------
+@anchor{partition}
@deffn {Function} partition (@var{expr}, @var{x})
Returns a list of two expressions. They are (1) the factors of @var{expr}
@@ -1921,8 +1540,8 @@ Assigns intermediate expression labels to subexpressions of @var{expr} at depth
assigned labels. @code{pickapart} returns an expression in terms of
intermediate expressions equivalent to the original expression @var{expr}.
-See also @code{part}, @code{dpart}, @code{lpart}, @code{inpart}, and
-@code{reveal}.
+See also @mrefcomma{part} @mrefcomma{dpart} @mrefcomma{lpart}@w{}
+@mrefcomma{inpart} and @mrefdot{reveal}
Examples:
@@ -2015,7 +1634,7 @@ Examples:
@anchor{piece}
@defvr {System variable} piece
-Holds the last expression selected when using the @code{part} functions.
+Holds the last expression selected when using the @mref{part} functions.
@c WHAT DOES THIS MEAN EXACTLY ??
It is set during the execution of the function and thus may be referred to in
the function itself.
@@ -2027,127 +1646,18 @@ the function itself.
@closecatbox
@end defvr
-@c ISN'T THERE AN EQUIVALENT FUNCTION SOMEWHERE ??
-@c NEEDS WORK (IF KEPT)
-
-@c -----------------------------------------------------------------------------
-@anchor{powers}
-@deffn {Function} powers (@var{expr}, @var{x})
-
-Gives the powers of @var{x} occuring in @var{expr}.
-
-@code{load (powers)} loads this function.
-@c HMM, THERE'S A BUNCH OF MAXIMA FUNCTIONS IN src/powers.lisp ...
-@c FOR SOME REASON src/powers.lisp IS NOT PART OF THE USUAL BUILD -- STRANGE
-
-@c HERE IS THE TEXT FROM archive/share/unknown/powers.usg -- MERGE !!!
-@c THIS FUNCTION IS A GENERALISATION OF "HIPOW" AND "LOPOW"
-@c IN THAT IT RETURNS A LIST OF ALL THE POWERS OF VAR OCCURING
-@c IN EXPR. IT IS STILL NECESSARY TO EXPAND EXPR BEFORE APPLYING
-@c POWERS (ON PAIN OF GETTING THE WRONG ANSWER).
-@c
-@c THIS FUNCTION HAS MANY USES, E.G. IF YOU WANT TO FIND ALL
-@c THE COEFFICIENTS OF X IN A POLYNOMIAL POLY YOU CAN USE
-@c MAP(LAMBDA([POW],COEFF(POLY,X,POW)),POWERS(POLY,X));
-@c AND MANY OTHER SIMILAR USEFUL HACKS.
-
-@opencatbox
-@category{Expressions} @category{Polynomials}
-@closecatbox
-@end deffn
-
-@c -----------------------------------------------------------------------------
-@anchor{product}
-@deffn {Function} product (@var{expr}, @var{i}, @var{i_0}, @var{i_1})
-
-Represents a product of the values of @var{expr} as
-the index @var{i} varies from @var{i_0} to @var{i_1}.
-The noun form @code{'product} is displayed as an uppercase letter pi.
-
-@code{product} evaluates @var{expr} and lower and upper limits @var{i_0} and
-@var{i_1}, @code{product} quotes (does not evaluate) the index @var{i}.
-
-If the upper and lower limits differ by an integer,
-@var{expr} is evaluated for each value of the index @var{i},
-and the result is an explicit product.
-
-Otherwise, the range of the index is indefinite.
-Some rules are applied to simplify the product.
-When the global variable @code{simpproduct} is @code{true}, additional rules
-are applied. In some cases, simplification yields a result which is not a
-product; otherwise, the result is a noun form @code{'product}.
-
-See also @code{nouns} and @code{evflag}.
-
-Examples:
-
-@c ===beg===
-@c product (x + i*(i+1)/2, i, 1, 4);
-@c product (i^2, i, 1, 7);
-@c product (a[i], i, 1, 7);
-@c product (a(i), i, 1, 7);
-@c product (a(i), i, 1, n);
-@c product (k, k, 1, n);
-@c product (k, k, 1, n), simpproduct;
-@c product (integrate (x^k, x, 0, 1), k, 1, n);
-@c product (if k <= 5 then a^k else b^k, k, 1, 10);
-@c ===end===
-
-@example
-(%i1) product (x + i*(i+1)/2, i, 1, 4);
-(%o1) (x + 1) (x + 3) (x + 6) (x + 10)
-(%i2) product (i^2, i, 1, 7);
-(%o2) 25401600
-(%i3) product (a[i], i, 1, 7);
-(%o3) a a a a a a a
- 1 2 3 4 5 6 7
-(%i4) product (a(i), i, 1, 7);
-(%o4) a(1) a(2) a(3) a(4) a(5) a(6) a(7)
-(%i5) product (a(i), i, 1, n);
- n
- /===\
- ! !
-(%o5) ! ! a(i)
- ! !
- i = 1
-(%i6) product (k, k, 1, n);
- n
- /===\
- ! !
-(%o6) ! ! k
- ! !
- k = 1
-(%i7) product (k, k, 1, n), simpproduct;
-(%o7) n!
-(%i8) product (integrate (x^k, x, 0, 1), k, 1, n);
- n
- /===\
- ! ! 1
-(%o8) ! ! -----
- ! ! k + 1
- k = 1
-(%i9) product (if k <= 5 then a^k else b^k, k, 1, 10);
- 15 40
-(%o9) a b
-@end example
-
-@opencatbox
-@category{Sums and products}
-@closecatbox
-@end deffn
-
@c -----------------------------------------------------------------------------
@anchor{psubst}
@deffn {Function} psubst (@var{list}, @var{expr})
@deffnx {Function} psubst (@var{a}, @var{b}, @var{expr})
@code{psubst(@var{a}, @var{b}, @var{expr})} is simliar to @code{subst}. See
-@code{subst}.
+@mrefdot{subst}
In distinction from @code{subst} the function @code{psubst} makes parallel
substitutions, if the first argument @var{list} is a list of equations.
-See also @code{sublis} for making parallel substitutions.
+See also @mref{sublis} for making parallel substitutions.
Example:
@@ -2186,7 +1696,8 @@ Removes boxes from @var{expr}.
@code{rembox (@var{expr})} removes all boxes, labelled and unlabelled.
-Boxes are drawn by the @code{box}, @code{dpart}, and @code{lpart} functions.
+Boxes are drawn by the @mrefcomma{box} @mrefcomma{dpart} and @mref{lpart}@w{}
+functions.
Examples:
@@ -2266,10 +1777,10 @@ Examples:
Makes multiple parallel substitutions into an expression. @var{list} is a list
of equations. The left hand side of the equations must be an atom.
-The variable @code{sublis_apply_lambda} controls simplification after
+The variable @mref{sublis_apply_lambda} controls simplification after
@code{sublis}.
-See also @code{psubst} for making parallel substitutions.
+See also @mref{psubst} for making parallel substitutions.
Example:
@@ -2292,7 +1803,7 @@ Example:
Default value: @code{true}
Controls whether @code{lambda}'s substituted are applied in simplification after
-@code{sublis} is used or whether you have to do an @code{ev} to get things to
+@code{sublis} is used or whether you have to do an @mref{ev} to get things to
apply. @code{true} means do the application.
@opencatbox
@@ -2305,11 +1816,11 @@ apply. @code{true} means do the application.
@defvr {Option variable} subnumsimp
Default value: @code{false}
-If @code{true} then the functions @code{subst} and @code{psubst} can substitute
+If @code{true} then the functions @mref{subst} and @mref{psubst} can substitute
a subscripted variable @code{f[x]} with a number, when only the symbol @code{f}
is given.
-See also @code{subst}.
+See also @mrefdot{subst}
@example
(%i1) subst(100,g,g[x]+2);
@@ -2336,8 +1847,8 @@ subst: cannot substitute 100 for operator g in expression g
Substitutes @var{a} for @var{b} in @var{c}. @var{b} must be an atom or a
complete subexpression of @var{c}. For example, @code{x+y+z} is a complete
subexpression of @code{2*(x+y+z)/w} while @code{x+y} is not. When @var{b} does
-not have these characteristics, one may sometimes use @code{substpart} or
-@code{ratsubst} (see below). Alternatively, if @var{b} is of the form
+not have these characteristics, one may sometimes use @mref{substpart} or
+@mref{ratsubst} (see below). Alternatively, if @var{b} is of the form
@code{e/f} then one could use @code{subst (a*f, e, c)} while if @var{b} is of
the form @code{e^(1/f)} then one could use @code{subst (a^f, e, c)}. The
@code{subst} command also discerns the @code{x^y} in @code{x^-y} so that
@@ -2358,7 +1869,7 @@ expression @var{expr}. The equations are substituted in serial from left to
right in @var{expr}. See the functions @code{sublis} and @code{psubst} for
making parallel substitutions.
-@code{exptsubst} if @code{true} permits substitutions
+@mref{exptsubst} if @code{true} permits substitutions
like @code{y} for @code{%e^x} in @code{%e^(a*x)} to take place.
@c WHAT IS THIS ABOUT ??
@@ -2408,7 +1919,7 @@ For further examples, do @code{example (subst)}.
@anchor{substinpart}
@deffn {Function} substinpart (@var{x}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
-Similar to @code{substpart}, but @code{substinpart} works on the
+Similar to @mrefcomma{substpart} but @code{substinpart} works on the
internal representation of @var{expr}.
Examples:
@@ -2444,10 +1955,10 @@ index of the list. Thus
(%o1) z + x
@end example
-@code{piece} holds the value of the last expression selected when using the
+@mref{piece} holds the value of the last expression selected when using the
@code{part} functions. It is set during the execution of the function and
thus may be referred to in the function itself as shown below.
-If @code{partswitch} is set to @code{true} then @code{end} is returned when a
+If @mref{partswitch} is set to @code{true} then @code{end} is returned when a
selected part of an expression doesn't exist, otherwise an error
message is given.
@@ -2481,8 +1992,8 @@ message is given.
x z
@end example
-Also, setting the option @code{inflag} to @code{true} and calling @code{part}
-or @code{substpart} is the same as calling @code{inpart} or @code{substinpart}.
+Also, setting the option @mref{inflag} to @code{true} and calling @mref{part}
+or @mref{substpart} is the same as calling @mref{inpart} or @code{substinpart}.
@opencatbox
@category{Expressions}
@@ -2496,7 +2007,7 @@ or @code{substpart} is the same as calling @code{inpart} or @code{substinpart}.
@deffn {Function} substpart (@var{x}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
Substitutes @var{x} for the subexpression picked out by the rest of the
-arguments as in @code{part}. It returns the new value of @var{expr}. @var{x}
+arguments as in @mrefdot{part} It returns the new value of @var{expr}. @var{x}
may be some operator to be substituted for an operator of @var{expr}. In some
cases @var{x} needs to be enclosed in double-quotes @code{"} (e.g.
@code{substpart ("+", a*b, 0)} yields @code{b + a}).
@@ -2526,175 +2037,15 @@ Example:
(%o4) x + f(b, y) + a
@end example
-Also, setting the option @code{inflag} to @code{true} and calling @code{part}
-or @code{substpart} is the same as calling @code{inpart} or @code{substinpart}.
+Also, setting the option @mref{inflag} to @code{true} and calling @mref{part}
+or @code{substpart} is the same as calling @code{inpart} or
+@mrefdot{substinpart}
@opencatbox
@category{Expressions}
@closecatbox
@end deffn
-
-@c -----------------------------------------------------------------------------
-@anchor{sum}
-@deffn {Function} sum (@var{expr}, @var{i}, @var{i_0}, @var{i_1})
-
-Represents a summation of the values of @var{expr} as
-the index @var{i} varies from @var{i_0} to @var{i_1}.
-The noun form @code{'sum} is displayed as an uppercase letter sigma.
-
-@code{sum} evaluates its summand @var{expr} and lower and upper limits @var{i_0}
-and @var{i_1}, @code{sum} quotes (does not evaluate) the index @var{i}.
-
-If the upper and lower limits differ by an integer, the summand @var{expr} is
-evaluated for each value of the summation index @var{i}, and the result is an
-explicit sum.
-
-Otherwise, the range of the index is indefinite.
-Some rules are applied to simplify the summation.
-When the global variable @code{simpsum} is @code{true}, additional rules are
-applied. In some cases, simplification yields a result which is not a
-summation; otherwise, the result is a noun form @code{'sum}.
-
-When the @code{evflag} (evaluation flag) @code{cauchysum} is @code{true},
-a product of summations is expressed as a Cauchy product,
-in which the index of the inner summation is a function of the
-index of the outer one, rather than varying independently.
-
-The global variable @code{genindex} is the alphabetic prefix used to generate
-the next index of summation, when an automatically generated index is needed.
-
-@code{gensumnum} is the numeric suffix used to generate the next index of
-summation, when an automatically generated index is needed.
-When @code{gensumnum} is @code{false}, an automatically-generated index is only
-@code{genindex} with no numeric suffix.
-
-See also @code{sumcontract}, @code{intosum},
-@code{bashindices}, @code{niceindices},
-@code{nouns}, @code{evflag}, and @code{zeilberger}.
-
-Examples:
-
-@c ===beg===
-@c sum (i^2, i, 1, 7);
-@c sum (a[i], i, 1, 7);
-@c sum (a(i), i, 1, 7);
-@c sum (a(i), i, 1, n);
-@c sum (2^i + i^2, i, 0, n);
-@c sum (2^i + i^2, i, 0, n), simpsum;
-@c sum (1/3^i, i, 1, inf);
-@c sum (1/3^i, i, 1, inf), simpsum;
-@c sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
-@c sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
-@c sum (integrate (x^k, x, 0, 1), k, 1, n);
-@c sum (if k <= 5 then a^k else b^k, k, 1, 10);
-@c ===end===
-
-@example
-(%i1) sum (i^2, i, 1, 7);
-(%o1) 140
-(%i2) sum (a[i], i, 1, 7);
-(%o2) a + a + a + a + a + a + a
- 7 6 5 4 3 2 1
-(%i3) sum (a(i), i, 1, 7);
-(%o3) a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
-(%i4) sum (a(i), i, 1, n);
- n
- ====
- \
-(%o4) > a(i)
- /
- ====
- i = 1
-(%i5) sum (2^i + i^2, i, 0, n);
- n
- ====
- \ i 2
-(%o5) > (2 + i )
- /
- ====
- i = 0
-(%i6) sum (2^i + i^2, i, 0, n), simpsum;
- 3 2
- n + 1 2 n + 3 n + n
-(%o6) 2 + --------------- - 1
- 6
-(%i7) sum (1/3^i, i, 1, inf);
- inf
- ====
- \ 1
-(%o7) > --
- / i
- ==== 3
- i = 1
-(%i8) sum (1/3^i, i, 1, inf), simpsum;
- 1
-(%o8) -
- 2
-(%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
- inf
- ====
- \ 1
-(%o9) 30 > --
- / 2
- ==== i
- i = 1
-(%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
- 2
-(%o10) 5 %pi
-(%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
- n
- ====
- \ 1
-(%o11) > -----
- / k + 1
- ====
- k = 1
-(%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10);
- 10 9 8 7 6 5 4 3 2
-(%o12) b + b + b + b + b + a + a + a + a + a
-@end example
-
-@opencatbox
-@category{Sums and products}
-@closecatbox
-@end deffn
-
-@c -----------------------------------------------------------------------------
-@anchor{lsum}
-@deffn {Function} lsum (@var{expr}, @var{x}, @var{L})
-
-Represents the sum of @var{expr} for each element @var{x} in @var{L}.
-A noun form @code{'lsum} is returned if the argument @var{L} does not evaluate
-to a list.
-
-Examples:
-
-@c ===beg===
-@c lsum (x^i, i, [1, 2, 7]);
-@c lsum (i^2, i, rootsof (x^3 - 1));
-@c ===end===
-@example
-(%i1) lsum (x^i, i, [1, 2, 7]);
- 7 2
-(%o1) x + x + x
-(%i2) lsum (i^2, i, rootsof (x^3 - 1));
-@group
- ====
- \ 2
-(%o2) > i
- /
- ====
- 3
- i in rootsof(x - 1)
-@end group
-@end example
-
-@opencatbox
-@category{Sums and products}
-@closecatbox
-@end deffn
-
@c -----------------------------------------------------------------------------
@anchor{symbolp}
@deffn {Function} symbolp (@var{expr})
commit 9aae478fdbf4e596d6a02520ea4ab55aae685dd2
Author: crategus <cra...@us...>
Date: Fri Jun 10 19:23:33 2011 +0200
Renaming the chapter Series to Products, Sums, and Series.
Adding a section Sums and Products.
diff --git a/doc/info/include-maxima.texi.in b/doc/info/include-maxima.texi.in
index 6aa4908..4e28ba5 100644
--- a/doc/info/include-maxima.texi.in
+++ b/doc/info/include-maxima.texi.in
@@ -123,7 +123,7 @@ Support for specific areas of mathematics
* itensor:: Indicial Tensor Manipulation.
* ctensor:: Component Tensor Manipulation.
* atensor:: Algebraic Tensor Manipulation.
-* Series:: Taylor and power series.
+* Sums Products and Series:: Sums, Products, Taylor and power series.
* Number Theory:: Number theory.
* Symmetries::
* Groups:: Abstract algebra.
@@ -385,10 +385,12 @@ atensor
* Introduction to atensor::
* Functions and Variables for atensor::
-Series
+Sums, Products, and Series
-* Introduction to Series::
-* Functions and Variables for Series::
+* Sums and Products::
+* Introduction to Series::
+* Functions and Variables for Series::
+* Poisson series::
Number Theory
@@ -812,15 +814,15 @@ zeilberger
@chapter ctensor
@include Ctensor.texi
-@node atensor, Series, ctensor, Top
+@node atensor, Sums Products and Series, ctensor, Top
@chapter atensor
@include Atensor.texi
-@node Series, Number Theory, atensor, Top
-@chapter Series
+@node Sums Products and Series, Number Theory, atensor, Top
+@chapter Sums, Products, and Series
@include Series.texi
-@node Number Theory, Symmetries, Series, Top
+@node Number Theory, Symmetries, Sums Products and Series, Top
@chapter Number Theory
@include Number.texi
commit a4a4344c991b8de6118f0f60c6c1ff710dcbad85
Author: crategus <cra...@us...>
Date: Fri Jun 10 19:21:58 2011 +0200
Reformating and adding nodes for cross references
diff --git a/doc/info/Integration.texi b/doc/info/Integration.texi
index 07ed15c..2618efc 100644
--- a/doc/info/Integration.texi
+++ b/doc/info/Integration.texi
@@ -5,15 +5,17 @@
* Functions and Variables for QUADPACK::
@end menu
+@c -----------------------------------------------------------------------------
@node Introduction to Integration, Functions and Variables for Integration, Integration, Integration
@section Introduction to Integration
+@c -----------------------------------------------------------------------------
Maxima has several routines for handling integration.
The @code{integrate} function makes use of most of them. There is also the
@code{antid} package, which handles an unspecified function (and its
derivatives, of course). For numerical uses,
-there is a set of adaptive integrators from QUADPACK,
-named @code{quad_qag}, @code{quad_qags}, etc., which are described under the heading @code{QUADPACK}.
+there is a set of adaptive integrators from QUADPACK, named @code{quad_qag},
+@code{quad_qags}, etc., which are described under the heading @code{QUADPACK}.
Hypergeometric functions are being worked on,
see @code{specint} for details.
Generally speaking, Maxima only handles integrals which are
@@ -23,14 +25,20 @@ extensions (error function, dilogarithm). It does not handle
integrals in terms of unknown functions such as @code{g(x)} and @code{h(x)}.
@c end concepts Integration
+
+@c -----------------------------------------------------------------------------
@node Functions and Variables for Integration, Introduction to QUADPACK, Introduction to Integration, Integration
@section Functions and Variables for Integration
+@c -----------------------------------------------------------------------------
@c NEEDS WORK
+
+@c -----------------------------------------------------------------------------
+@anchor{changevar}
@deffn {Function} changevar (@var{expr}, @var{f(x,y)}, @var{y}, @var{x})
-Makes the change of variable given by
-@code{@var{f(x,y)} = 0} in all integrals occurring in @var{expr} with integration with
-respect to @var{x}.
+
+Makes the change of variable given by @code{@var{f(x,y)} = 0} in all integrals
+occurring in @var{expr} with integration with respect to @var{x}.
The new variable is @var{y}.
@c HMM, THIS EXAMPLE YIELDS A CORRECT BUT SLIGHTLY STRANGE RESULT...
@@ -60,8 +68,8 @@ The new variable is @var{y}.
@end group
@end example
-An expression containing a noun form, such as the instances of @code{'integrate} above,
-may be evaluated by @code{ev} with the @code{nouns} flag.
+An expression containing a noun form, such as the instances of @code{'integrate}
+above, may be evaluated by @code{ev} with the @code{nouns} flag.
For example, the expression returned by @code{changevar} above may be evaluated
by @code{ev (%o3, nouns)}.
@@ -100,7 +108,11 @@ higher degree function. E.g.,
@c THIS ITEM IS A MESS, BUT DON'T BOTHER TO CLEAN IT UP:
@c THE GAUSS-KRONROD FUNCTIONS (QUADPACK) MAKE THIS OBSOLETE
+
+@c -----------------------------------------------------------------------------
+@anchor{dblint}
@deffn {Function} dblint (@var{f}, @var{r}, @var{s}, @var{a}, @var{b})
+
A double-integral routine which was written in
top-level Maxima and then translated and compiled to machine code.
Use @code{load (dblint)} to access this package. It uses the Simpson's rule
@@ -121,35 +133,34 @@ $$\int_a^b \int_{r\left(x\right)}^{s\left(x\right)} f\left(x,y\right) \, dy \, d
@end example
@end ifnottex
-The function @var{f} must be a translated or compiled function of two
-variables, and @var{r} and @var{s} must each be a translated or compiled
-function of one variable, while @var{a} and @var{b} must be floating point
-numbers. The routine has two global variables which determine the
-number of divisions of the x and y intervals: @code{dblint_x} and @code{dblint_y},
-both of which are initially 10, and can be changed independently to
-other integer values (there are @code{2*dblint_x+1} points computed in the x
-direction, and @code{2*dblint_y+1} in the y direction).
-The routine subdivides the X axis and then for each value of X it
-first computes @code{@var{r}(x)} and @code{@var{s}(x)}; then the Y axis between @code{@var{r}(x)} and @code{@var{s}(x)} is
-subdivided and the integral along the Y axis is performed using
-Simpson's rule; then the integral along the X axis is done using
-Simpson's rule with the function values being the Y-integrals. This
-procedure may be numerically unstable for a great variety of reasons,
-but is reasonably fast: avoid using it on highly oscillatory functions
-and functions with singularities (poles or branch points in the
-region). The Y integrals depend on how far apart @code{@var{r}(x)} and @code{@var{s}(x)} are,
-so if the distance @code{@var{s}(x) - @var{r}(x)} varies rapidly with X, there may be
-substantial errors arising from truncation with different step-sizes
-in the various Y integrals. One can increase @code{dblint_x} and @code{dblint_y} in
-an effort to improve the coverage of the region, at the expense of
-computation time. The function values are not saved, so if the
-function is very time-consuming, you will have to wait for
-re-computation if you change anything (sorry).
-It is required that the functions @var{f}, @var{r}, and @var{s} be either translated or
-compiled prior to calling @code{dblint}. This will result in orders of
-magnitude speed improvement over interpreted code in many cases!
-
-@code{demo (dblint)} executes a demonstration of @code{dblint} applied to an example problem.
+The function @var{f} must be a translated or compiled function of two variables,
+and @var{r} and @var{s} must each be a translated or compiled function of one
+variable, while @var{a} and @var{b} must be floating point numbers. The routine
+has two global variables which determine the number of divisions of the x and y
+intervals: @code{dblint_x} and @code{dblint_y}, both of which are initially 10,
+and can be changed independently to other integer values (there are
+@code{2*dblint_x+1} points computed in the x direction, and @code{2*dblint_y+1}
+in the y direction). The routine subdivides the X axis and then for each value
+of X it first computes @code{@var{r}(x)} and @code{@var{s}(x)}; then the Y axis
+between @code{@var{r}(x)} and @code{@var{s}(x)} is subdivided and the integral
+along the Y axis is performed using Simpson's rule; then the integral along the
+X axis is done using Simpson's rule with the function values being the
+Y-integrals. This procedure may be numerically unstable for a great variety of
+r...
[truncated message content] |
