doc/info/Function.texi

26 @subsection Ordinary functions
38 Anonymous functions may also be created using @code{lambda}.
104 code executes inside the @code{block}, or inside functions called from
147 Inside functions, when the right hand side of a definition,
152 @anchor{memoizing functions}
154 @anchor{Memoizing functions}
161 same argument is given.  Memoizing functions are often called
164 The names of memoizing functions are appended to the global list @code{arrays}
165 (not the global list @code{functions}).  @code{arrayinfo} returns the list of
171 analogous to @code{funmake} for ordinary functions.
173 analogous to @code{apply} for ordinary functions.
174 There is nothing exactly analogous to @code{map} for array functions,
180 function values), analogous to @code{remfunction} for ordinary functions.
195 long list of cached results) Memoizing functions can speed up calculations
567 @code{macros} is the list of user-defined macro functions.
570 macro functions from the list.
802 modified by the @code{go}, @code{throw}, and @code{return} functions.  The last
910 @fname{compfile} (@var{filename}, functions) @
913 Translates Maxima functions into Lisp and writes the translated code into the
917 specified functions.  @code{compfile (@var{filename}, functions)} and
918 @code{compfile (@var{filename}, all)} translate all user-defined functions.
948 @fname{compile} (functions) @
951 Translates Maxima functions @var{f_1}, @dots{}, @var{f_n} into Lisp, evaluates
953 translated function.  @code{compile} returns a list of the names of the
954 compiled functions.
956 @code{compile (all)} or @code{compile (functions)} compiles all user-defined
957 functions.
1150 translated or compiled as it gives the compiler hints of the type (``mode'')
1168 to ensure that @var{name} is only assigned values of the declared mode.
1222 translator: foo was declared with mode boolean
1330 Displays the definition of the user-defined functions @var{f_1}, @dots{},
1336 parentheses @code{( )}), one of a family of subscripted functions selected by a
1340 @code{dispfun (all)} displays all user-defined functions as
1341 given by the @code{functions}, @code{arrays}, and @code{macros} lists,
1342 omitting subscripted functions defined with constant subscripts.
1351 labels corresponding to the displayed functions.
1439 @category{Display functions}
1508 @anchor{functions}
1509 @defvr {System variable} functions
1512 @code{functions} is the list of ordinary Maxima functions
1519 @mref{Memoizing functions} (called with square brackets, e.g., @code{F[x]}) and subscripted
1520 functions (called with square brackets and parentheses, e.g., @code{F[x](y)})
1521 are listed by the global variable @code{arrays}, and not by @code{functions}.
1523 Lisp functions are not kept on any list.
1535 @c functions;
1576 (%i8) functions;
1605 @item one of a family of subscripted functions selected by a particular
1631 @code{funmake} does not attempt to distinguish @mref{memoizing functions} from ordinary
1632 functions; when @var{F} is the name of a memoizing function,
2333 all variables and knowing the return value of all functions a function uses
2339 array            an declared array (see the detailed description below)
2353 A function parameter named @code{a} can be declared as an array filled with elements
2577 The arguments may be the names of ordinary functions (created by @mref{:=} or
2578 @mref{define}) or macro functions (created by @mref{::=}).
2588 @code{remfunction} does not apply to @mref{memoizing functions} or subscripted functions.
2589 @mref{remarray} applies to those types of functions.
2604 preserved when the function is translated.  This permits the definition to be
2607 When @code{savedef} is @code{false}, the names of translated functions are
2608 removed from the @code{functions} list.
2624 @code{translate_file} generate declarations to make the translated code more
2639 @fname{translate} (functions) @
2642 Translates the user-defined functions @var{f_1}, @dots{}, @var{f_n} from the
2644 Typically the translated functions run faster than the originals.
2646 @code{translate (all)} or @code{translate (functions)} translates all
2647 user-defined functions.
2649 Functions to be translated should include a call to @code{mode_declare} at the
2661 The names of translated functions are removed from the @code{functions} list
2665 Functions should not be translated unless they are fully debugged.
2669 @code{false} which inhibits simplification of the expressions to be translated.
2674 Note that translated
2675 functions may not run identically to the way they did before
2690 functions to be run (provided they are still around) rather than the
2691 translated version.
2694 functions translated.
2720 For example, @code{foo.mac} is translated into @code{foo.LISP}.
2736 for tracking down bugs in translated code.
2784 version of all functions to be run (provided they are still around)
2785 rather than the translated version.
2804 otherwise array names appear as literal symbols in translated code.
2860 Tells the Maxima-to-Lisp translator to assume that the functions
2888 messages implies full compatibility of translated and compiled code with the
2951 translated output.
2954 trying to debug the translator.  By comparing the translated product
2998 encountered.  FEXPRs should not normally be output in translated code,
2999 all legitimate special program forms are translated.
3075 These include functions defined with the @code{:=} operator,
3110 to Lisp, it is important for the translator to know which functions it
3111 sees in the file are to be called as translated or compiled functions,
3112 and which ones are just Maxima functions or undefined.  Putting this