Menu
▾
▴
[Maxima-commits] CVS: maxima/doc/info/de Miscellaneous.de.texi, NONE, 1.1 Ctensor.de.texi, NONE, 1.1 Numerical.de.texi, NONE, 1.1 Program.de.texi, NONE, 1.1 Function.de.texi, NONE, 1.1 Rules.de.texi, NONE, 1.1 Lists.de.texi, NONE, 1.1 Equations.de.texi, NONE, 1.1 Nset.de.texi, NONE, 1.1 Debugging.de.texi, NONE, 1.1 Atensor.de.texi, NONE, 1.1 Itensor.de.texi, NONE, 1.1 Matrices.de.texi, NONE, 1.1 Runtime.de.texi, NONE, 1.1
|
From: Dieter K. <cra...@us...> - 2010-11-16 18:09:51
|
Update of /cvsroot/maxima/maxima/doc/info/de In directory sfp-cvsdas-4.v30.ch3.sourceforge.com:/tmp/cvs-serv3118/doc/info/de Added Files: Miscellaneous.de.texi Ctensor.de.texi Numerical.de.texi Program.de.texi Function.de.texi Rules.de.texi Lists.de.texi Equations.de.texi Nset.de.texi Debugging.de.texi Atensor.de.texi Itensor.de.texi Matrices.de.texi Runtime.de.texi Log Message: Adding files to the manual. --- NEW FILE: Miscellaneous.de.texi --- @c ----------------------------------------------------------------------------- @c File : Miscellaneous.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Translation : Dr. Dieter Kaiser @c Date : 14.11.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Introduction to Miscellaneous Options:: * Share:: * Functions and Variables for Miscellaneous Options:: @end menu @node Introduction to Miscellaneous Options, Share, Miscellaneous Options, Miscellaneous Options @section Introduction to Miscellaneous Options In this section various options are discussed which have a global effect on the operation of Maxima. Also various lists such as the list of all user defined functions, are discussed. @node Share, Functions and Variables for Miscellaneous Options, Introduction to Miscellaneous Options, Miscellaneous Options @section Share The Maxima "share" directory contains programs and other files of interest to Maxima users, but not part of the core implementation of Maxima. These programs are typically loaded via @code{load} or @code{setup_autoload}. @code{:lisp *maxima-sharedir*} displays the location of the share directory within the user's file system. @c FIXME FIXME FIXME -- WE REALLY NEED AN UP-TO-DATE LIST OF SHARE PACKAGES !! @code{printfile ("share.usg")} prints an out-of-date list of share packages. Users may find it more informative to browse the share directory using a file system browser. @node Functions and Variables for Miscellaneous Options, , Share, Miscellaneous Options @section Functions and Variables for Miscellaneous Options @c THE FUNCTION APRPOS IS MOVED TO THE FILE HELP.TEXI @c CROSS REF TO WHICH FUNCTION OR FUNCTIONS ESTABLISH PROPERTIES !! (VERY IMPORTANT) @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} properties (@var{a}) Returns a list of the names of all the properties associated with the atom @var{a}. @c @opencatbox @c @category{Declarations and inferences} @c @closecatbox @end deffn @c CROSS REF TO WHICH FUNCTION OR FUNCTIONS ESTABLISH PROPERTIES !! (VERY IMPORTANT) @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES @c WHAT IS HIDDEN IN THE "etc" HERE ?? @c ----------------------------------------------------------------------------- @defvr {Special symbol} props @code{props} are atoms which have any property other than those explicitly mentioned in @code{infolists}, such as specified by @code{atvalue}, @code{matchdeclare}, etc., as well as properties specified in the @code{declare} function. @c @opencatbox @c @category{Declarations and inferences} @category{Global variables} @c @closecatbox @end defvr @c CROSS REF TO WHICH FUNCTION OR FUNCTIONS ESTABLISH PROPERTIES !! (VERY IMPORTANT) @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} propvars (@var{prop}) Returns a list of those atoms on the @code{props} list which have the property indicated by @var{prop}. Thus @code{propvars (atvalue)} returns a list of atoms which have atvalues. @c @opencatbox @c @category{Declarations and inferences} @c @closecatbox @end deffn @c CROSS REF TO OTHER FUNCTIONS WHICH PUT/GET PROPERTIES !! (VERY IMPORTANT) @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES @c ARE PROPERTIES ESTABLISHED BY put THE SAME AS PROPERTIES ESTABLISHED BY declare OR OTHER FUNCTIONS ?? @c IS put (foo, true, integer) EQUIVALENT TO declare (foo, integer) FOR EXAMPLE ?? @c ----------------------------------------------------------------------------- @deffn {Function} put (@var{atom}, @var{value}, @var{indicator}) Assigns @var{value} to the property (specified by @var{indicator}) of @var{atom}. @var{indicator} may be the name of any property, not just a system-defined property. @code{put} evaluates its arguments. @code{put} returns @var{value}. Examples: @example (%i1) put (foo, (a+b)^5, expr); 5 (%o1) (b + a) (%i2) put (foo, "Hello", str); (%o2) Hello (%i3) properties (foo); (%o3) [[user properties, str, expr]] (%i4) get (foo, expr); 5 (%o4) (b + a) (%i5) get (foo, str); (%o5) Hello @end example @c @opencatbox @c @category{Declarations and inferences} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} qput (@var{atom}, @var{value}, @var{indicator}) Assigns @var{value} to the property (specified by @var{indicator}) of @var{atom}. This is the same as @code{put}, except that the arguments are quoted. Example: @example (%i1) foo: aa$ (%i2) bar: bb$ (%i3) baz: cc$ (%i4) put (foo, bar, baz); (%o4) bb (%i5) properties (aa); (%o5) [[user properties, cc]] (%i6) get (aa, cc); (%o6) bb (%i7) qput (foo, bar, baz); (%o7) bar (%i8) properties (foo); (%o8) [value, [user properties, baz]] (%i9) get ('foo, 'baz); (%o9) bar @end example @c @opencatbox @c @category{Declarations and inferences} @c @closecatbox @end deffn @c CROSS REF TO OTHER FUNCTIONS WHICH PUT/GET PROPERTIES !! (VERY IMPORTANT) @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES @c HOW DOES THIS INTERACT WITH declare OR OTHER PROPERTY-ESTABLISHING FUNCTIONS ?? @c HOW IS THIS DIFFERENT FROM remove ?? @c ----------------------------------------------------------------------------- @deffn {Function} rem (@var{atom}, @var{indicator}) Removes the property indicated by @var{indicator} from @var{atom}. @c @opencatbox @c @category{Declarations and inferences} @c @closecatbox @end deffn @c CROSS REF TO OTHER FUNCTIONS WHICH PUT/GET PROPERTIES !! (VERY IMPORTANT) @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES @c HOW DOES THIS INTERACT WITH declare OR OTHER PROPERTY-ESTABLISHING FUNCTIONS ?? @c HOW IS THIS DIFFERENT FROM rem ?? @c ----------------------------------------------------------------------------- @deffn {Function} remove (@var{a_1}, @var{p_1}, ..., @var{a_n}, @var{p_n}) @deffnx {Function} remove ([@var{a_1}, ..., @var{a_m}], [@var{p_1}, ..., @var{p_n}], ...) @deffnx {Function} remove ("@var{a}", operator) @deffnx {Function} remove (@var{a}, transfun) @deffnx {Function} remove (all, @var{p}) Removes properties associated with atoms. @code{remove (@var{a_1}, @var{p_1}, ..., @var{a_n}, @var{p_n})} removes property @code{p_k} from atom @code{a_k}. @code{remove ([@var{a_1}, ..., @var{a_m}], [@var{p_1}, ..., @var{p_n}], ...)} removes properties @code{@var{p_1}, ..., @var{p_n}} from atoms @var{a_1}, ..., @var{a_m}. There may be more than one pair of lists. @c VERIFY THAT THIS WORKS AS ADVERTISED @code{remove (all, @var{p})} removes the property @var{p} from all atoms which have it. @c SHOULD REFER TO A LIST OF ALL SYSTEM-DEFINED PROPERTIES HERE. The removed properties may be system-defined properties such as @code{function}, @code{macro}, or @code{mode_declare}, or user-defined properties. @c VERIFY THAT THIS WORKS AS ADVERTISED @c IS transfun PECULIAR TO remove ?? IF SO, SHOW SPECIAL CASE AS @defunx A property may be @code{transfun} to remove the translated Lisp version of a function. After executing this, the Maxima version of the function is executed rather than the translated version. @code{remove ("@var{a}", operator)} or, equivalently, @code{remove ("@var{a}", op)} removes from @var{a} the operator properties declared by @code{prefix}, @code{infix}, @code{nary}, @code{postfix}, @code{matchfix}, or @code{nofix}. Note that the name of the operator must be written as a quoted string. @code{remove} always returns @code{done} whether or not an atom has a specified property. This behavior is unlike the more specific remove functions @code{remvalue}, @code{remarray}, @code{remfunction}, and @code{remrule}. @c IN SERIOUS NEED OF EXAMPLES HERE @c @opencatbox @c @category{Declarations and inferences} @c @closecatbox @end deffn @c NEEDS EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} remvalue (@var{name_1}, ..., @var{name_n}) @deffnx {Function} remvalue (all) Removes the values of user variables @var{name_1}, ..., @var{name_n} (which can be subscripted) from the system. @code{remvalue (all)} removes the values of all variables in @code{values}, the list of all variables given names by the user (as opposed to those which are automatically assigned by Maxima). See also @code{values}. @c @opencatbox @c @category{Evaluation} @c @closecatbox @end deffn @c NEEDS EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} rncombine (@var{expr}) Transforms @var{expr} by combining all terms of @var{expr} that have identical denominators or denominators that differ from each other by numerical factors only. This is slightly different from the behavior of @code{combine}, which collects terms that have identical denominators. Setting @code{pfeformat: true} and using @code{combine} yields results similar to those that can be obtained with @code{rncombine}, but @code{rncombine} takes the additional step of cross-multiplying numerical denominator factors. This results in neater forms, and the possibility of recognizing some cancellations. @code{load(rncomb)} loads this function. @c @opencatbox @c @category{Expressions} @c @closecatbox @end deffn @c NEEDS CLARIFICATION AND EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} scalarp (@var{expr}) Returns @code{true} if @var{expr} is a number, constant, or variable declared @code{scalar} with @code{declare}, or composed entirely of numbers, constants, and such variables, but not containing matrices or lists. @c @opencatbox @c @category{Predicate functions} @category{Vectors} @category{Matrices} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} setup_autoload (@var{filename}, @var{function_1}, ..., @var{function_n}) Specifies that if any of @var{function_1}, ..., @var{function_n} are referenced and not yet defined, @var{filename} is loaded via @code{load}. @var{filename} usually contains definitions for the functions specified, although that is not enforced. @code{setup_autoload} does not work for array functions. @code{setup_autoload} quotes its arguments. Example: @c EXAMPLE GENERATED FROM FOLLOWING INPUT @c legendre_p (1, %pi); @c setup_autoload ("specfun.mac", legendre_p, ultraspherical); @c ultraspherical (2, 1/2, %pi); @c legendre_p (1, %pi); @c legendre_q (1, %pi); @example (%i1) legendre_p (1, %pi); (%o1) legendre_p(1, %pi) (%i2) setup_autoload ("specfun.mac", legendre_p, ultraspherical); (%o2) done (%i3) ultraspherical (2, 1/2, %pi); Warning - you are redefining the Macsyma function ultraspherical Warning - you are redefining the Macsyma function legendre_p 2 3 (%pi - 1) (%o3) ------------ + 3 (%pi - 1) + 1 2 (%i4) legendre_p (1, %pi); (%o4) %pi (%i5) legendre_q (1, %pi); %pi + 1 %pi log(-------) 1 - %pi (%o5) ---------------- - 1 2 @end example @c @opencatbox @c @category{Function definition} @category{File input} @c @closecatbox @end deffn @c RECOMMEND CUTTING THIS ITEM AND CUTTING $tcl_output IN src/plot.lisp @c THIS REALLY, REALLY SEEMS LIKE CRUFT: @c $tcl_output IS NEVER CALLED WITHIN MAXIMA SOURCE, @c AND THIS EXTREMELY NARROW, LIMITED FUNCTIONALITY ISN'T USEFUL TO USERS @c AND IT'S BROKEN: INCORRECT OUTPUT FOR CLISP, DIES ON GCL @c --- 28.08.2010 -------------------------------------------------------------- @deffn {Function} tcl_output (@var{list}, @var{i0}, @var{skip}) @deffnx {Function} tcl_output (@var{list}, @var{i0}) @deffnx {Function} tcl_output ([@var{list_1}, ..., @var{list_n}], @var{i}) Prints elements of a list enclosed by curly braces @code{@{ @}}, suitable as part of a program in the Tcl/Tk language. @code{tcl_output (@var{list}, @var{i0}, @var{skip})} prints @var{list}, beginning with element @var{i0} and printing elements @code{@var{i0} + @var{skip}}, @code{@var{i0} + 2 @var{skip}}, etc. @code{tcl_output (@var{list}, @var{i0})} is equivalent to @code{tcl_output (@var{list}, @var{i0}, 2)}. @code{tcl_output ([@var{list_1}, ..., @var{list_n}], @var{i})} prints the @var{i}'th elements of @var{list_1}, ..., @var{list_n}. Examples: @c EXAMPLE INPUT @c tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$ @c tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$ @c tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$ @c tcl_output ([x1, y1, x2, y2, x3, y3], 2)$ @c tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$ @c EXAMPLE OUTPUT: CLISP @c OUTPUT IS OK FOR FIRST TWO, BROKEN FOR OTHERS @c GCL OUTPUT: SAME FOR FIRST TWO @c GCL FAILS ON OTHERS (IN EACH CASE COMPLAINING ELEMENTS ARE "not of type @c (OR RATIONAL LISP:FLOAT)" @example (%i1) tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$ @{1.000000000 4.000000000 @} (%i2) tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$ @{2.000000000 5.000000000 @} (%i3) tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$ @{((RAT SIMP) 3 7) ((RAT SIMP) 11 13) @} (%i4) tcl_output ([x1, y1, x2, y2, x3, y3], 2)$ @{$Y1 $Y2 $Y3 @} (%i5) tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$ @{SIMP 1.000000000 11.00000000 @} @end example @end deffn @c --- End of Miscellaneous.texi ----------------------------------------------- --- NEW FILE: Ctensor.de.texi --- @c ----------------------------------------------------------------------------- @c File : Ctensor.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Translation : Dr. Dieter Kaiser @c Date : 14.11.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Introduction to ctensor:: * Functions and Variables for ctensor:: @end menu @c ----------------------------------------------------------------------------- @node Introduction to ctensor, Functions and Variables for ctensor, ctensor, ctensor @section Introduction to ctensor [...1836 lines suppressed...] ricci() LRICCICOM() Compute the mixed Ricci-tensor ctaypov MINP Maximum power in Taylor-series expansion cgeodesic() MOTION Compute geodesic equations ct_coords OMEGA Metric coordinates ctayvar PARAM Taylor-series expansion variable lriem[] R[] Covariant Riemann-tensor uriemann() RAISERIEMANN() Compute the contravariant Riemann-tensor ratriemann RATRIEMAN Rational simplif. of the Riemann-tensor uric[] RICCI[] Contravariant Ricci-tensor uricci() RICCICOM() Compute the contravariant Ricci-tensor cmetric() SETMETRIC() Set up the metric ctaypt TAYPT Point for Taylor-series expansion ctayswitch TAYSWITCH Taylor-series setting switch csetup() TSETUP() Start interactive setup session ctransform() TTRANSFORM() Interactive coordinate transformation uriem[] UR[] Contravariant Riemann-tensor weyl[] W[] (3,1) Weyl-tensor @end example --- NEW FILE: Numerical.de.texi --- @c ----------------------------------------------------------------------------- @c File : Numerical.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Translation : Dr. Dieter Kaiser @c Date : 13.11.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Introduction to fast Fourier transform:: * Functions and Variables for fast Fourier transform:: * Introduction to Fourier series:: * 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 The @code{fft} package comprises functions for the numerical (not symbolic) computation of the fast Fourier transform. @c @opencatbox @c @category{Fourier transform} @category{Numerical methods} @category{Share packages} @category{Package fft} @c @closecatbox @c end concepts Numerical @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 @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. @var{r} and @var{t} 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 replaced by the real and imaginary parts, @code{a} and @code{b}, on return. The outputs are calculated as @example a = r cos(t) b = r sin(t) @end example @code{polartorect} is the inverse function of @code{recttopolar}. @code{load(fft)} loads this function. See also @code{fft}. @c @opencatbox @c @category{Package fft} @category{Complex variables} @c @closecatbox @end deffn @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. The array size need not be a power of 2. The original values of the input arrays are replaced by the magnitude and angle, @code{r} and @code{t}, on return. The outputs are calculated as @example r = sqrt(a^2 + b^2) t = atan2(b, a) @end example 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}. @c @opencatbox @c @category{Package fft} @category{Complex variables} @c @closecatbox @end deffn @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. 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 or symbolic constants. @code{inverse_fft} returns a new object of the same type as @var{y}, which is not modified. Results are always computed as floats or expressions @code{a + b*%i} where @code{a} and @code{b} are floats. The inverse discrete Fourier transform is defined as follows. Let @code{x} be the output of the inverse transform. Then for @code{j} from 0 through @code{n - 1}, @example x[j] = sum(y[k] exp(+2 %i %pi j k / n), k, 0, n - 1) @end example @code{load(fft)} loads this function. See also @code{fft} (forward transform), @code{recttopolar}, and @code{polartorect}. Examples: Real data. @c ===beg=== @c load (fft) $ @c fpprintprec : 4 $ @c L : [1, 2, 3, 4, -1, -2, -3, -4] $ @c L1 : inverse_fft (L); @c L2 : fft (L1); @c lmax (abs (L2 - L)); @c ===end=== @example (%i1) load (fft) $ (%i2) fpprintprec : 4 $ (%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $ (%i4) L1 : inverse_fft (L); (%o4) [0.0, 14.49 %i - .8284, 0.0, 2.485 %i + 4.828, 0.0, 4.828 - 2.485 %i, 0.0, - 14.49 %i - .8284] (%i5) L2 : fft (L1); (%o5) [1.0, 2.0 - 2.168L-19 %i, 3.0 - 7.525L-20 %i, 4.0 - 4.256L-19 %i, - 1.0, 2.168L-19 %i - 2.0, 7.525L-20 %i - 3.0, 4.256L-19 %i - 4.0] (%i6) lmax (abs (L2 - L)); (%o6) 3.545L-16 @end example Complex data. @c ===beg=== @c load (fft) $ @c fpprintprec : 4 $ @c L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $ @c L1 : inverse_fft (L); @c L2 : fft (L1); @c lmax (abs (L2 - L)); @c ===end=== @example (%i1) load (fft) $ (%i2) fpprintprec : 4 $ (%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $ (%i4) L1 : inverse_fft (L); (%o4) [4.0, 2.711L-19 %i + 4.0, 2.0 %i - 2.0, - 2.828 %i - 2.828, 0.0, 5.421L-20 %i + 4.0, - 2.0 %i - 2.0, 2.828 %i + 2.828] (%i5) L2 : fft (L1); (%o5) [4.066E-20 %i + 1.0, 1.0 %i + 1.0, 1.0 - 1.0 %i, 1.55L-19 %i - 1.0, - 4.066E-20 %i - 1.0, 1.0 - 1.0 %i, 1.0 %i + 1.0, 1.0 - 7.368L-20 %i] (%i6) lmax (abs (L2 - L)); (%o6) 6.841L-17 @end example @c @opencatbox @c @category{Package fft} @c @closecatbox @end deffn @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. 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 or symbolic constants. @code{fft} returns a new object of the same type as @var{x}, which is not modified. Results are always computed as floats or expressions @code{a + b*%i} where @code{a} and @code{b} are floats. The discrete Fourier transform is defined as follows. Let @code{y} be the output of the transform. Then for @code{k} from 0 through @code{n - 1}, @example y[k] = (1/n) sum(x[j] exp(-2 %i %pi j k / n), j, 0, n - 1) @end example When the data @var{x} are real, real coefficients @code{a} and @code{b} can be computed such that @example x[j] = sum (a[k] * cos (2*%pi*j*k / n) + b[k] * sin (2*%pi*j*k / n), k, 0, n/2) @end example with @example a[0] = realpart (y[0]) b[0] = 0 @end example and, for k from 1 through n/2 - 1, @example a[k] = realpart (y[k] + y[n - k]) b[k] = imagpart (y[n - k] - y[k]) @end example and @example a[n/2] = realpart (y[n/2]) b[n/2] = 0 @end example @code{load(fft)} loads this function. See also @code{inverse_fft} (inverse transform), @code{recttopolar}, and @code{polartorect}. Examples: Real data. @c ===beg=== @c load (fft) $ @c fpprintprec : 4 $ @c L : [1, 2, 3, 4, -1, -2, -3, -4] $ @c L1 : fft (L); @c L2 : inverse_fft (L1); @c lmax (abs (L2 - L)); @c ===end=== @example (%i1) load (fft) $ (%i2) fpprintprec : 4 $ (%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $ (%i4) L1 : fft (L); (%o4) [0.0, - 1.811 %i - .1036, 0.0, .6036 - .3107 %i, 0.0, .3107 %i + .6036, 0.0, 1.811 %i - .1036] (%i5) L2 : inverse_fft (L1); (%o5) [1.0, 2.168L-19 %i + 2.0, 7.525L-20 %i + 3.0, 4.256L-19 %i + 4.0, - 1.0, - 2.168L-19 %i - 2.0, - 7.525L-20 %i - 3.0, - 4.256L-19 %i - 4.0] (%i6) lmax (abs (L2 - L)); (%o6) 3.545L-16 @end example Complex data. @c ===beg=== @c load (fft) $ @c fpprintprec : 4 $ @c L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $ @c L1 : fft (L); @c L2 : inverse_fft (L1); @c lmax (abs (L2 - L)); @c ===end=== @example (%i1) load (fft) $ (%i2) fpprintprec : 4 $ (%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $ (%i4) L1 : fft (L); (%o4) [0.5, .3536 %i + .3536, - 0.25 %i - 0.25, 0.5 - 6.776L-21 %i, 0.0, - .3536 %i - .3536, 0.25 %i - 0.25, 0.5 - 3.388L-20 %i] (%i5) L2 : inverse_fft (L1); (%o5) [1.0 - 4.066E-20 %i, 1.0 %i + 1.0, 1.0 - 1.0 %i, - 1.008L-19 %i - 1.0, 4.066E-20 %i - 1.0, 1.0 - 1.0 %i, 1.0 %i + 1.0, 1.947L-20 %i + 1.0] (%i6) lmax (abs (L2 - L)); (%o6) 6.83L-17 @end example Computation of sine and cosine coefficients. @c ===beg=== @c load (fft) $ @c fpprintprec : 4 $ @c L : [1, 2, 3, 4, 5, 6, 7, 8] $ @c n : length (L) $ @c x : make_array (any, n) $ @c fillarray (x, L) $ @c y : fft (x) $ @c a : make_array (any, n/2 + 1) $ @c b : make_array (any, n/2 + 1) $ @c a[0] : realpart (y[0]) $ @c b[0] : 0 $ @c for k : 1 thru n/2 - 1 do @c (a[k] : realpart (y[k] + y[n - k]), @c b[k] : imagpart (y[n - k] - y[k])); @c a[n/2] : y[n/2] $ @c b[n/2] : 0 $ @c listarray (a); @c listarray (b); @c f(j) := sum (a[k] * cos (2*%pi*j*k / n) + b[k] * sin (2*%pi*j*k / n), k, 0, n/2) $ @c makelist (float (f (j)), j, 0, n - 1); @c ===end=== @example (%i1) load (fft) $ (%i2) fpprintprec : 4 $ (%i3) L : [1, 2, 3, 4, 5, 6, 7, 8] $ (%i4) n : length (L) $ (%i5) x : make_array (any, n) $ (%i6) fillarray (x, L) $ (%i7) y : fft (x) $ (%i8) a : make_array (any, n/2 + 1) $ (%i9) b : make_array (any, n/2 + 1) $ (%i10) a[0] : realpart (y[0]) $ (%i11) b[0] : 0 $ (%i12) for k : 1 thru n/2 - 1 do (a[k] : realpart (y[k] + y[n - k]), b[k] : imagpart (y[n - k] - y[k])); (%o12) done (%i13) a[n/2] : y[n/2] $ (%i14) b[n/2] : 0 $ (%i15) listarray (a); (%o15) [4.5, - 1.0, - 1.0, - 1.0, - 0.5] (%i16) listarray (b); (%o16) [0, - 2.414, - 1.0, - .4142, 0] (%i17) f(j) := sum (a[k] * cos (2*%pi*j*k / n) + b[k] * sin (2*%pi*j*k / n), k, 0, n/2) $ (%i18) makelist (float (f (j)), j, 0, n - 1); (%o18) [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] @end example @c @opencatbox @c @category{Package fft} @c @closecatbox @end deffn @defvr {Option variable} fortindent Default value: 0 @code{fortindent} controls the left margin indentation of expressions printed out by the @code{fortran} command. 0 gives normal printout (i.e., 6 spaces), and positive values will causes the expressions to be printed farther to the right. @c @opencatbox @c @category{Translation and compilation} @c @closecatbox @end defvr @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 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. 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} causes expressions to be printed further to the right. When @code{fortspaces} is @code{true}, @code{fortran} fills out each printed line with spaces to 80 columns. @code{fortran} evaluates its arguments; quoting an argument defeats evaluation. @code{fortran} always returns @code{done}. Examples: @verbatim (%i1) expr: (a + b)^12$ (%i2) fortran (expr); (b+a)**12 (%o2) done (%i3) fortran ('x=expr); x = (b+a)**12 (%o3) done (%i4) fortran ('x=expand (expr)); x = b**12+12*a*b**11+66*a**2*b**10+220*a**3*b**9+495*a**4*b**8+792 1 *a**5*b**7+924*a**6*b**6+792*a**7*b**5+495*a**8*b**4+220*a**9*b 2 **3+66*a**10*b**2+12*a**11*b+a**12 (%o4) done (%i5) fortran ('x=7+5*%i); x = (7,5) (%o5) done (%i6) fortran ('x=[1,2,3,4]); x = [1,2,3,4] (%o6) done (%i7) f(x) := x^2$ (%i8) fortran (f); f (%o8) done @end verbatim @c @opencatbox @c @category{Translation and compilation} @c @closecatbox @end deffn @defvr {Option variable} fortspaces Default value: @code{false} When @code{fortspaces} is @code{true}, @code{fortran} fills out each printed line with spaces to 80 columns. @c @opencatbox @c @category{Translation and compilation} @c @closecatbox @end defvr @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. @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}. @example (%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155; 2 (%o1) 1.0E-155 x - 5.5 x + 5.2E+155 (%i2) expr2: horner (%, x), keepfloat: true; (%o2) (1.0E-155 x - 5.5) x + 5.2E+155 (%i3) ev (expr, x=1e155); Maxima encountered a Lisp error: floating point overflow Automatically continuing. To reenable the Lisp debugger set *debugger-hook* to nil. (%i4) ev (expr2, x=1e155); (%o4) 7.0E+154 @end example @c @opencatbox @c @category{Numerical methods} @c @closecatbox @end deffn @deffn {Function} find_root (@var{expr}, @var{x}, @var{a}, @var{b}) @deffnx {Function} find_root (@var{f}, @var{a}, @var{b}) @deffnx {Option variable} find_root_error @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})}. 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. @code{find_root} initially applies binary search. If the function in question appears to be smooth enough, @code{find_root} applies linear interpolation instead. The accuracy of @code{find_root} is governed by @code{find_root_abs} and @code{find_root_rel}. @code{find_root} stops when the function in question evaluates to something less than or equal to @code{find_root_abs}, or if successive approximants @var{x_0}, @var{x_1} differ by no more than @code{find_root_rel * 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. 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}. When @code{find_root_error} is @code{true}, @code{find_root} prints an error message. 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. 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 @c interpolate(f(x),x,0.1,%pi); time= 68 msec @c translate(f); @c interpolate(f(x),x,0.1,%pi); time= 26 msec @c interpolate(f,0.1,%pi); time= 5 msec @c ===beg=== @c f(x) := sin(x) - x/2; @c find_root (sin(x) - x/2, x, 0.1, %pi); @c find_root (sin(x) = x/2, x, 0.1, %pi); @c find_root (f(x), x, 0.1, %pi); @c find_root (f, 0.1, %pi); @c find_root (exp(x) = y, x, 0, 100); @c find_root (exp(x) = y, x, 0, 100), y = 10; @c log (10.0); @c ===end=== @example (%i1) f(x) := sin(x) - x/2; x (%o1) f(x) := sin(x) - - 2 (%i2) find_root (sin(x) - x/2, x, 0.1, %pi); (%o2) 1.895494267033981 (%i3) find_root (sin(x) = x/2, x, 0.1, %pi); (%o3) 1.895494267033981 (%i4) find_root (f(x), x, 0.1, %pi); (%o4) 1.895494267033981 (%i5) find_root (f, 0.1, %pi); (%o5) 1.895494267033981 (%i6) find_root (exp(x) = y, x, 0, 100); x (%o6) find_root(%e = y, x, 0.0, 100.0) (%i7) find_root (exp(x) = y, x, 0, 100), y = 10; (%o7) 2.302585092994046 (%i8) log (10.0); (%o8) 2.302585092994046 @end example @c @opencatbox @c @category{Algebraic equations} @category{Numerical methods} @c @closecatbox @end deffn @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}} and proceeds until @code{abs(@var{expr}) < @var{eps}} (with @var{expr} evaluated at the current value of @var{x}). @code{newton} allows undefined variables to appear in @var{expr}, so long as the termination test @code{abs(@var{expr}) < @var{eps}} evaluates to @code{true} or @code{false}. 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}. Examples: @c ===beg=== @c load (newton1); @c newton (cos (u), u, 1, 1/100); @c ev (cos (u), u = %); @c assume (a > 0); @c newton (x^2 - a^2, x, a/2, a^2/100); @c ev (x^2 - a^2, x = %); @c ===end=== @example (%i1) load (newton1); (%o1) /usr/share/maxima/5.10.0cvs/share/numeric/newton1.mac (%i2) newton (cos (u), u, 1, 1/100); (%o2) 1.570675277161251 (%i3) ev (cos (u), u = %); (%o3) 1.2104963335033528E-4 (%i4) assume (a > 0); (%o4) [a > 0] (%i5) newton (x^2 - a^2, x, a/2, a^2/100); (%o5) 1.00030487804878 a (%i6) ev (x^2 - a^2, x = %); 2 (%o6) 6.098490481853958E-4 a @end example @c @opencatbox @c @category{Algebraic equations} @category{Numerical methods} @c @closecatbox @end deffn @node Introduction to Fourier series, Functions and Variables for Fourier series, Functions and Variables for fast Fourier transform, Numerical @section Introduction to Fourier series The @code{fourie} package comprises functions for the symbolic computation of Fourier series. There are functions in the @code{fourie} package to calculate Fourier integral coefficients and some functions for manipulation of expressions. @c @opencatbox @c @category{Fourier transform} @category{Share packages} @category{Package fourie} @c @closecatbox @node Functions and Variables for Fourier series, , Introduction to Fourier series, Numerical @section Functions and Variables for Fourier series @c REPHRASE @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). @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @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}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @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}. @code{funp (@var{f}, @var{expr}, @var{x})} returns @code{true} if @var{expr} contains the function @var{f} and the variable @var{x} is somewhere in the argument of one of the instances of @var{f}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @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}, @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. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @category{Integral calculus} @c @closecatbox @end deffn @c NEEDS EXPANSION @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]}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @c NEES EXPANSION. WHAT IS THE ARGUMENT l ?? @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}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @category{Trigonometric functions} @category{Simplification functions} @c @closecatbox @end deffn @defvr {Option variable} sinnpiflag Default value: @code{true} See @code{foursimp}. @c @opencatbox @c @category{Package fourie} @c @closecatbox @end defvr @defvr {Option variable} cosnpiflag Default value: @code{true} See @code{foursimp}. @c @opencatbox @c @category{Package fourie} @c @closecatbox @end defvr @c NEEDS EXPANSION. EXPLAIN x AND p HERE (DO NOT REFER SOMEWHERE ELSE) @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}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @c NEEDS EXPANSION @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}]}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @c NEEDS EXPANSION @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}]}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @c NEEDS EXPANSION @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)}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @c NEEDS EXPANSION @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]}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @c NEEDS EXPANSION @deffn {Function} fourintcos (@var{f}, @var{x}) Returns the Fourier cosine integral coefficients for @code{@var{f}(@var{x})} on @code{[0, inf]}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn @c NEEDS EXPANSION @deffn {Function} fourintsin (@var{f}, @var{x}) Returns the Fourier sine integral coefficients for @code{@var{f}(@var{x})} on @code{[0, inf]}. @c NEEDS EXAMPLES @c @opencatbox @c @category{Package fourie} @c @closecatbox @end deffn --- NEW FILE: Program.de.texi --- @c ----------------------------------------------------------------------------- @c File : Program.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Translation : Dr. Dieter Kaiser @c Date : 14.11.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Lisp und Maxima:: * Introduction to Program Flow:: * Functions and Variables for Program Flow:: @end menu @c TODO: SOLL DAS FOLGENDE IN DIESES KAPITEL AUFGENOMMEN WERDEN? @c ----------------------------------------------------------------------------- [...1023 lines suppressed...] (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], [F(c, 1), F(c, 2), F(c, 3)]] (%i2) setify (flatten (%)); (%o2) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), F(c, 1), F(c, 2), F(c, 3)@} (%i3) map(lambda([L], apply(F, L)), cartesian_product(@{a, b, c@}, @{1, 2, 3@})); (%o3) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), F(c, 1), F(c, 2), F(c, 3)@} (%i4) is (equal (%, %th (2))); (%o4) true @end example @c @opencatbox @c @category{Function application} @c @closecatbox @end deffn @c --- End of file Program.de.texi --------------------------------------------- --- NEW FILE: Function.de.texi --- @c ----------------------------------------------------------------------------- @c File : Function.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Translation : Dr. Dieter Kaiser @c Date : 14.11.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Introduction to Function Definition:: * Function:: * Macros:: * Functions and Variables for Function Definition:: @end menu @c ----------------------------------------------------------------------------- @node Introduction to Function Definition, Function, Function Definition, Function Definition [...2421 lines suppressed...] @c NEEDS CLARIFICATION @c ----------------------------------------------------------------------------- @deffn {Function} declare_translated (@var{f_1}, @var{f_2}, ...) When translating a file of Maxima code to Lisp, it is important for the translator to know which functions it sees in the file are to be called as translated or compiled functions, and which ones are just Maxima functions or undefined. Putting this declaration at the top of the file, lets it know that although a symbol does which does not yet have a Lisp function value, will have one at call time. @code{(MFUNCTION-CALL fn arg1 arg2 ...)} is generated when the translator does not know @code{fn} is going to be a Lisp function. @c @opencatbox @c @category{Translation and compilation} @c @closecatbox @end deffn @c --- End of file Function.de.texi -------------------------------------------- --- NEW FILE: Rules.de.texi --- @c ----------------------------------------------------------------------------- @c File : Rules.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Translation : Dr. Dieter Kaiser @c Date : 14.11.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Introduction to Rules and Patterns:: * Functions and Variables for Rules and Patterns:: @end menu @node Introduction to Rules and Patterns, Functions and Variables for Rules and Patterns, Rules and Patterns, Rules and Patterns @section Introduction to Rules and Patterns This section describes user-defined pattern matching and [...1167 lines suppressed...] 9 8 7 6 5 4 3 2 1 0 @end example @c @opencatbox @c @category{Rules and patterns} @c @closecatbox @end deffn @deffn {Function} clear_rules () Executes @code{kill (rules)} and then resets the next rule number to 1 for addition @code{+}, multiplication @code{*}, and exponentiation @code{^}. @c @opencatbox @c @category{Rules and patterns} @c @closecatbox @end deffn @c --- End of file Rules.de.texi ----------------------------------------------- --- NEW FILE: Lists.de.texi --- @c ----------------------------------------------------------------------------- @c File : Lists.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Translation : Dr. Dieter Kaiser @c Date : 14.11.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Einf@"uhrung in Listen:: * Funktionen und Variablen f@"ur Listen:: @end menu @c ----------------------------------------------------------------------------- @node Einf@"uhrung in Listen, Funktionen und Variablen f@"ur Listen, Listen, Listen @section Einf@"uhrung in Listen Lists are the basic building block for Maxima and Lisp. All data types other than arrays, hash tables, numbers are represented as Lisp lists, These Lisp lists have the form @example ((MPLUS) $A 2) @end example @noindent to indicate an expression @code{a+2}. At Maxima level one would see the infix notation @code{a+2}. Maxima also has lists which are printed as @example [1, 2, 7, x+y] @end example @noindent for a list with 4 elements. Internally this corresponds to a Lisp list of the form @example ((MLIST) 1 2 7 ((MPLUS) $X $Y )) @end example @noindent The flag which denotes the type field of the Maxima expression is a list itself, since after it has been through the simplifier the list would become @example ((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y)) @end example @c ----------------------------------------------------------------------------- @node Funktionen und Variablen f@"ur Listen, , Einf@"uhrung in Listen, Listen @section Funktionen und Variablen f@"ur Listen @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS @c NEEDS CLARIFICATION AND EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} append (@var{list_1}, ..., @var{list_n}) Returns a single list of the elements of @var{list_1} followed by the elements of @var{list_2}, ... @code{append} also works on general expressions, e.g. @code{append (f(a,b), f(c,d,e));} yields @code{f(a,b,c,d,e)}. Do @code{example(append);} for an example. @c @opencatbox @c @category{Lists} @category{Expressions} @c @closecatbox @end deffn @c NEEDS CLARIFICATION AND EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} assoc (@var{key}, @var{list}, @var{default}) @deffnx {Function} assoc (@var{key}, @var{list}) This function searches for the @var{key} in the left hand side of the input @var{list} of the form @code{[x,y,z,...]} where each of the @var{list} elements is an expression of a binary operand and 2 elements. For example @code{x=1}, @code{2^3}, @code{[a,b]} etc. The @var{key} is checked againts the first operand. @code{assoc} returns the second operand if the @code{key} is found. If the @code{key} is not found it either returns the @var{default} value. @var{default} is optional and defaults to @code{false}. @c @opencatbox @c @category{Lists} @category{Expressions} @c @closecatbox @end deffn @c REPHRASE @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION @c ----------------------------------------------------------------------------- @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 unbound). @c @opencatbox @c @category{Expressions} @category{Predicate functions} @c @closecatbox @end deffn @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION @c ----------------------------------------------------------------------------- @deffn {Function} cons (@var{expr}, @var{list}) Returns a new list constructed of the element @var{expr} as its first element, followed by the elements of @var{list}. @code{cons} also works on other expressions, e.g. @code{cons(x, f(a,b,c));} -> @code{f(x,a,b,c)}. @c @opencatbox @c @category{Lists} @category{Expressions} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} copylist (@var{list}) Returns a copy of the list @var{list}. @c @opencatbox @c @category{Lists} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} create_list (@var{form}, @var{x_1}, @var{list_1}, ..., @var{x_n}, @var{list_n}) Create a list by evaluating @var{form} with @var{x_1} bound to each element of @var{list_1}, and for each such binding bind @var{x_2} to each element of @var{list_2}, .... The number of elements in the result will be the product of the number of elements in each list. Each variable @var{x_i} must actually be a symbol -- it will not be evaluated. The list arguments will be evaluated once at the beginning of the iteration. @example (%i1) create_list(x^i,i,[1,3,7]); 3 7 (%o1) [x, x , x ] @end example @noindent With a double iteration: @example (%i1) create_list([i,j],i,[a,b],j,[e,f,h]); (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]] @end example Instead of @var{list_i} two args may be supplied each of which should evaluate to a number. These will be the inclusive lower and upper bounds for the iteration. @example (%i1) create_list([i,j],i,[1,2,3],j,1,i); (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]] @end example Note that the limits or list for the @code{j} variable can depend on the current value of @code{i}. @c @opencatbox @c @category{Lists} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} delete (@var{expr_1}, @var{expr_2}) @deffnx {Function} delete (@var{expr_1}, @var{expr_2}, @var{n}) @code{delete(@var{expr_1}, @var{expr_2})} removes from @var{expr_2} any arguments of its top-level operator which are the same (as determined by "=") as @var{expr_1}. Note that "=" tests for formal equality, not equivalence. Note also that arguments of subexpressions are not affected. @var{expr_1} may be an atom or a non-atomic expression. @var{expr_2} may be any non-atomic expression. @code{delete} returns a new expression; it does not modify @var{expr_2}. @code{delete(@var{expr_1}, @var{expr_2}, @var{n})} removes from @var{expr_2} the first @var{n} arguments of the top-level operator which are the same as @var{expr_1}. If there are fewer than @var{n} such arguments, then all such arguments are removed. Examples: Removing elements from a list. @c ===beg=== @c delete (y, [w, x, y, z, z, y, x, w]); @c ===end=== @example (%i1) delete (y, [w, x, y, z, z, y, x, w]); (%o1) [w, x, z, z, x, w] @end example Removing terms from a sum. @c ===beg=== @c delete (sin(x), x + sin(x) + y); @c ===end=== @example (%i1) delete (sin(x), x + sin(x) + y); (%o1) y + x @end example Removing factors from a product. @c ===beg=== @c delete (u - x, (u - w)*(u - x)*(u - y)*(u - z)); @c ===end=== @example (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z)); (%o1) (u - w) (u - y) (u - z) @end example Removing arguments from an arbitrary expression. @c ===beg=== @c delete (a, foo (a, b, c, d, a)); @c ===end=== @example (%i1) delete (a, foo (a, b, c, d, a)); (%o1) foo(b, c, d) @end example Limit the number of removed arguments. @c ===beg=== @c delete (a, foo (a, b, a, c, d, a), 2); @c ===end=== @example (%i1) delete (a, foo (a, b, a, c, d, a), 2); (%o1) foo(b, c, d, a) @end example Whether arguments are the same as @var{expr_1} is determined by "=". Arguments which are @code{equal} but not "=" are not removed. @c ===beg=== @c [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))]; @c [is (0 = 0), is (0 = 0.0), is (0 = 0b0)]; @c delete (0, [0, 0.0, 0b0]); @c is (equal ((x + y)*(x - y), x^2 - y^2)); @c is ((x + y)*(x - y) = x^2 - y^2); @c delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]); @c ===end=== @example (%i1) [is (equal (0, 0)), is (equal (0, 0.0)), is (equal (0, 0b0))]; `rat' replaced 0.0 by 0/1 = 0.0 `rat' replaced 0.0B0 by 0/1 = 0.0B0 (%o1) [true, true, true] (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)]; (%o2) [true, false, false] (%i3) delete (0, [0, 0.0, 0b0]); (%o3) [0.0, 0.0b0] (%i4) is (equal ((x + y)*(x - y), x^2 - y^2)); (%o4) true (%i5) is ((x + y)*(x - y) = x^2 - y^2); (%o5) false (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]); 2 2 (%o6) [x - y ] @end example @c @opencatbox @c @category{Lists} @c @category{Expressions} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} eighth (@var{expr}) Returns the 8'th item of expression or list @var{expr}. See @code{first} for more details. @c @opencatbox @c @category{Lists} @c @category{Expressions} @c @closecatbox @end deffn @c NEED ANOTHER deffn FOR GENERAL EXPRESSIONS ARGUMENTS @c SPLIT OFF EXAMPLES INTO EXAMPLE SECTION @c ----------------------------------------------------------------------------- @deffn {Function} endcons (@var{expr}, @var{list}) Returns a new list consisting of the elements of @code{list} followed by @var{expr}. @code{endcons} also works on general expressions, e.g. @code{endcons(x, f(a,b,c));} -> @code{f(a,b,c,x)}. @c @opencatbox @c @category{Lists} @c @category{Expressions} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} fifth (@var{expr}) Returns the 5'th item of expression or list @var{expr}. See @code{first} for more details. @c @opencatbox @c @category{Lists} @c @category{Expressions} @c @closecatbox @end deffn @c NEEDS CLARIFICATION AND EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} first (@var{expr}) Returns the first part of @var{expr} which may result in the first element of a list, the first row of a matrix, the first term of a sum, etc. Note that @code{first} and its related functions, @code{rest} and @code{last}, work on the form of @var{expr} which is displayed not the form which is typed on input. If the variable @code{inflag} is set to @code{true} however, these functions will look at the internal form of @var{expr}. Note that the simplifier re-orders expressions. Thus @code{first(x+y)} will be @code{x} if @code{inflag} is @code{true} and @code{y} if @code{inflag} is @code{false} (@code{first(y+x)} gives the same results). The functions @code{second} .. @code{tenth} yield the second through the tenth part of their input argument. @c @opencatbox @c @category{Lists} @c @category{Expressions} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} fourth (@var{expr}) Returns the 4'th item of expression or list @var{expr}. See @code{first} for more details. @c @opencatbox @c @category{Lists} @c @category{Expressions} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} get (@var{a}, @var{i}) Retrieves the user property indicated by @var{i} associated with atom @var{a} or returns @code{false} if a doesn't have property @var{i}. @code{get} evaluates its arguments. @c ===beg=== @c put (%e, 'transcendental, 'type); @c put (%pi, 'transcendental, 'type)$ @c put (%i, 'algebraic, 'type)$ @c typeof (expr) := block ([q], @c if numberp (expr) @c then return ('algebraic), @c if not atom (expr) @c then return (maplist ('typeof, expr)), @c q: get (expr, 'type), @c if q=false @c then errcatch (error(expr,"is not numeric.")) else q)$ @c typeof (2*%e + x*%pi); @c typeof (2*%e + %pi); @c ===end=== @example (%i1) put (%e, 'transcendental, 'type); (%o1) transcendental (%i2) put (%pi, 'transcendental, 'type)$ (%i3) put (%i, 'algebraic, 'type)$ (%i4) typeof (expr) := block ([q], if numberp (expr) then return ('algebraic), if not atom (expr) then return (maplist ('typeof, expr)), q: get (expr, 'type), if q=false then errcatch (error(expr,"is not numeric.")) else q)$ (%i5) typeof (2*%e + x*%pi); x is not numeric. (%o5) [[transcendental, []], [algebraic, transcendental]] (%i6) typeof (2*%e + %pi); (%o6) [transcendental, [algebraic, transcendental]] @end example @c @opencatbox @c @category{Declarations and inferences} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @deffn {Function} join (@var{l}, @var{m}) Creates a new list containing the elements of lists @var{l} and @var{m}, interspersed. The result has elements @code{[@var{l}[1], @var{m}[1], @var{l}[2], @var{m}[2], ...]}. The lists @var{l} and @var{m} may contain any type of elements. If the lists are different lengths, @code{join} ignores elements of the longer list. Maxima complains if @var{l} or @var{m} is not a list. Examples: @c ===beg=== @c L1: [a, sin(b), c!, d - 1]; @c join (L1, [1, 2, 3, 4]); @c join (L1, [aa, bb, cc, dd, ee, ff]); @c ===end=== @example (%i1) L1: [a, sin(b), c!, d - 1]; (%o1) [a, sin(b), c!, d - 1] (%i2) join (L1, [1, 2, 3, 4]); (%o2) [a, 1, sin(b), 2, c!, 3, d - 1, 4] (%i3) join (L1, [aa, bb, cc, dd, ee, ff]); (%o3) [a, aa, sin(b), bb, c!, cc, d - 1, dd] @end example @c @opencatbox @c @category{Lists} @c @closecatbox @end deffn @c NEEDS EXAMPLES @c HOW IS "LAST" PART DETERMINED ?? @deffn {Function} last (@var{expr}) Returns the last part (term, row, element, etc.) of the @var{expr}. @c @opencatbox @c @category{Lists} @c @category{Expressions} @c @closecatbox @end deffn @c NEEDS CLARIFICATION AND EXAMPLES @c ----------------------------------------------------------------------------- @deffn {Function} length (@var{expr}) Returns (by default) the number of parts in the external (displayed) form of @var{expr}. For lists this is the number of elements, for matrices it is the number of rows, and for sums it is the number of terms (see @code{dispform}). The @code{length} command is affected by the @code{inflag} switch. So, e.g. @code{length(a/(b*c));} gives 2 if @code{inflag} is @code{false} (Assuming @code{exptdispflag} is @code{true}), but 3 if @code{inflag} is @code{true} (the internal representation is essentially @code{a*b^-1*c^-1}). @c @opencatbox @c @category{Lists} @c @category{Expressions} @c @closecatbox @end deffn @c ----------------------------------------------------------------------------- @defvr {Op... [truncated message content] |