Menu
▾
▴
[Maxima-commits] Maxima, A Computer Algebra System branch, master, updated. 437d5571d5c6a6f45cd38f112a37ff1b4843c8ee
|
From: Dieter K. <cra...@us...> - 2011-06-12 11:36:55
|
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 437d5571d5c6a6f45cd38f112a37ff1b4843c8ee (commit)
via f4b3286aee44bbcee344eabdff3b7cf4aace8e57 (commit)
via bf3bb4ef85d2a6477ba4736a880eeea8b807998b (commit)
via 14d0bc6c44fcc74319fa90c0d5561f60f88f550c (commit)
via 5cb48d53140f4e1d9cae88edfdeb9b5ec60dd096 (commit)
via 203d957539e3e5b3a85e9cf12008b314b1e65e53 (commit)
via 37cc136a04ef3c991947c1c57899e345d1f5adc4 (commit)
via e78600be139fb21dccb521429c956d8cc382f51e (commit)
via 074191b192b0c573a8447dec8743787ebb62443b (commit)
via 886876105b4c206c526149f0df222f6ee2cc61ff (commit)
via 047fa24d692811ca0cc37009564f546de14decaf (commit)
via f8d012c99d7aaffbb8459acaccb5503c2e7b7ade (commit)
via 835c3658b6d42a1afa303dd3277895bfe9a1d5a1 (commit)
via 8ad0af566fa3e97d7dce84698596ef26a7ebbe3e (commit)
via e565ada1e17e61709f84da52461300a32a114c61 (commit)
via 896a73ba7239dedaa5563ad2e79301ae6bc16bb7 (commit)
via 67d94f91404307a37304c111cf7d170680c42f66 (commit)
via 4ab34449b64497574ad7886fd63ffb49cb079d26 (commit)
from 4653cb5bf7a6d905e48ed2a0e07bbf363b6338fb (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 437d5571d5c6a6f45cd38f112a37ff1b4843c8ee
Author: crategus <cra...@us...>
Date: Sun Jun 12 13:33:12 2011 +0200
Moving documentation for sqrtdispflag to Command.texi.
diff --git a/doc/info/MathFunctions.texi b/doc/info/MathFunctions.texi
index 806664b..e4f7597 100644
--- a/doc/info/MathFunctions.texi
+++ b/doc/info/MathFunctions.texi
@@ -866,20 +866,6 @@ which are powers of n to be pulled outside of the radical, e.g.
@end deffn
@c -----------------------------------------------------------------------------
-@anchor{sqrtdispflag}
-@defvr {Option variable} sqrtdispflag
-Default value: @code{true}
-
-When @code{sqrtdispflag} is @code{false}, causes @code{sqrt} to display with
-exponent 1/2.
-@c AND OTHERWISE ... ??
-
-@opencatbox
-@category{Mathematical functions} @category{Display flags and variables}
-@closecatbox
-@end defvr
-
-@c -----------------------------------------------------------------------------
@node Trigonometric Functions, Hyperbolic Functions, Root Exponential and Logarithmic Functions, Mathematical Functions
@section Trigonometric Functions
@c -----------------------------------------------------------------------------
commit f4b3286aee44bbcee344eabdff3b7cf4aace8e57
Author: crategus <cra...@us...>
Date: Sun Jun 12 13:32:27 2011 +0200
Reformating and adding nodes for cross references.
diff --git a/doc/info/Numerical.texi b/doc/info/Numerical.texi
index 1a25920..4d653dc 100644
--- a/doc/info/Numerical.texi
+++ b/doc/info/Numerical.texi
@@ -5,26 +5,31 @@
* Functions and Variables for Fourier series::
@end menu
+@c -----------------------------------------------------------------------------
@node Introduction to fast Fourier transform, Functions and Variables for fast Fourier transform, Numerical, Numerical
@section Introduction to fast Fourier transform
+@c -----------------------------------------------------------------------------
-The @code{fft} package comprises functions for the numerical (not symbolic) computation
-of the fast Fourier transform.
+The @code{fft} package comprises functions for the numerical (not symbolic)
+computation of the fast Fourier transform.
@opencatbox
@category{Fourier transform} @category{Numerical methods} @category{Share packages} @category{Package fft}
@closecatbox
-
@c end concepts Numerical
+@c -----------------------------------------------------------------------------
@node Functions and Variables for fast Fourier transform, Introduction to Fourier series, Introduction to fast Fourier transform, Numerical
@section Functions and Variables for fast Fourier transform
+@c -----------------------------------------------------------------------------
+@c -----------------------------------------------------------------------------
+@anchor{polartorect}
@deffn {Function} polartorect (@var{r}, @var{t})
-Translates complex values of the form @code{r %e^(%i t)} to the form @code{a + b %i},
-where @var{r} is the magnitude and @var{t} is the phase.
+Translates complex values of the form @code{r %e^(%i t)} to the form
+@code{a + b %i}, where @var{r} is the magnitude and @var{t} is the phase.
@var{r} and @var{t} are 1-dimensional arrays of the same size.
The array size need not be a power of 2.
@@ -39,18 +44,20 @@ b = r sin(t)
@code{polartorect} is the inverse function of @code{recttopolar}.
-@code{load(fft)} loads this function. See also @code{fft}.
+@code{load(fft)} loads this function. See also @code{fft}.
@opencatbox
@category{Package fft} @category{Complex variables}
@closecatbox
@end deffn
+@c -----------------------------------------------------------------------------
+@anchor{recttopolar}
@deffn {Function} recttopolar (@var{a}, @var{b})
-Translates complex values of the form @code{a + b %i} to the form @code{r %e^(%i t)},
-where @var{a} is the real part and @var{b} is the imaginary part.
-@var{a} and @var{b} are 1-dimensional arrays of the same size.
+Translates complex values of the form @code{a + b %i} to the form
+@code{r %e^(%i t)}, where @var{a} is the real part and @var{b} is the imaginary
+part. @var{a} and @var{b} are 1-dimensional arrays of the same size.
The array size need not be a power of 2.
The original values of the input arrays are
@@ -62,22 +69,24 @@ r = sqrt(a^2 + b^2)
t = atan2(b, a)
@end example
-The computed angle is in the range @code{-%pi} to @code{%pi}.
+The computed angle is in the range @code{-%pi} to @code{%pi}.
@code{recttopolar} is the inverse function of @code{polartorect}.
-@code{load(fft)} loads this function. See also @code{fft}.
+@code{load(fft)} loads this function. See also @code{fft}.
@opencatbox
@category{Package fft} @category{Complex variables}
@closecatbox
@end deffn
+@c -----------------------------------------------------------------------------
+@anchor{inverse_fft}
@deffn {Function} inverse_fft (@var{y})
Computes the inverse complex fast Fourier transform.
-@var{y} is a list or array (named or unnamed) which contains the data to transform.
-The number of elements must be a power of 2.
+@var{y} is a list or array (named or unnamed) which contains the data to
+transform. The number of elements must be a power of 2.
The elements must be literal numbers (integers, rationals, floats, or bigfloats)
or symbolic constants,
or expressions @code{a + b*%i} where @code{a} and @code{b} are literal numbers
@@ -98,7 +107,8 @@ x[j] = sum(y[k] exp(+2 %i %pi j k / n), k, 0, n - 1)
@code{load(fft)} loads this function.
-See also @code{fft} (forward transform), @code{recttopolar}, and @code{polartorect}.
+See also @code{fft} (forward transform), @code{recttopolar}, and
+@code{polartorect}.
Examples:
@@ -156,14 +166,15 @@ Complex data.
@opencatbox
@category{Package fft}
@closecatbox
-
@end deffn
+@c -----------------------------------------------------------------------------
+@anchor{fft}
@deffn {Function} fft (@var{x})
Computes the complex fast Fourier transform.
-@var{x} is a list or array (named or unnamed) which contains the data to transform.
-The number of elements must be a power of 2.
+@var{x} is a list or array (named or unnamed) which contains the data to
+transform. The number of elements must be a power of 2.
The elements must be literal numbers (integers, rationals, floats, or bigfloats)
or symbolic constants,
or expressions @code{a + b*%i} where @code{a} and @code{b} are literal numbers
@@ -212,7 +223,8 @@ b[n/2] = 0
@code{load(fft)} loads this function.
-See also @code{inverse_fft} (inverse transform), @code{recttopolar}, and @code{polartorect}.
+See also @code{inverse_fft} (inverse transform), @code{recttopolar}, and
+@code{polartorect}.
Examples:
@@ -322,9 +334,10 @@ Computation of sine and cosine coefficients.
@opencatbox
@category{Package fft}
@closecatbox
-
@end deffn
+@c -----------------------------------------------------------------------------
+@anchor{fortindent}
@defvr {Option variable} fortindent
Default value: 0
@@ -336,27 +349,30 @@ expressions to be printed farther to the right.
@opencatbox
@category{Translation and compilation}
@closecatbox
-
@end defvr
+@c -----------------------------------------------------------------------------
+@anchor{fortran}
@deffn {Function} fortran (@var{expr})
+
Prints @var{expr} as a Fortran statement.
The output line is indented with spaces.
If the line is too long, @code{fortran} prints continuation lines.
@code{fortran} prints the exponentiation operator @code{^} as @code{**},
and prints a complex number @code{a + b %i} in the form @code{(a,b)}.
-@var{expr} may be an equation. If so, @code{fortran} prints an assignment
+@var{expr} may be an equation. If so, @code{fortran} prints an assignment
statement, assigning the right-hand side of the equation to the left-hand side.
In particular, if the right-hand side of @var{expr} is the name of a matrix,
-then @code{fortran} prints an assignment statement for each element of the matrix.
+then @code{fortran} prints an assignment statement for each element of the
+matrix.
If @var{expr} is not something recognized by @code{fortran},
the expression is printed in @code{grind} format without complaint.
@code{fortran} does not know about lists, arrays, or functions.
@code{fortindent} controls the left margin of the printed lines.
-0 is the normal margin (i.e., indented 6 spaces). Increasing @code{fortindent}
+0 is the normal margin (i.e., indented 6 spaces). Increasing @code{fortindent}
causes expressions to be printed further to the right.
When @code{fortspaces} is @code{true}, @code{fortran} fills out
@@ -396,9 +412,10 @@ Examples:
@opencatbox
@category{Translation and compilation}
@closecatbox
-
@end deffn
+@c -----------------------------------------------------------------------------
+@anchor{fortspaces}
@defvr {Option variable} fortspaces
Default value: @code{false}
@@ -408,19 +425,21 @@ each printed line with spaces to 80 columns.
@opencatbox
@category{Translation and compilation}
@closecatbox
-
@end defvr
-@deffn {Function} horner (@var{expr}, @var{x})
+@c -----------------------------------------------------------------------------
+@anchor{horner}
+@deffn {Function} horner (@var{expr}, @var{x})
@deffnx {Function} horner (@var{expr})
-Returns a rearranged representation of @var{expr} as
-in Horner's rule, using @var{x} as the main variable if it is specified.
-@code{x} may be omitted in which case the main variable of the canonical rational expression
-form of @var{expr} is used.
+
+Returns a rearranged representation of @var{expr} as in Horner's rule, using
+@var{x} as the main variable if it is specified. @code{x} may be omitted in
+which case the main variable of the canonical rational expression form of
+@var{expr} is used.
@code{horner} sometimes improves stability if @code{expr} is
to be numerically evaluated. It is also useful if Maxima is used to
-generate programs to be run in Fortran. See also @code{stringout}.
+generate programs to be run in Fortran. See also @code{stringout}.
@example
(%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155;
@@ -442,10 +461,15 @@ To reenable the Lisp debugger set *debugger-hook* to nil.
@opencatbox
@category{Numerical methods}
@closecatbox
-
@end deffn
-@deffn {Function} find_root (@var{expr}, @var{x}, @var{a}, @var{b}, [@var{abserr}, @var{relerr}])
+@c -----------------------------------------------------------------------------
+@anchor{find_root}
+@anchor{bf_find_root}
+@anchor{find_root_error}
+@anchor{find_root_abs}
+@anchor{find_root_rel}
+@deffn {Function} find_root (@var{expr}, @var{x}, @var{a}, @var{b}, [@var{abserr}, @var{relerr}])
@deffnx {Function} find_root (@var{f}, @var{a}, @var{b}, [@var{abserr}, @var{relerr}])
@deffnx {Function} bf_find_root (@var{expr}, @var{x}, @var{a}, @var{b}, [@var{abserr}, @var{relerr}])
@deffnx {Function} bf_find_root (@var{f}, @var{a}, @var{b}, [@var{abserr}, @var{relerr}])
@@ -453,13 +477,13 @@ To reenable the Lisp debugger set *debugger-hook* to nil.
@deffnx {Option variable} find_root_abs
@deffnx {Option variable} find_root_rel
-Finds a root of the expression @var{expr} or the function @var{f}
-over the closed interval @math{[@var{a}, @var{b}]}.
-The expression @var{expr} may be an equation,
-in which case @code{find_root} seeks a root of @code{lhs(@var{expr}) - rhs(@var{expr})}.
+Finds a root of the expression @var{expr} or the function @var{f} over the
+closed interval @math{[@var{a}, @var{b}]}. The expression @var{expr} may be an
+equation, in which case @code{find_root} seeks a root of
+@code{lhs(@var{expr}) - rhs(@var{expr})}.
-Given that Maxima can evaluate @var{expr} or @var{f} over @math{[@var{a}, @var{b}]}
-and that @var{expr} or @var{f} is continuous,
+Given that Maxima can evaluate @var{expr} or @var{f} over
+@math{[@var{a}, @var{b}]} and that @var{expr} or @var{f} is continuous,
@code{find_root} is guaranteed to find the root,
or one of the roots if there is more than one.
@@ -471,7 +495,7 @@ If the function in question appears to be smooth enough,
function is computed using bigfloat arithmetic and a bigfloat result
is returned. Otherwise, @code{bf_find_root} is identical to
@code{find_root}, and the following description is equally applicable
-to @code{bf_find_root}.
+to @code{bf_find_root}.
The accuracy of @code{find_root} is governed by @code{abserr} and
@code{relerr}, which are optional keyword arguments to
@@ -481,7 +505,7 @@ The accuracy of @code{find_root} is governed by @code{abserr} and
@table @var
@item abserr
Desired absolute error of function value at root. Default is
-@code{find_root_abs}.
+@code{find_root_abs}.
@item relerr
Desired relative error of root. Default is @code{find_root_rel}.
@end table
@@ -492,8 +516,8 @@ approximants @var{x_0}, @var{x_1} differ by no more than @code{relerr
* max(abs(x_0), abs(x_1))}. The default values of
@code{find_root_abs} and @code{find_root_rel} are both zero.
-@code{find_root} expects the function in question to have a different sign at the endpoints
-of the search interval.
+@code{find_root} expects the function in question to have a different sign at
+the endpoints of the search interval.
When the function evaluates to a number at both endpoints
and these numbers have the same sign,
the behavior of @code{find_root} is governed by @code{find_root_error}.
@@ -502,13 +526,15 @@ When @code{find_root_error} is @code{true},
Otherwise @code{find_root} returns the value of @code{find_root_error}.
The default value of @code{find_root_error} is @code{true}.
-If @var{f} evaluates to something other than a number at any step in the search algorithm,
-@code{find_root} returns a partially-evaluated @code{find_root} expression.
+If @var{f} evaluates to something other than a number at any step in the search
+algorithm, @code{find_root} returns a partially-evaluated @code{find_root}
+expression.
-The order of @var{a} and @var{b} is ignored;
-the region in which a root is sought is @math{[min(@var{a}, @var{b}), max(@var{a}, @var{b})]}.
+The order of @var{a} and @var{b} is ignored; the region in which a root is
+sought is @math{[min(@var{a}, @var{b}), max(@var{a}, @var{b})]}.
Examples:
+
@c PREVIOUS EXAMPLE STUFF -- MAY WANT TO BRING TRANSLATE BACK INTO THE EXAMPLE
@c f(x):=(mode_declare(x,float),sin(x)-x/2.0);
@c interpolate(sin(x)-x/2,x,0.1,%pi) time= 60 msec
@@ -562,10 +588,12 @@ Examples:
@opencatbox
@category{Algebraic equations} @category{Numerical methods}
@closecatbox
-
@end deffn
+@c -----------------------------------------------------------------------------
+@anchor{newton}
@deffn {Function} newton (@var{expr}, @var{x}, @var{x_0}, @var{eps})
+
Returns an approximate solution of @code{@var{expr} = 0} by Newton's method,
considering @var{expr} to be a function of one variable, @var{x}.
The search begins with @code{@var{x} = @var{x_0}}
@@ -579,7 +607,8 @@ Thus it is not necessary that @var{expr} evaluate to a number.
@code{load(newton1)} loads this function.
-See also @code{realroots}, @code{allroots}, @code{find_root}, and @code{mnewton}.
+See also @code{realroots}, @code{allroots}, @code{find_root}, and
+@code{mnewton}.
Examples:
@@ -610,12 +639,12 @@ Examples:
@opencatbox
@category{Algebraic equations} @category{Numerical methods}
@closecatbox
-
@end deffn
-
+@c -----------------------------------------------------------------------------
@node Introduction to Fourier series, Functions and Variables for Fourier series, Functions and Variables for fast Fourier transform, Numerical
@section Introduction to Fourier series
+@c -----------------------------------------------------------------------------
The @code{fourie} package comprises functions for the symbolic computation
of Fourier series.
@@ -626,14 +655,19 @@ coefficients and some functions for manipulation of expressions.
@category{Fourier transform} @category{Share packages} @category{Package fourie}
@closecatbox
-
+@c -----------------------------------------------------------------------------
@node Functions and Variables for Fourier series, , Introduction to Fourier series, Numerical
@section Functions and Variables for Fourier series
+@c -----------------------------------------------------------------------------
@c REPHRASE
+
+@c -----------------------------------------------------------------------------
+@anchor{equalp}
@deffn {Function} equalp (@var{x}, @var{y})
-Returns @code{true} if @code{equal (@var{x}, @var{y})} otherwise @code{false} (doesn't give an
-error message like @code{equal (x, y)} would do in this case).
+
+Returns @code{true} if @code{equal (@var{x}, @var{y})} otherwise @code{false}
+(doesn't give an error message like @code{equal (x, y)} would do in this case).
@c NEEDS EXAMPLES
@opencatbox
@@ -641,14 +675,17 @@ error message like @code{equal (x, y)} would do in this case).
@closecatbox
@end deffn
-@deffn {Function} remfun (@var{f}, @var{expr})
+@c -----------------------------------------------------------------------------
+@anchor{remfun}
+@deffn {Function} remfun (@var{f}, @var{expr})
@deffnx {Function} remfun (@var{f}, @var{expr}, @var{x})
-@code{remfun (@var{f}, @var{expr})}
-replaces all occurrences of @code{@var{f} (@var{arg})} by @var{arg} in @var{expr}.
-@code{remfun (@var{f}, @var{expr}, @var{x})}
-replaces all occurrences of @code{@var{f} (@var{arg})} by @var{arg} in @var{expr}
-only if @var{arg} contains the variable @var{x}.
+@code{remfun (@var{f}, @var{expr})} replaces all occurrences of @code{@var{f}
+(@var{arg})} by @var{arg} in @var{expr}.
+
+@code{remfun (@var{f}, @var{expr}, @var{x})} replaces all occurrences of
+@code{@var{f} (@var{arg})} by @var{arg} in @var{expr} only if @var{arg} contains
+the variable @var{x}.
@c NEEDS EXAMPLES
@opencatbox
@@ -656,8 +693,11 @@ only if @var{arg} contains the variable @var{x}.
@closecatbox
@end deffn
-@deffn {Function} funp (@var{f}, @var{expr})
+@c -----------------------------------------------------------------------------
+@anchor{funp}
+@deffn {Function} funp (@var{f}, @var{expr})
@deffnx {Function} funp (@var{f}, @var{expr}, @var{x})
+
@code{funp (@var{f}, @var{expr})}
returns @code{true} if @var{expr} contains the function @var{f}.
@@ -671,19 +711,23 @@ returns @code{true} if @var{expr} contains the function @var{f} and the variable
@closecatbox
@end deffn
-@deffn {Function} absint (@var{f}, @var{x}, @var{halfplane})
+@c -----------------------------------------------------------------------------
+@anchor{absint}
+@deffn {Function} absint (@var{f}, @var{x}, @var{halfplane})
@deffnx {Function} absint (@var{f}, @var{x})
@deffnx {Function} absint (@var{f}, @var{x}, @var{a}, @var{b})
+
@code{absint (@var{f}, @var{x}, @var{halfplane})}
returns the indefinite integral of @var{f} with respect to
@var{x} in the given halfplane (@code{pos}, @code{neg}, or @code{both}).
@var{f} may contain expressions of the form
@code{abs (x)}, @code{abs (sin (x))}, @code{abs (a) * exp (-abs (b) * abs (x))}.
-@code{absint (@var{f}, @var{x})} is equivalent to @code{absint (@var{f}, @var{x}, pos)}.
+@code{absint (@var{f}, @var{x})} is equivalent to
+@code{absint (@var{f}, @var{x}, pos)}.
-@code{absint (@var{f}, @var{x}, @var{a}, @var{b})}
-returns the definite integral of @var{f} with respect to @var{x} from @var{a} to @var{b}.
+@code{absint (@var{f}, @var{x}, @var{a}, @var{b})} returns the definite integral
+of @var{f} with respect to @var{x} from @var{a} to @var{b}.
@c SAME LIST AS ABOVE ??
@var{f} may include absolute values.
@@ -694,7 +738,11 @@ returns the definite integral of @var{f} with respect to @var{x} from @var{a} to
@end deffn
@c NEEDS EXPANSION
+
+@c -----------------------------------------------------------------------------
+@anchor{fourier}
@deffn {Function} fourier (@var{f}, @var{x}, @var{p})
+
Returns a list of the Fourier coefficients of @code{@var{f}(@var{x})} defined
on the interval @code{[-p, p]}.
@@ -705,7 +753,11 @@ on the interval @code{[-p, p]}.
@end deffn
@c NEES EXPANSION. WHAT IS THE ARGUMENT l ??
+
+@c -----------------------------------------------------------------------------
+@anchor{foursimp}
@deffn {Function} foursimp (@var{l})
+
Simplifies @code{sin (n %pi)} to 0 if @code{sinnpiflag} is @code{true} and
@code{cos (n %pi)} to @code{(-1)^n} if @code{cosnpiflag} is @code{true}.
@@ -715,6 +767,8 @@ Simplifies @code{sin (n %pi)} to 0 if @code{sinnpiflag} is @code{true} and
@closecatbox
@end deffn
+@c -----------------------------------------------------------------------------
+@anchor{sinnpiflag}
@defvr {Option variable} sinnpiflag
Default value: @code{true}
@@ -723,9 +777,10 @@ See @code{foursimp}.
@opencatbox
@category{Package fourie}
@closecatbox
-
@end defvr
+@c -----------------------------------------------------------------------------
+@anchor{cosnpiflag}
@defvr {Option variable} cosnpiflag
Default value: @code{true}
@@ -734,15 +789,17 @@ See @code{foursimp}.
@opencatbox
@category{Package fourie}
@closecatbox
-
@end defvr
@c NEEDS EXPANSION. EXPLAIN x AND p HERE (DO NOT REFER SOMEWHERE ELSE)
+
+@c -----------------------------------------------------------------------------
+@anchor{fourexpand}
@deffn {Function} fourexpand (@var{l}, @var{x}, @var{p}, @var{limit})
-Constructs and returns the Fourier series from the list of
-Fourier coefficients @var{l} up through @var{limit} terms (@var{limit}
-may be @code{inf}). @var{x} and @var{p} have same meaning as in
-@code{fourier}.
+
+Constructs and returns the Fourier series from the list of Fourier coefficients
+@var{l} up through @var{limit} terms (@var{limit} may be @code{inf}). @var{x}
+and @var{p} have same meaning as in @code{fourier}.
@c NEEDS EXAMPLES
@opencatbox
@@ -751,8 +808,13 @@ may be @code{inf}). @var{x} and @var{p} have same meaning as in
@end deffn
@c NEEDS EXPANSION
+
+@c -----------------------------------------------------------------------------
+@anchor{fourcos}
@deffn {Function} fourcos (@var{f}, @var{x}, @var{p})
-Returns the Fourier cosine coefficients for @code{@var{f}(@var{x})} defined on @code{[0, @var{p}]}.
+
+Returns the Fourier cosine coefficients for @code{@var{f}(@var{x})} defined on
+@code{[0, @var{p}]}.
@c NEEDS EXAMPLES
@opencatbox
@@ -761,8 +823,13 @@ Returns the Fourier cosine coefficients for @code{@var{f}(@var{x})} defined on @
@end deffn
@c NEEDS EXPANSION
+
+@c -----------------------------------------------------------------------------
+@anchor{foursin}
@deffn {Function} foursin (@var{f}, @var{x}, @var{p})
-Returns the Fourier sine coefficients for @code{@var{f}(@var{x})} defined on @code{[0, @var{p}]}.
+
+Returns the Fourier sine coefficients for @code{@var{f}(@var{x})} defined on
+@code{[0, @var{p}]}.
@c NEEDS EXAMPLES
@opencatbox
@@ -771,8 +838,13 @@ Returns the Fourier sine coefficients for @code{@var{f}(@var{x})} defined on @co
@end deffn
@c NEEDS EXPANSION
+
+@c -----------------------------------------------------------------------------
+@anchor{totalfourier}
@deffn {Function} totalfourier (@var{f}, @var{x}, @var{p})
-Returns @code{fourexpand (foursimp (fourier (@var{f}, @var{x}, @var{p})), @var{x}, @var{p}, 'inf)}.
+
+Returns @code{fourexpand (foursimp (fourier (@var{f}, @var{x}, @var{p})),
+@var{x}, @var{p}, 'inf)}.
@c NEEDS EXAMPLES
@opencatbox
@@ -781,9 +853,13 @@ Returns @code{fourexpand (foursimp (fourier (@var{f}, @var{x}, @var{p})), @var{x
@end deffn
@c NEEDS EXPANSION
+
+@c -----------------------------------------------------------------------------
+@anchor{fourint}
@deffn {Function} fourint (@var{f}, @var{x})
-Constructs and returns a list of the Fourier integral coefficients of @code{@var{f}(@var{x})}
-defined on @code{[minf, inf]}.
+
+Constructs and returns a list of the Fourier integral coefficients of
+@code{@var{f}(@var{x})} defined on @code{[minf, inf]}.
@c NEEDS EXAMPLES
@opencatbox
@@ -792,8 +868,13 @@ defined on @code{[minf, inf]}.
@end deffn
@c NEEDS EXPANSION
+
+@c -----------------------------------------------------------------------------
+@anchor{fourintcos}
@deffn {Function} fourintcos (@var{f}, @var{x})
-Returns the Fourier cosine integral coefficients for @code{@var{f}(@var{x})} on @code{[0, inf]}.
+
+Returns the Fourier cosine integral coefficients for @code{@var{f}(@var{x})}
+on @code{[0, inf]}.
@c NEEDS EXAMPLES
@opencatbox
@@ -802,11 +883,17 @@ Returns the Fourier cosine integral coefficients for @code{@var{f}(@var{x})} on
@end deffn
@c NEEDS EXPANSION
+
+@c -----------------------------------------------------------------------------
+@anchor{forintsin}
@deffn {Function} fourintsin (@var{f}, @var{x})
-Returns the Fourier sine integral coefficients for @code{@var{f}(@var{x})} on @code{[0, inf]}.
+
+Returns the Fourier sine integral coefficients for @code{@var{f}(@var{x})} on
+@code{[0, inf]}.
@c NEEDS EXAMPLES
@opencatbox
@category{Package fourie}
@closecatbox
@end deffn
+
commit bf3bb4ef85d2a6477ba4736a880eeea8b807998b
Author: crategus <cra...@us...>
Date: Sun Jun 12 13:25:13 2011 +0200
Adding documentation for matchfix from Rules.texi
Adding cross references.
diff --git a/doc/info/Operators.texi b/doc/info/Operators.texi
index 724827a..fd60e5f 100644
--- a/doc/info/Operators.texi
+++ b/doc/info/Operators.texi
@@ -68,8 +68,8 @@ Division and exponentiation are binary, noncommutative operators.
Maxima sorts the operands of commutative operators to construct a canonical
representation. For internal storage, the ordering is determined by
-@code{orderlessp}. For display, the ordering for addition is determined by
-@code{ordergreatp}, and for multiplication, it is the same as the internal
+@mrefdot{orderlessp} For display, the ordering for addition is determined by
+@mrefcomma{ordergreatp} and for multiplication, it is the same as the internal
ordering.
Arithmetic computations are carried out on literal numbers (integers, rationals,
@@ -77,7 +77,7 @@ ordinary floats, and bigfloats). Except for exponentiation, all arithmetic
operations on numbers are simplified to numbers. Exponentiation is simplified
to a number if either operand is an ordinary float or bigfloat or if the result
is an exact integer or rational; otherwise an exponentiation may be simplified
-to @code{sqrt} or another exponentiation or left unchanged.
+to @mref{sqrt} or another exponentiation or left unchanged.
Floating-point contagion applies to arithmetic computations: if any operand is
a bigfloat, the result is a bigfloat; otherwise, if any operand is an ordinary
@@ -88,7 +88,7 @@ Arithmetic computations are a simplification, not an evaluation.
Thus arithmetic is carried out in quoted (but simplified) expressions.
Arithmetic operations are applied element-by-element to lists when the global
-flag @code{listarith} is @code{true}, and always applied element-by-element to
+flag @mref{listarith} is @code{true}, and always applied element-by-element to
matrices. When one operand is a list or matrix and another is an operand of
some other type, the other operand is combined with each of the elements of the
list or matrix.
@@ -253,11 +253,11 @@ Arithmetic is carried out element-by-element for lists (depending on
@deffn {Operator} **
Exponentiation operator.
-Maxima recognizes @code{**} as the same operator as @code{^} in input,
+Maxima recognizes @code{**} as the same operator as @mref{^} in input,
and it is displayed as @code{^} in 1-dimensional output,
or by placing the exponent as a superscript in 2-dimensional output.
-The @code{fortran} function displays the exponentiation operator as @code{**},
+The @mref{fortran} function displays the exponentiation operator as @code{**},
whether it was input as @code{**} or @code{^}.
Examples:
@@ -387,17 +387,17 @@ These relational operators are all binary operators; constructs such as
@code{a < b < c} are not recognized by Maxima.
Relational expressions are evaluated to Boolean values by the functions
-@code{is} and @code{maybe}, and the programming constructs @code{if},
-@code{while}, and @code{unless}. Relational expressions are not otherwise
-evaluated or simplified to Boolean values, although the arguments of relational
-expressions are evaluated (when evaluation is not otherwise prevented by
-quotation).
+@mref{is} and @mrefcomma{maybe} and the programming constructs
+@mrefcomma{if} @mrefcomma{while} and @mrefdot{unless} Relational expressions
+are not otherwise evaluated or simplified to Boolean values, although the
+arguments of relational expressions are evaluated (when evaluation is not
+otherwise prevented by quotation).
When a relational expression cannot be evaluated to @code{true} or @code{false},
the behavior of @code{is} and @code{if} are governed by the global flag
-@code{prederror}. When @code{prederror} is @code{true}, @code{is} and @code{if}
-trigger an error. When @code{prederror} is @code{false}, @code{is} returns
-@code{unknown}, and @code{if} returns a partially-evaluated conditional
+@mrefdot{prederror} When @code{prederror} is @code{true}, @code{is} and
+@code{if} trigger an error. When @code{prederror} is @code{false}, @code{is}
+returns @code{unknown}, and @code{if} returns a partially-evaluated conditional
expression.
@code{maybe} always behaves as if @code{prederror} were @code{false}, and
@@ -406,7 +406,7 @@ expression.
Relational operators do not distribute over lists or other aggregates.
-See also @code{=} @code{#} @code{equal} and @code{notequal}.
+See also @mrefcomma{=} @mrefcomma{#} @mrefcomma{equal} and @mrefdot{notequal}
Examples:
@@ -473,7 +473,7 @@ values, although the arguments of relational expressions are evaluated.
The logical conjunction operator. @code{and} is an n-ary infix operator;
its operands are Boolean expressions, and its result is a Boolean value.
-@code{and} forces evaluation (like @code{is}) of one or more operands,
+@code{and} forces evaluation (like @mref{is}) of one or more operands,
and may force evaluation of all operands.
Operands are evaluated in the order in which they appear. @code{and} evaluates
@@ -481,7 +481,7 @@ only as many of its operands as necessary to determine the result. If any
operand is @code{false}, the result is @code{false} and no further operands are
evaluated.
-The global flag @code{prederror} governs the behavior of @code{and} when an
+The global flag @mref{prederror} governs the behavior of @code{and} when an
evaluated operand cannot be determined to be @code{true} or @code{false}.
@code{and} prints an error message when @code{prederror} is @code{true}.
Otherwise, operands which do not evaluate to @code{true} or @code{false} are
@@ -509,7 +509,7 @@ its operand is a Boolean expression, and its result is a Boolean value.
@code{not} forces evaluation (like @code{is}) of its operand.
-The global flag @code{prederror} governs the behavior of @code{not} when its
+The global flag @mref{prederror} governs the behavior of @code{not} when its
operand cannot be determined to be @code{true} or @code{false}. @code{not}
prints an error message when @code{prederror} is @code{true}. Otherwise,
operands which do not evaluate to @code{true} or @code{false} are accepted,
@@ -532,7 +532,7 @@ and the result is a Boolean expression.
The logical disjunction operator. @code{or} is an n-ary infix operator;
its operands are Boolean expressions, and its result is a Boolean value.
-@code{or} forces evaluation (like @code{is}) of one or more operands,
+@code{or} forces evaluation (like @mref{is}) of one or more operands,
and may force evaluation of all operands.
Operands are evaluated in the order in which they appear. @code{or} evaluates
@@ -540,7 +540,7 @@ only as many of its operands as necessary to determine the result. If any
operand is @code{true}, the result is @code{true} and no further operands are
evaluated.
-The global flag @code{prederror} governs the behavior of @code{or} when an
+The global flag @mref{prederror} governs the behavior of @code{or} when an
evaluated operand cannot be determined to be @code{true} or @code{false}.
@code{or} prints an error message when @code{prederror} is @code{true}.
Otherwise, operands which do not evaluate to @code{true} or @code{false} are
@@ -566,7 +566,7 @@ due to the treatment of indeterminate operands.
@fnindex Not equal (syntactic inequality)
@end ifinfo
-Represents the negation of syntactic equality @code{=}.
+Represents the negation of syntactic equality @mrefdot{=}
Note that because of the rules for evaluation of predicate expressions
(in particular because @code{not @var{expr}} causes evaluation of @var{expr}),
@@ -615,9 +615,9 @@ The equation operator.
An expression @code{@var{a} = @var{b}}, by itself, represents an unevaluated
equation, which might or might not hold. Unevaluated equations may appear as
-arguments to @code{solve} and @code{algsys} or some other functions.
+arguments to @mref{solve} and @mref{algsys} or some other functions.
-The function @code{is} evaluates @code{=} to a Boolean value.
+The function @mref{is} evaluates @code{=} to a Boolean value.
@code{is(@var{a} = @var{b})} evaluates @code{@var{a} = @var{b}} to @code{true}
when @var{a} and @var{b} are identical. That is, @var{a} and @var{b} are atoms
which are identical, or they are not atoms and their operators are identical and
@@ -628,24 +628,24 @@ syntactically equal, in contrast to equivalent expressions, for which
@code{is(equal(@var{a}, @var{b}))} is @code{true}. Expressions can be
equivalent and not syntactically equal.
-The negation of @code{=} is represented by @code{#}.
+The negation of @code{=} is represented by @mrefdot{#}
As with @code{=}, an expression @code{@var{a} # @var{b}}, by itself, is not
evaluated. @code{is(@var{a} # @var{b})} evaluates @code{@var{a} # @var{b}} to
@code{true} or @code{false}.
In addition to @code{is}, some other operators evaluate @code{=} and @code{#}
-to @code{true} or @code{false}, namely @code{if}, @code{and}, @code{or}, and
-@code{not}.
+to @code{true} or @code{false}, namely @mrefcomma{if} @mrefcomma{and}@w{}
+@mrefcomma{or} and @mrefdot{not}
Note that because of the rules for evaluation of predicate expressions
(in particular because @code{not @var{expr}} causes evaluation of @var{expr}),
@code{not @var{a} = @var{b}} is equivalent to @code{is(@var{a} # @var{b})},
instead of @code{@var{a} # @var{b}}.
-@code{rhs} and @code{lhs} return the right-hand and left-hand sides,
+@mref{rhs} and @mref{lhs} return the right-hand and left-hand sides,
respectively, of an equation or inequation.
-See also @code{equal} and @code{notequal}.
+See also @mref{equal} and @mrefdot{notequal}
Examples:
@@ -669,12 +669,14 @@ an unevaluated equation, which might or might not hold.
(%o3) [[x = ---------, y = -----------]]
5 b + 3 a 5 b + 3 a
(%i4) subst (%, [eq_1, eq_2]);
+@group
196 a 5 (29 a - 17 b)
(%o4) [--------- - --------------- = 17,
5 b + 3 a 5 b + 3 a
196 b 3 (29 a - 17 b)
--------- + --------------- = 29]
5 b + 3 a 5 b + 3 a
+@end group
(%i5) ratsimp (%);
(%o5) [17 = 17, 29 = 29]
@end example
@@ -772,7 +774,7 @@ When the left-hand side is a list of simple and/or subscripted variables, the
right-hand side must evaluate to a list, and the elements of the right-hand
side are assigned to the elements of the left-hand side, in parallel.
-See also @code{kill} and @code{remvalue}, which undo the association between
+See also @mref{kill} and @mrefcomma{remvalue} which undo the association between
the left-hand side and its value.
Examples:
@@ -885,7 +887,7 @@ The values of @code{a} and @code{b} are exchanged in this example.
Assignment operator.
-@code{::} is the same as @code{:} (which see) except that @code{::} evaluates
+@code{::} is the same as @mref{:} (which see) except that @code{::} evaluates
its left-hand side as well as its right-hand side.
Examples:
@@ -937,18 +939,18 @@ quotes its arguments, and the expression which it returns (called the "macro
expansion") is evaluated in the context from which the macro was called.
A macro function is otherwise the same as an ordinary function.
-@code{macroexpand} returns a macro expansion (without evaluating it).
+@mref{macroexpand} returns a macro expansion (without evaluating it).
@code{macroexpand (foo (x))} followed by @code{''%} is equivalent to
@code{foo (x)} when @code{foo} is a macro function.
@code{::=} puts the name of the new macro function onto the global list
-@code{macros}. @code{kill}, @code{remove}, and @code{remfunction} unbind macro
-function definitions and remove names from @code{macros}.
+@mrefdot{macros} @mrefcomma{kill} @mrefcomma{remove} and @mref{remfunction}@w{}
+unbind macro function definitions and remove names from @code{macros}.
-@code{fundef} or @code{dispfun} return a macro function definition or assign it
+@mref{fundef} or @mref{dispfun} return a macro function definition or assign it
to a label, respectively.
-Macro functions commonly contain @code{buildq} and @code{splice} expressions to
+Macro functions commonly contain @mref{buildq} and @mref{splice} expressions to
construct an expression, which is then evaluated.
Examples
@@ -1063,13 +1065,13 @@ All function definitions appear in the same namespace; defining a function
@code{f} within another function @code{g} does not automatically limit the scope
of @code{f} to @code{g}. However, @code{local(f)} makes the definition of
function @code{f} effective only within the block or other compound expression
-in which @code{local} appears.
+in which @mref{local} appears.
If some formal argument @var{x_k} is a quoted symbol, the function defined by
@code{:=} does not evaluate the corresponding actual argument. Otherwise all
actual arguments are evaluated.
-See also @code{define} and @code{::=}.
+See also @mref{define} and @mrefdot{::=}
Examples:
@@ -1199,7 +1201,7 @@ 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}.
+See also @ref{Syntax}.
Examples:
@@ -1284,7 +1286,144 @@ if x ## y then
@end deffn
@c -----------------------------------------------------------------------------
-@deffn {Function} nary
+@anchor{matchfix}
+@deffn {Function} matchfix (@var{ldelimiter}, @var{rdelimiter})
+@deffnx {Function} matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos}, @var{pos})
+
+Declares a matchfix operator with left and right delimiters @var{ldelimiter}
+and @var{rdelimiter}. The delimiters are specified as strings.
+
+A "matchfix" operator is a function of any number of arguments,
+such that the arguments occur between matching left and right delimiters.
+The delimiters may be any strings, so long as the parser can
+distinguish the delimiters from the operands
+and other expressions and operators.
+In practice this rules out unparseable delimiters such as
+@code{%}, @code{,}, @code{$} and @code{;},
+and may require isolating the delimiters with white space.
+The right delimiter can be the same or different from the left delimiter.
+
+A left delimiter can be associated with only one right delimiter;
+two different matchfix operators cannot have the same left delimiter.
+
+An existing operator may be redeclared as a matchfix operator
+without changing its other properties.
+In particular, built-in operators such as addition @code{+} can
+be declared matchfix,
+but operator functions cannot be defined for built-in operators.
+
+The command @code{matchfix (@var{ldelimiter}, @var{rdelimiter}, @var{arg_pos},
+@var{pos})} declares the argument part-of-speech @var{arg_pos} and result
+part-of-speech @var{pos}, and the delimiters @var{ldelimiter} and
+@var{rdelimiter}.
+
+"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.
+
+@c DUNNO IF WE REALLY NEED TO MENTION BINDING POWER HERE -- AS NOTED IT'S IRRELEVANT
+@c An operator declared by @code{matchfix} is assigned a low binding power.
+@c Since a matchfix operator must be evaluated before any expression
+@c which contains it,
+@c binding power is effectively irrelevant
+@c to the declaration of a matchfix operator.
+
+The function to carry out a matchfix operation is an ordinary
+user-defined function.
+The operator function is defined
+in the usual way
+with the function definition operator @code{:=} or @code{define}.
+The arguments may be written between the delimiters,
+or with the left delimiter as a quoted string and the arguments
+following in parentheses.
+@code{dispfun (@var{ldelimiter})} displays the function definition.
+
+The only built-in matchfix operator is the list constructor @code{[ ]}.
+Parentheses @code{( )} and double-quotes @code{" "}
+act like matchfix operators,
+but are not treated as such by the Maxima parser.
+
+@code{matchfix} evaluates its arguments.
+@code{matchfix} returns its first argument, @var{ldelimiter}.
+@c HOW TO TAKE AWAY THE MATCHFIX PROPERTY ??
+
+Examples:
+
+Delimiters may be almost any strings.
+
+@c ===beg===
+@c matchfix ("@@", "~");
+@c @@ a, b, c ~;
+@c matchfix (">>", "<<");
+@c >> a, b, c <<;
+@c matchfix ("foo", "oof");
+@c foo a, b, c oof;
+@c >> w + foo x, y oof + z << / @@ p, q ~;
+@c ===end===
+@example
+(%i1) matchfix ("@@@@", "~");
+(%o1) @@@@
+(%i2) @@@@ a, b, c ~;
+(%o2) @@@@a, b, c~
+(%i3) matchfix (">>", "<<");
+(%o3) >>
+(%i4) >> a, b, c <<;
+(%o4) >>a, b, c<<
+(%i5) matchfix ("foo", "oof");
+(%o5) foo
+(%i6) foo a, b, c oof;
+(%o6) fooa, b, coof
+(%i7) >> w + foo x, y oof + z << / @@@@ p, q ~;
+ >>z + foox, yoof + w<<
+(%o7) ----------------------
+ @@@@p, q~
+@end example
+
+Matchfix operators are ordinary user-defined functions.
+
+@example
+(%i1) matchfix ("!-", "-!");
+(%o1) "!-"
+(%i2) !- x, y -! := x/y - y/x;
+ x y
+(%o2) !-x, y-! := - - -
+ y x
+(%i3) define (!-x, y-!, x/y - y/x);
+ x y
+(%o3) !-x, y-! := - - -
+ y x
+(%i4) define ("!-" (x, y), x/y - y/x);
+ x y
+(%o4) !-x, y-! := - - -
+ y x
+(%i5) dispfun ("!-");
+ x y
+(%t5) !-x, y-! := - - -
+ y x
+
+(%o5) done
+(%i6) !-3, 5-!;
+ 16
+(%o6) - --
+ 15
+(%i7) "!-" (3, 5);
+ 16
+(%o7) - --
+ 15
+@end example
+
+@opencatbox
+@category{Syntax} @category{Operators}
+@closecatbox
+@end deffn
+
+@c -----------------------------------------------------------------------------
+@anchor{operator_nary}
+@deffn {Function} nary (@var{op})
+@deffnx {Function} nary (@var{op}, @var{bp}, @var{arg_pos}, @var{pos})
An @code{nary} operator is used to denote a function of any number of arguments,
each of which is separated by an occurrence of the operator, e.g. A+B or A+B+C.
@@ -1293,7 +1432,7 @@ to be an @code{nary} operator. Functions may be declared to be @code{nary}. If
@code{declare(j,nary);} is done, this tells the simplifier to simplify, e.g.
@code{j(j(a,b),j(c,d))} to @code{j(a, b, c, d)}.
-See also @code{Syntax}.
+See also @ref{Syntax}.
@opencatbox
@category{Operators} @category{Syntax}
@@ -1301,7 +1440,9 @@ See also @code{Syntax}.
@end deffn
@c -----------------------------------------------------------------------------
-@deffn {Function} nofix
+@anchor{nofix}
+@deffn {Function} nofix (@var{op})
+@deffnx {Function} nofix (@var{op}, @var{pos})
@code{nofix} operators are used to denote functions of no arguments.
The mere presence of such an operator in a command will cause the
@@ -1310,7 +1451,7 @@ corresponding function to be evaluated. For example, when one types
@code{nofix} operator. The function @code{nofix("x")} is a syntax extension
function which declares @code{x} to be a @code{nofix} operator.
-See also @code{Syntax}.
+See also @ref{Syntax}.
@opencatbox
@category{Operators} @category{Syntax}
@@ -1318,7 +1459,9 @@ See also @code{Syntax}.
@end deffn
@c -----------------------------------------------------------------------------
-@deffn {Function} postfix
+@anchor{postfix}
+@deffn {Function} postfix (@var{op})
+@deffnx {Function} postfix (@var{op}, @var{lbp}, @var{lpos}, @var{pos})
@code{postfix} operators like the @code{prefix} variety denote functions of a
single argument, but in this case the argument immediately precedes an
@@ -1326,7 +1469,7 @@ occurrence of the operator in the input string, e.g. 3!. The
@code{postfix("x")} function is a syntax extension function to declare @code{x}
to be a @code{postfix} operator.
-See also @code{Syntax}.
+See also @ref{Syntax}.
@opencatbox
@category{Operators} @category{Syntax}
@@ -1334,14 +1477,16 @@ See also @code{Syntax}.
@end deffn
@c -----------------------------------------------------------------------------
-@deffn {Function} prefix
+@anchor{prefix}
+@deffn {Function} prefix (@var{op})
+@deffnx {Function} prefix (@var{op}, @var{rbp}, @var{rpos}, @var{pos})
A @code{prefix} operator is one which signifies a function of one argument,
which argument immediately follows an occurrence of the operator.
@code{prefix("x")} is a syntax extension function to declare @code{x} to be a
@code{prefix} operator.
-See also @code{Syntax}.
+See also @ref{Syntax}.
@opencatbox
@category{Operators} @category{Syntax}
commit 14d0bc6c44fcc74319fa90c0d5561f60f88f550c
Author: crategus <cra...@us...>
Date: Sun Jun 12 13:23:49 2011 +0200
Moving documentation
to Expressions.texi:
mainvar
noun
noundisp
opsubst
to Command.texi:
negsumdispflag
diff --git a/doc/info/Simplification.texi b/doc/info/Simplification.texi
index 1980be4..5bda996 100644
--- a/doc/info/Simplification.texi
+++ b/doc/info/Simplification.texi
@@ -576,27 +576,6 @@ See also @code{opproperties}.
@closecatbox
@end defvr
-@c NEEDS CLARIFICATION, EXAMPLES
-
-@c -----------------------------------------------------------------------------
-@anchor{mainvar}
-@defvr {Declaration} mainvar
-
-You may declare variables to be @code{mainvar}. The ordering scale for atoms is
-essentially: numbers < constants (e.g., @code{%e}, @code{%pi}) < scalars < other
-variables < mainvars. E.g., compare @code{expand ((X+Y)^4)} with
-@code{(declare (x, mainvar), expand ((x+y)^4))}. (Note: Care should be taken if
-you elect to use the above feature. E.g., if you subtract an expression in
-which @code{x} is a @code{mainvar} from one in which @code{x} isn't a
-@code{mainvar}, resimplification e.g. with @code{ev (expr, simp)} may be
-necessary if cancellation is to occur. Also, if you save an expression in which
-@code{x} is a @code{mainvar}, you probably should also save @code{x}.)
-
-@opencatbox
-@category{Declarations and inferences} @category{Expressions}
-@closecatbox
-@end defvr
-
@c NEEDS EXAMPLES
@c -----------------------------------------------------------------------------
@@ -760,55 +739,6 @@ than local use in your Maxima.
@closecatbox
@end defvr
-@c NEEDS CLARIFICATION, EXAMPLES
-
-@c -----------------------------------------------------------------------------
-@anchor{negsumdispflag}
-@defvr {Option variable} negsumdispflag
-Default value: @code{true}
-
-When @code{negsumdispflag} is @code{true}, @code{x - y} displays as @code{x - y}
-instead of as @code{- y + x}. Setting it to @code{false} causes the special
-check in display for the difference of two expressions to not be done. One
-application is that thus @code{a + %i*b} and @code{a - %i*b} may both be
-displayed the same way.
-
-@opencatbox
-@category{Display flags and variables}
-@closecatbox
-@end defvr
-
-@c NEEDS CLARIFICATION, EXAMPLES
-
-@c -----------------------------------------------------------------------------
-@anchor{noun}
-@defvr {Declaration} noun
-
-@code{noun} is one of the options of the @code{declare} command. It makes a
-function so declared a "noun", meaning that it won't be evaluated
-automatically.
-
-@opencatbox
-@category{Nouns and verbs}
-@closecatbox
-@end defvr
-
-@c NEEDS CLARIFICATION, EXAMPLES
-
-@c -----------------------------------------------------------------------------
-@anchor{noundisp}
-@defvr {Option variable} noundisp
-Default value: @code{false}
-
-When @code{noundisp} is @code{true}, nouns display with
-a single quote. This switch is always @code{true} when displaying function
-definitions.
-
-@opencatbox
-@category{Display flags and variables} @category{Nouns and verbs}
-@closecatbox
-@end defvr
-
@c -----------------------------------------------------------------------------
@anchor{opproperties}
@defvr {System variable} opproperties
@@ -824,22 +754,6 @@ by the Maxima simplifier:
@closecatbox
@end defvr
-@c NEEDS CLARIFICATION, EXAMPLES
-
-@c -----------------------------------------------------------------------------
-@anchor{option_opsubst}
-@defvr {Option variable} opsubst
-Default value: @code{true}
-
-When @code{opsubst} is @code{false}, @code{subst} does not attempt to
-substitute into the operator of an expression. E.g.,
-@code{(opsubst: false, subst (x^2, r, r+r[0]))} will work.
-
-@opencatbox
-@category{Expressions}
-@closecatbox
-@end defvr
-
@c NEEDS EXAMPLES
@c -----------------------------------------------------------------------------
commit 5cb48d53140f4e1d9cae88edfdeb9b5ec60dd096
Author: crategus <cra...@us...>
Date: Sun Jun 12 13:21:23 2011 +0200
Including documentation for Lists, Arrays, and Structures into the
chapter Data Types and Structures.
diff --git a/doc/info/include-maxima.texi.in b/doc/info/include-maxima.texi.in
index 4e28ba5..4aaed2a 100644
--- a/doc/info/include-maxima.texi.in
+++ b/doc/info/include-maxima.texi.in
@@ -117,7 +117,6 @@ Support for specific areas of mathematics
* Differential Equations:: Defining and solving differential equations.
* Numerical:: Numerical integration, Fourier
transforms, etc.
-* Arrays:: Creating and working with arrays.
* Matrices and Linear Algebra:: Matrix operations.
* Affine::
* itensor:: Indicial Tensor Manipulation.
@@ -134,9 +133,7 @@ Advanced facilities and programming
* Miscellaneous Options:: Options with a global effect on Maxima.
* Rules and Patterns:: User defined pattern matching and
simplification rules.
-* Lists:: Manipulation of lists.
* Sets:: Manipulation of sets.
-* Structures:: Aggregated data.
* Function Definition:: Defining functions.
* Program Flow:: Defining Maxima programs.
* Debugging:: Debugging Maxima programs.
@@ -353,10 +350,6 @@ Numerical
* Introduction to Fourier series::
* Functions and Variables for Fourier series::
-Arrays
-
-* Functions and Variables for Arrays::
-
Matrices and Linear Algebra
* Introduction to Matrices and Linear Algebra::
@@ -420,22 +413,12 @@ Miscellaneous Options
Rules and Patterns
* Introduction to Rules and Patterns::
-* Functions and Variables for Rules and Patterns::
-
-Lists
-
-* Introduction to Lists::
-* Functions and Variables for Lists::
+* Functions and Variables for Rules and Patterns::
Sets
* Introduction to Sets::
-* Functions and Variables for Sets::
-
-Structures
-
-* Introduction to Structures::
-* Functions and Variables for Structures::
+* Functions and Variables for Sets::
Function Definition
@@ -703,6 +686,9 @@ zeilberger
@chapter Data Types and Structures
@include DataTypes.texi
@include Constants.texi
+@include Lists.texi
+@include Arrays.texi
+@include defstruct.texi
@node Expressions, Operators, Data Types and Structures, Top
@chapter Expressions
@@ -748,10 +734,6 @@ zeilberger
@chapter Polynomials
@include Polynomials.texi
-@c @node Constants, Logarithms, Polynomials, Top
-@c @chapter Constants
-@c @include Constants.texi
-
@node Logarithms, Trigonometric, Polynomials, Top
@chapter Logarithms
@include Logarithms.texi
@@ -790,15 +772,11 @@ zeilberger
@c @include NonCommutative.texi
-@node Numerical, Arrays, Differential Equations, Top
+@node Numerical, Matrices and Linear Algebra, Differential Equations, Top
@chapter Numerical
@include Numerical.texi
-@node Arrays, Matrices and Linear Algebra, Numerical, Top
-@chapter Arrays
-@include Arrays.texi
-
-@node Matrices and Linear Algebra, Affine, Arrays, Top
+@node Matrices and Linear Algebra, Affine, Numerical, Top
@chapter Matrices and Linear Algebra
@include Matrices.texi
@@ -842,23 +820,15 @@ zeilberger
@chapter Miscellaneous Options
@include Miscellaneous.texi
-@node Rules and Patterns, Lists, Miscellaneous Options, Top
+@node Rules and Patterns, Sets, Miscellaneous Options, Top
@chapter Rules and Patterns
@include Rules.texi
-@node Lists, Sets, Rules and Patterns, Top
-@chapter Lists
-@include Lists.texi
-
-@node Sets, Structures, Lists, Top
+@node Sets, Function Definition, Rules and Patterns, Top
@chapter Sets
@include nset.texi
-@node Structures, Function Definition, Sets, Top
-@chapter Structures
-@include defstruct.texi
-
-@node Function Definition, Program Flow, Structures, Top
+@node Function Definition, Program Flow, Sets, Top
@chapter Function Definition
@include Function.texi
commit 203d957539e3e5b3a85e9cf12008b314b1e65e53
Author: crategus <cra...@us...>
Date: Sun Jun 12 13:19:56 2011 +0200
Moving documentation for lopow to Polynomials.texi
Adding documentation from Simplification.texi:
mainvar
noun
noundisp
opsubst
from Input.texi:
reveal
diff --git a/doc/info/Expressions.texi b/doc/info/Expressions.texi
index bb9718d..efd05a1 100644
--- a/doc/info/Expressions.texi
+++ b/doc/info/Expressions.texi
@@ -1098,36 +1098,71 @@ For each member @var{m} of @var{list}, calls
@closecatbox
@end deffn
-@c -----------------------------------------------------------------------------
-@anchor{lowpow}
-@deffn {Function} lopow (@var{expr}, @var{x})
+@c NEEDS WORK
-Returns the lowest exponent of @var{x} which explicitly appears in
-@var{expr}. Thus
+@c -----------------------------------------------------------------------------
+@anchor{lpart}
+@deffn {Function} lpart (@var{label}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
-@example
-(%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
-(%o1) min(a, 2)
-@end example
+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
@category{Expressions}
@closecatbox
@end deffn
-@c NEEDS WORK
+@c NEEDS CLARIFICATION, EXAMPLES
@c -----------------------------------------------------------------------------
-@anchor{lpart}
-@deffn {Function} lpart (@var{label}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
+@anchor{mainvar}
+@defvr {Declaration} mainvar
+
+You may declare variables to be @code{mainvar}. The ordering scale for atoms is
+essentially: numbers < constants (e.g., @code{%e}, @code{%pi}) < scalars < other
+variables < mainvars. E.g., compare @code{expand ((X+Y)^4)} with
+@code{(declare (x, mainvar), expand ((x+y)^4))}. (Note: Care should be taken if
+you elect to use the above feature. E.g., if you subtract an expression in
+which @code{x} is a @code{mainvar} from one in which @code{x} isn't a
+@code{mainvar}, resimplification e.g. with @code{ev (expr, simp)} may be
+necessary if cancellation is to occur. Also, if you save an expression in which
+@code{x} is a @code{mainvar}, you probably should also save @code{x}.)
-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
+@category{Declarations and inferences} @category{Expressions}
+@closecatbox
+@end defvr
+
+@c NEEDS CLARIFICATION, EXAMPLES
+
+@c -----------------------------------------------------------------------------
+@anchor{noun}
+@defvr {Declaration} noun
+
+@code{noun} is one of the options of the @mref{declare} command. It makes a
+function so declared a "noun", meaning that it won't be evaluated
+automatically.
@opencatbox
-@category{Expressions}
+@category{Nouns and verbs}
@closecatbox
-@end deffn
+@end defvr
+
+@c NEEDS CLARIFICATION, EXAMPLES
+
+@c -----------------------------------------------------------------------------
+@anchor{noundisp}
+@defvr {Option variable} noundisp
+Default value: @code{false}
+
+When @code{noundisp} is @code{true}, nouns display with
+a single quote. This switch is always @code{true} when displaying function
+definitions.
+
+@opencatbox
+@category{Display flags and variables} @category{Nouns and verbs}
+@closecatbox
+@end defvr
@c NEEDS WORK
@@ -1204,7 +1239,6 @@ Examples:
@c op (F [x, y] (a, b, c));
@c op (G [u, v, w]);
@c ===end===
-
@example
(%i1) stringdisp: true$
(%i2) op (a * b * c);
@@ -1258,6 +1292,22 @@ operator of @var{expr}.
@closecatbox
@end deffn
+@c NEEDS CLARIFICATION, EXAMPLES
+
+@c -----------------------------------------------------------------------------
+@anchor{option_opsubst}
+@defvr {Option variable} opsubst
+Default value: @code{true}
+
+When @code{opsubst} is @code{false}, @mref{subst} does not attempt to
+substitute into the operator of an expression. E.g.,
+@code{(opsubst: false, subst (x^2, r, r+r[0]))} will work.
+
+@opencatbox
+@category{Expressions}
+@closecatbox
+@end defvr
+
@c NEEDS WORK
@c -----------------------------------------------------------------------------
@@ -1552,12 +1602,12 @@ Examples:
(%o1) - log(sqrt(x + 1) + 1) + ------- + -----
...
[truncated message content] |
