[BACK]Return to misc.texi CVS log [TXT][DIR] Up to [local] / OpenXM / src / asir-doc / parts / builtin

Diff for /OpenXM/src/asir-doc/parts/builtin/misc.texi between version 1.1.1.1 and 1.20

version 1.1.1.1, 1999/12/08 05:47:44 version 1.20, 2016/08/26 04:56:07
Line 1 
Line 1 
   @comment $OpenXM: OpenXM/src/asir-doc/parts/builtin/misc.texi,v 1.19 2009/02/22 16:40:05 ohara Exp $
   \BJP
 @node $B$=$NB>(B,,, $BAH$_9~$_H!?t(B  @node $B$=$NB>(B,,, $BAH$_9~$_H!?t(B
 @section $B$=$NB>(B  @section $B$=$NB>(B
   \E
   \BEG
   @node Miscellaneouses,,, Built-in Function
   @section Miscellaneouses
   \E
   
 @menu  @menu
 * ctrl::  * ctrl::
Line 8 
Line 15 
 * help::  * help::
 * time::  * time::
 * cputime tstart tstop::  * cputime tstart tstop::
   * timer::
   * currenttime::
   * sleep::
 * heap::  * heap::
 * version::  * version::
 * shell::  * shell::
Line 15 
Line 25 
 * flist::  * flist::
 * delete_history::  * delete_history::
 * get_rootdir::  * get_rootdir::
   * getopt::
   * getenv::
 @end menu  @end menu
   
 @node ctrl,,, $B$=$NB>(B  \JP @node ctrl,,, $B$=$NB>(B
   \EG @node ctrl,,, Miscellaneouses
 @subsection @code{ctrl}  @subsection @code{ctrl}
 @findex ctrl  @findex ctrl
   
 @table @t  @table @t
 @item ctrl("@var{switch}"[,@var{obj}])  @item ctrl("@var{switch}"[,@var{obj}])
 :: $B4D6-@_Dj(B  \JP :: $B4D6-@_Dj(B
   \EG :: Sets the value of @var{switch}.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $B@_Dj$5$l$F$$$kCM(B  \JP $B@_Dj$5$l$F$$$kCM(B
   \EG value of @var{switch}
 @item switch  @item switch
 $B%9%$%C%AL>(B  \JP $B%9%$%C%AL>(B
   \EG switch name
 @item obj  @item obj
 $B%Q%i%a%?(B  \JP $B%Q%i%a%?(B
   \EG parameter
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 @b{Asir} $B$N<B9T4D6-$N@_DjJQ99(B, $B;2>H$r9T$&(B.  @b{Asir} $B$N<B9T4D6-$N@_DjJQ99(B, $B;2>H$r9T$&(B.
 @item @var{switch} $B$N$_$N>l9g(B, $B$=$N%9%$%C%A$N8=:_$N>uBV$rJV$9(B.  @item @var{switch} $B$N$_$N>l9g(B, $B$=$N%9%$%C%A$N8=:_$N>uBV$rJV$9(B.
Line 43 
Line 61 
 @item  @item
 $B%9%$%C%A$OJ8;zNs$H$7$FF~NO$9$k(B. $B$9$J$o$A%@%V%k%/%)!<%H$G0O$`(B.  $B%9%$%C%A$OJ8;zNs$H$7$FF~NO$9$k(B. $B$9$J$o$A%@%V%k%/%)!<%H$G0O$`(B.
 @item  @item
 $B%9%$%C%A$O<!$NDL$j(B.  $B%9%$%C%A$O<!$NDL$j(B. $B0J2<$G(B, on $B$O(B 1, off $B$O(B 0 $B$r0UL#$9$k(B.
 @table @code  @table @code
 @item cputime  @item cputime
 on $B$N;~(B CPU time $B$*$h$S(B GC time $B$rI=<((B, off $B$N;~(B $BI=<($7$J$$(B. @code{cputime()}  on $B$N;~(B CPU time $B$*$h$S(B GC time $B$rI=<((B, off $B$N;~(B $BI=<($7$J$$(B. @code{cputime()}
Line 57  on $B$N;~$OI8=`F~NO$r7+$jJV$7$F=PNO$7(B, off $B$N;~
Line 75  on $B$N;~$OI8=`F~NO$r7+$jJV$7$F=PNO$7(B, off $B$N;~
 @code{output} $B%3%^%s%I$rMQ$$$k:]$KM-8z$G$"$k(B.  @code{output} $B%3%^%s%I$rMQ$$$k:]$KM-8z$G$"$k(B.
 @item bigfloat  @item bigfloat
 on $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B @b{bigfloat} $B$KJQ49$5$l(B, $BIbF0>.?t1i;;$O(B  on $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B @b{bigfloat} $B$KJQ49$5$l(B, $BIbF0>.?t1i;;$O(B
 @b{PARI} (@xref{pari}) $B$K$h$j9T$o$l$k(B. $B%G%U%)%k%H$NM-8z7e?t$O(B 9 $B7e$G$"$k(B.  @b{PARI} (@ref{pari}) $B$K$h$j9T$o$l$k(B. $B%G%U%)%k%H$NM-8z7e?t$O(B 9 $B7e$G$"$k(B.
 $BM-8z7e?t$rA}$d$7$?$$;~$K$O(B @code{setprec()} $B$rMQ$$$k(B.  $BM-8z7e?t$rA}$d$7$?$$;~$K$O(B @code{setprec()} $B$rMQ$$$k(B.
 off $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B, $BG\@:EYIbF0>.?t$KJQ49$5$l$k(B.  off $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B, $BG\@:EYIbF0>.?t$KJQ49$5$l$k(B.
 @cindex PARI  @cindex PARI
Line 68  off $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B, $BG\@:EYI
Line 86  off $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B, $BG\@:EYI
 @xref{$B%3%^%s%I%i%$%s%*%W%7%g%s(B}.  @xref{$B%3%^%s%I%i%$%s%*%W%7%g%s(B}.
 @item verbose  @item verbose
 on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k(B.  on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k(B.
   @item quiet_mode
   1 $B$N$H$-(B, $B5/F0;~$KCx:n8"I=<($r9T$o$J$$(B.
   @xref{$B%3%^%s%I%i%$%s%*%W%7%g%s(B}.
   @item prompt
   0 $B$N$H$-%W%m%s%W%H$rI=<($7$J$$(B. 1 $B$N$H$-I8=`%W%m%s%W%H$rI=<((B.
   C $B%9%?%$%k$N%U%)%^%C%HJ8;zNs$r$b$A$$$k$H%f!<%6Dj5A$N%W%m%s%W%H(B.
   $BNc(B(asirgui $B$G$OIT2D(B):
   @code{ ctrl("prompt","\033[32m[%d]:= \033[0m")}
 @item hex  @item hex
 1 $B$N$H$-(B, $B@0?t$O(B 0x $B$G;O$^$k(B 16 $B?J?t$H$7$FI=<($5$l$k(B. -1 $B$N$H$-(B, 16 $B?J?t$O(B,  1 $B$N$H$-(B, $B@0?t$O(B 0x $B$G;O$^$k(B 16 $B?J?t$H$7$FI=<($5$l$k(B. -1 $B$N$H$-(B, 16 $B?J?t$O(B,
 $B4V$K(B @samp{|} $B$r$O$5$s$G(B 8 $B7e$4$H$K6h@Z$C$FI=<($5$l$k(B.  $B4V$K(B @samp{|} $B$r$O$5$s$G(B 8 $B7e$4$H$K6h@Z$C$FI=<($5$l$k(B.
   @item real_digit
   $BG\@:EYIbF0>.?t$NI=<($N7e?t$r;XDj$9$k(B.
   @item double_output
   1 $B$N$H$-(B, $BG\@:EYIbF0>.?t$O$D$M$K(B ddd.ddd $B$N7A$GI=<($5$l$k(B.
   @item fortran_output
   1 $B$N$H$-(B, $BB?9`<0$NI=<($,(B FORTRAN $B%9%?%$%k$K$J$k(B. $B$9$J$o$AQQ$,(B
   @samp{^} $B$NBe$o$j$K(B @samp{**} $B$GI=$5$l$k(B.
   ($B%G%U%)%k%HCM$O(B 0.)
 @item ox_batch  @item ox_batch
 1 $B$N$H$-(B, $BAw?.%P%C%U%!$,$$$C$Q$$$K$J$C$?;~$N$_<+F0E*$K(B flush.  1 $B$N$H$-(B, $BAw?.%P%C%U%!$,$$$C$Q$$$K$J$C$?;~$N$_<+F0E*$K(B flush.
 0 $B$N$H$-(B, $B%G!<%?(B, $B%3%^%s%IAw?.Kh$K(B flush. ($B%G%U%)%k%HCM$O(B 0.)  0 $B$N$H$-(B, $B%G!<%?(B, $B%3%^%s%IAw?.Kh$K(B flush. ($B%G%U%)%k%HCM$O(B 0.)
 @xref{$BJ,;67W;;(B}  @xref{$BJ,;67W;;(B}.
 @item ox_check  @item ox_check
 1 $B$N$H$-(B, $BAw?.%G!<%?$rAj<j%W%m%;%9$,<u$1<h$l$k$+$I$&$+%A%'%C%/$9$k(B.  1 $B$N$H$-(B, $BAw?.%G!<%?$rAj<j%W%m%;%9$,<u$1<h$l$k$+$I$&$+%A%'%C%/$9$k(B.
 0 $B$N$H$-$7$J$$(B. ($B%G%U%)%k%HCM$O(B 1.)  0 $B$N$H$-$7$J$$(B. ($B%G%U%)%k%HCM$O(B 1.)
 @xref{$BJ,;67W;;(B}  @xref{$BJ,;67W;;(B}.
   @item ox_exchange_mathcap
   1 $B$N$H$-(B, OX server $B$H$N@\B33+;O;~$K(B, $B<+F0E*$K(B mathcap $B$N8r49$r9T$&(B.
   ($B%G%U%)%k%HCM$O(B 1.)
   @xref{$BJ,;67W;;(B}.
   @item debug_window
   1 $B$N;~(B debug_window $B$,%]%C%W%"%C%W$7$F3+$/(B.
   ($B%G%U%)%k%HCM$O(B 0.)
   @item fake_ox_reset
   1 $B$N$H$-(B, ox_reset $B$r<BAu$7$F$J$$%5!<%P!<$K$OBe$o$j$K(B ox_shutdown $B$rAw?.$9$k(B.
   ox_reset $B$N<BAu$NM-L5$O(B mathcap $B$N(B optional argument ($BBh;M0z?t(B)
   $B$KJ8;zNs(B no_ox_reset $B$,@_Dj$5$l$F$$$k$+$I$&$+$GH=CG$9$k(B.
   ox_pari $B$rMxMQ$9$k$H$-$O$3$N%U%i%0$r(B1$B$K$7$F$*$/$3$H$,K>$^$7$$(B.
   ($B%G%U%)%k%HCM$O(B 0.)
   @xref{$BJ,;67W;;(B}.
 @end table  @end table
   \E
   \BEG
   @item
   This function is used to set or to get the values of switches.
   The switches are used to control an execution of @b{Asir}.
   @item If @var{obj} is not specified, the value of @var{switch} is returned.
   @item If @var{obj} is specified, the value of @var{switch} is set to
   @var{obj}.
   @item
   Switches are specified by strings, namely, enclosed by two
   double quotes.
   @item
   Here are of switches of @b{Asir}.
   @table @code
   @item cputime
   If `on', CPU time and GC time is displayed at every top level evaluation
   of @b{Asir} command; if `off', not displayed.
   @xref{cputime tstart tstop}.
   (The switch is also set by command @code{cputime(1)}, and
   reset by @code{cputime(0)}.)
   @item nez
   Selection for EZGCD algorithm.  It is set to 1 by default.  Ordinary
   users need not change this setting.
   @item echo
   If `on', inputs from the standard input will be echoed onto the
   standard output.  When executing to load a file, the contents of the
   file will be written onto the standard output.
   If `off', the inputs will not be echoed.
   This command will be useful when used with command @code{output}.
   @item bigfloat
   If `on', floating operations will be done by @b{PARI} system with arbitrary
   precision floating point operations.
   Default precision is set to 9 digits.  To change the precision, use
   command @code{setprec}.
   If `off', floating operations will be done by @b{Asir}'s own floating
   operation routines with a fixed precision operations of
   standard floating double.
   @cindex PARI
   @item adj
   Sets the frequency of garbage collection. A rational number greater
   than or equal to 1 can be specified. The default value is 3.
   If a value closer to 1 is specified, larger heap is allocated
   and as a result, the frequency of garbage collection decreases.
   @xref{Command line options}.
   @item verbose
   If `on' a warning messages is displayed when a function is redefined.
   @item quiet_mode
   If 1 is set, the copyright notice has been displayed at boot time.
   @item prompt
   If the value is 0, then prompt is not output.
   If the value is 1, then the standard prompt is output.
   Asir prompt can be customized by giving a C-style format string.
   Example (for unix asir);
   @code{ ctrl("prompt","\033[32m[%d]:= \033[0m")}
   
   @item hex
   If 1 is set, integers are displayed as hexadecimal numbers with prefix
   @code{0x}. if -1 is set, hexadecimal numbers are displayed with
   @samp{|} inserted at every 8 hexadecimal digits.
   @item real_digit
   Sets the number of digits used to print a floating double.
   @item double_output
   If set to 1, any floating double is printed in the style ddd.ddd.
   @item fortran_output
   If `on' polynomials are displayed in FORTRAN style. That is, a power
   is represented by @samp{**} instead of @samp{^}.
   The default value is 'off.
   @item ox_batch
   If 'on', the OpenXM send buffer is flushed only when the buffer is full.
   If 'off', the buffer is always flushed at each sending of data or command.
   The default value is 'off'.
   @xref{Distributed computation}.
   @item ox_check
   If 'on' the check by mathcap is done before sending data.
   The default value is 'on'.
   @xref{Distributed computation}.
   @item ox_exchange_mathcap
   If 'on' Asir forces the exchange of mathcaps at the communication startup.
   The default value is 'on'.
   @xref{Distributed computation}.
   @item debug_window
   When 1, a debug window pops up.
   (The default value is 0.)
   @item fake_ox_reset
   When 1, the function ox_reset sends ox_shutdown insread of ox_reset
   to servers which do not implement ox_reset protocol.
   It is checked by the optional argument (the fourth argument)
   containing the string "no_ox_reset"
   of mathcap if ox_reset is implemented or not.
   When you use ox_pari, it is recommended to set this flag 1.
   (The default value is 0.)
   @xref{Distributed computation}.
   @end table
   \E
 @end itemize  @end itemize
   
 @table @t  @table @t
 @item $B;2>H(B  \JP @item $B;2>H(B
   \EG @item References
 @fref{cputime tstart tstop}, @fref{output},  @fref{cputime tstart tstop}, @fref{output},
 @fref{pari}, @fref{setprec}, @fref{eval}.  @fref{pari}, @fref{setprec}, @fref{eval deval}.
 @end table  @end table
   
 @node debug,,, $B$=$NB>(B  \JP @node debug,,, $B$=$NB>(B
   \EG @node debug,,, Miscellaneouses
 @subsection @code{debug}  @subsection @code{debug}
 @findex debug  @findex debug
   
 @table @t  @table @t
 @item debug  @item debug
 :: $B%G%P%C%0%b!<%I$KF~$k(B.  \JP :: $B%G%P%C%0%b!<%I$KF~$k(B.
   \EG :: Forces to enter into debugging mode.
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 @code{debug} $B$OL50z?t$NH!?t$G$"$k$,(B, @samp{()} $B$J$7$G8F$S=P$;$k(B.  @code{debug} $B$OL50z?t$NH!?t$G$"$k$,(B, @samp{()} $B$J$7$G8F$S=P$;$k(B.
 @item  @item
Line 105  on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k
Line 251  on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k
 $B<u$1IU$1>uBV$H$J$k(B. @code{quit} $B$rF~NO$9$k$H%G%P%C%,$+$iH4$1$k(B.  $B<u$1IU$1>uBV$H$J$k(B. @code{quit} $B$rF~NO$9$k$H%G%P%C%,$+$iH4$1$k(B.
 @item  @item
 $B%G%P%C%0%b!<%I$K$D$$$F$N>\:Y$O(B @xref{$B%G%P%C%,(B}.  $B%G%P%C%0%b!<%I$K$D$$$F$N>\:Y$O(B @xref{$B%G%P%C%,(B}.
   \E
   \BEG
   Function @code{debug} is a function with no argument.
   It can be called without @samp{()}.
   @item
   In the debug-mode, you are prompted by @code{(debug)} and
   the debugger is ready for commands.
   Typing in @code{quit} (Note! without a semicolon.) brings you
   to exit the debug-mode.
   @item
   See @ref{Debugger} for details.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 114  on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k
Line 272  on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k
 [2]  [2]
 @end example  @end example
   
 @node error,,, $B$=$NB>(B  \JP @node error,,, $B$=$NB>(B
   \EG @node error,,, Miscellaneouses
 @subsection @code{error}  @subsection @code{error}
 @findex error  @findex error
   
 @table @t  @table @t
 @item error(@var{message})  @item error(@var{message})
 :: $B%W%m%0%i%`Cf$G6/@)E*$K%(%i!<$rH/@8$5$;$k(B.  \JP :: $B%W%m%0%i%`Cf$G6/@)E*$K%(%i!<$rH/@8$5$;$k(B.
   \EG :: Forces @b{Asir} to cause an error and enter debugging mode.
 @end table  @end table
   
 @table @var  @table @var
 @item message  @item message
 $BJ8;zNs(B  \JP $BJ8;zNs(B
   \EG string
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 $B0lHL$K(B, $B0z?t$N4V0c$$$J$I(B, $BB39TIT2DG=$J%(%i!<$,AH$_9~$_H!?t$K$*$$$F(B  $B0lHL$K(B, $B0z?t$N4V0c$$$J$I(B, $BB39TIT2DG=$J%(%i!<$,AH$_9~$_H!?t$K$*$$$F(B
 $BH/@8$7$?;~(B, $B%H%C%W%l%Y%k$KLa$kA0$K(B, $B2DG=$J$i$P$=$N%(%i!<$N;~E@$G(B  $BH/@8$7$?;~(B, $B%H%C%W%l%Y%k$KLa$kA0$K(B, $B2DG=$J$i$P$=$N%(%i!<$N;~E@$G(B
Line 140  on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k
Line 302  on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k
 @item  @item
 $B%f!<%6H!?t$K$*$$$F(B, $BJQ?t$r%A%'%C%/$7$F(B, $B$"$jF@$J$$CM$N>l9g$K(B @code{error()}  $B%f!<%6H!?t$K$*$$$F(B, $BJQ?t$r%A%'%C%/$7$F(B, $B$"$jF@$J$$CM$N>l9g$K(B @code{error()}
 $B$r8F$S=P$9$h$&$K$7$F$*$1$P(B, $B$=$N;~E@$G<+F0E*$K%G%P%C%0%b!<%I$KF~$l$k(B.  $B$r8F$S=P$9$h$&$K$7$F$*$1$P(B, $B$=$N;~E@$G<+F0E*$K%G%P%C%0%b!<%I$KF~$l$k(B.
   \E
   \BEG
   @item
   When @b{Asir} encounters a serious error such that it finds difficult
   to continue execution,
   it, in general, tries to enter debugging mode before it returns to
   top level.
   The command @code{error()} forces a similar behavior in a user program.
   @item
   The argument is a string which will be displayed when @code{error()}
   will be executed.
   @item
   You can enter the debug-mode when your program encounters an illegal
   value for a program variable, if you have written the program
   so as to call @code{error()} upon finding such an error in your program
   text.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 168  return to toplevel
Line 347  return to toplevel
 @end example  @end example
   
 @table @t  @table @t
 @item $B;2>H(B  \JP @item $B;2>H(B
   \EG @item References
 @fref{debug}.  @fref{debug}.
 @end table  @end table
   
 @node help,,, $B$=$NB>(B  \JP @node help,,, $B$=$NB>(B
   \EG @node help,,, Miscellaneouses
 @subsection @code{help}  @subsection @code{help}
 @findex help  @findex help
   
 @table @t  @table @t
 @item help(["@var{function}"])  @item help(["@var{function}"])
 :: $BH!?t$N@bL@$rI=<($9$k(B.  \JP :: $BH!?t$N@bL@$rI=<($9$k(B.
   \EG :: Displays the description of function @var{function}.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 0  0
 @item function  @item function
 $BH!?tL>(B  \JP $BH!?tL>(B
   \EG function name
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 $BL50z?t$N;~(B, $B:G>.8B$N@bL@$,I=<($5$l$k(B. $BH!?tL>$,0z?t$H$7$FM?$($i$l$?(B  $BL50z?t$N;~(B, $B:G>.8B$N@bL@$,I=<($5$l$k(B. $BH!?tL>$,0z?t$H$7$FM?$($i$l$?(B
 $B$H$-(B, $BI8=`%i%$%V%i%j%G%#%l%/%H%j$K$"$k(B @samp{help} $B$H$$$&%G%#%l%/%H%j(B  $B$H$-(B, $BI8=`%i%$%V%i%j%G%#%l%/%H%j$K$"$k(B @samp{help} $B$H$$$&%G%#%l%/%H%j(B
 $B$KF1L>$N%U%!%$%k$,$"$l$P(B, $B4D6-JQ?t(B @code{PAGER} $B$K@_Dj$5$l$F$$$k%3%^%s%I(B,  $B$KF1L>$N%U%!%$%k$,$"$l$P(B, $B4D6-JQ?t(B @code{PAGER} $B$K@_Dj$5$l$F$$$k%3%^%s%I(B,
 $B$"$k$$$O(B @samp{more} $B$r8F$S=P$7$F$=$N%U%!%$%k$rI=<($9$k(B.  $B$"$k$$$O(B @samp{more} $B$r8F$S=P$7$F$=$N%U%!%$%k$rI=<($9$k(B.
 @item  @item
   $B4D6-JQ?t(B @code{LANG} $B$,@_Dj$5$l$F$$$k>l9g(B, $B$=$NCM$,(B @code{"japan"} $B$^$?$O(B
   @code{"ja_JP"} $B$G;O$^$k$J$i(B, @samp{help} $B$NBe$o$j$K(B @samp{help-ja}
   $B$K$"$k%U%!%$%k$,I=<($5$l$k(B. $B$=$&$G$J$$>l9g(B, @samp{help-en}
   $B$K$"$k%U%!%$%k$,I=<($5$l$k(B.
   @item
 Windows $BHG$G$O(B, $B%3%^%s%I%i%$%s$+$i$N%X%k%W8F$S=P$7$OL$%5%]!<%H$@$,(B,  Windows $BHG$G$O(B, $B%3%^%s%I%i%$%s$+$i$N%X%k%W8F$S=P$7$OL$%5%]!<%H$@$,(B,
 $B%a%K%e!<$+$i(B HTML $B7A<0$N$b$N$r8F$S=P$7MQ$$$k$3$H$,$G$-$k(B.  $B%a%K%e!<$+$i(B HTML $B7A<0$N$b$N$r8F$S=P$7MQ$$$k$3$H$,$G$-$k(B.
   \E
   \BEG
   @item
   If invoked without argument, it displays rough usage of @b{Asir}.
   @item
   If a function name is given and if there exists a file with the
   same name in the directory @samp{help} under standard library directory,
   the file is displayed by a command set to the environmental variable
   @code{PAGER} or else command @samp{more}.
   @item
   If the @code{LANG} environment variable is set and its value
   begins with @code{"japan"} or @code{"ja_JP"}, then the file in
   @samp{help-ja} is displayed. If its value does not begin with
   @code{"japan"} or @code{"ja_JP"}, then the file in @samp{help-en}
   is displayed.
   @item
   On Windows HTML-style help is available from the menu.
   \E
 @end itemize  @end itemize
   
 @node time,,, $B$=$NB>(B  \JP @node time,,, $B$=$NB>(B
   \EG @node time,,, Miscellaneouses
 @subsection @code{time}  @subsection @code{time}
 @findex time  @findex time
   
 @table @t  @table @t
 @item time()  @item time()
 :: $B%;%C%7%g%s3+;O$+$i8=:_$^$G$N(B CPU $B;~4V$*$h$S(B GC $B;~4V$rI=<($9$k(B  \JP :: $B%;%C%7%g%s3+;O$+$i8=:_$^$G$N(B CPU $B;~4V$*$h$S(B GC $B;~4V$rI=<($9$k(B
   \BEG
   :: Returns a four element list consisting of
   total CPU time, GC time, the elapsed time
   and also total memory quantities requested
   from the start of current @b{Asir} session.
   \E
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $B%j%9%H(B  \JP $B%j%9%H(B
   \EG list
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 CPU $B;~4V$*$h$S(B GC $B;~4V$NI=<($K4X$9$k%3%^%s%I$G$"$k(B.  CPU $B;~4V$*$h$S(B GC $B;~4V$NI=<($K4X$9$k%3%^%s%I$G$"$k(B.
 @item  @item
Line 241  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
Line 457  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
 @code{getrusage()} $B$,;H$($k(B UNIX $B>e$G$O(B @code{time()} $B$O?.Mj@-$N$"$kCM(B  @code{getrusage()} $B$,;H$($k(B UNIX $B>e$G$O(B @code{time()} $B$O?.Mj@-$N$"$kCM(B
 $B$rJV$9$,(B, Windows 95, 98 $B>e$G$O;~9o$rMQ$$$k$[$+J}K!$,$J$$$?$a7P2a;~4V$=$N$b$N(B  $B$rJV$9$,(B, Windows 95, 98 $B>e$G$O;~9o$rMQ$$$k$[$+J}K!$,$J$$$?$a7P2a;~4V$=$N$b$N(B
 $B$,I=<($5$l$k(B. $B$h$C$F(B, $BBT$A>uBV$,$"$k$H(B, $B$=$l$b7P2a;~4V$K2C;;$5$l$k(B.  $B$,I=<($5$l$k(B. $B$h$C$F(B, $BBT$A>uBV$,$"$k$H(B, $B$=$l$b7P2a;~4V$K2C;;$5$l$k(B.
   \E
   \BEG
   @item
   These are commands regarding CPU time and GC time.
   @item
   The GC time is the time regarded to spent by the garbage collector,
   and the CPU time is the time defined by subtracting the GC time from
   the total time consumed by command @b{Asir}.  Their unit is `second.'
   @item
   Command @code{time()} returns total CPU time and GC time measured
   from the start of current @b{Asir} session. It also returns the elapsed
   time. Time unit is `second.'
   Moreover, it returns total memory quantities in words
   (usually 4 bytes) which are requested
   to the memory manager from the beginning of the current session.
   The return value is a list and the format is @code{[CPU time, GC time,
   Memory, Elapsed time]}.
   @item
   You can find the CPU time and GC time for some computation by taking
   the difference of the figure reported by @code{time()} at the beginning
   and the ending of the computation.
   @item
   Since arbitrary precision integers are NOT used for counting
   the total amount of memory request, the number will eventually happen
   to become meaningless due to integer overflow.
   @item
   When @code{cputime} switch is active by @code{ctrl()} or by
   @code{cputime()}, the execution time will be displayed after every
   evaluation of top level statement.
   In a program, however, in order to know the execution time for a
   sequence of computations, you have to use @code{time()} command, for
   an example.
   @item
   On UNIX, if @code{getrusage()} is available, @code{time()} reports
   reliable figures. On Windows NT it also gives reliable CPU time.
   However, on Windows 95/98, the reported time is nothing but
   the elapsed time of the real world.
   Therefore, the time elapsed in the debug-mode and the time of waiting
   for a reply to interruption prompting are added to the elapsed time.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 254  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
Line 510  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
 @end example  @end example
   
 @table @t  @table @t
 @item $B;2>H(B  \JP @item $B;2>H(B
 @fref{cputime tstart tstop}.  \EG @item References
   @fref{cputime tstart tstop}, @fref{currenttime}.
 @end table  @end table
   
 @node cputime tstart tstop,,, $B$=$NB>(B  \JP @node cputime tstart tstop,,, $B$=$NB>(B
   \EG @node cputime tstart tstop,,, Miscellaneouses
 @subsection @code{cputime}, @code{tstart}, @code{tstop}  @subsection @code{cputime}, @code{tstart}, @code{tstop}
 @findex cputime  @findex cputime
 @findex tstart  @findex tstart
Line 266  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
Line 524  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
   
 @table @t  @table @t
 @item cputime(@var{onoff})  @item cputime(@var{onoff})
 :: $B0z?t$,(B 0 $B$J$i$P(B @code{cputime} $B$NI=<($r;_$a$k(B. $B$=$l0J30$J$i$PI=<($r9T$&(B.  \JP :: $B0z?t$,(B 0 $B$J$i$P(B @code{cputime} $B$NI=<($r;_$a$k(B. $B$=$l0J30$J$i$PI=<($r9T$&(B.
   \BEG
   :: Stop displaying @code{cputime} if its argument is 0, otherwise
   start displaying @code{cputime} after every top level evaluation of
   Asir command.
   \E
 @item tstart()  @item tstart()
 :: CPU time $B7WB,3+;O(B.  \JP :: CPU time $B7WB,3+;O(B.
   \EG :: Resets and starts timer for CPU time and GC time.
 @item tstop()  @item tstop()
 :: CPU time $B7WB,=*N;$*$h$SI=<((B.  \JP :: CPU time $B7WB,=*N;$*$h$SI=<((B.
   \BEG
   :: Stops timer and then displays CPU time GC time elapsed from the
   last time when timer was started.
   \E
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 0  0
 @item onoff  @item onoff
 $B%U%i%0(B ($BG$0U(B)  \JP $B%U%i%0(B ($BG$0U(B)
   \EG flag (arbitrary)
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 @code{cputime()} $B$O(B, $B0z?t$,(B 0 $B$J$i$P(B CPU time $B$NI=<($r;_$a$k(B. $B$=$l0J30$J$i$PI=<($r9T$&(B.  @code{cputime()} $B$O(B, $B0z?t$,(B 0 $B$J$i$P(B CPU time $B$NI=<($r;_$a$k(B. $B$=$l0J30$J$i$PI=<($r9T$&(B.
 @item  @item
Line 299  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
Line 569  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
 $B$N0l$D$NJ8$KBP$9$k7WB,$O>o$K9T$o$l$F$$$k(B. $B$h$C$F(B, $B7W;;$r;O$a$F$+$i$G$b(B,  $B$N0l$D$NJ8$KBP$9$k7WB,$O>o$K9T$o$l$F$$$k(B. $B$h$C$F(B, $B7W;;$r;O$a$F$+$i$G$b(B,
 $B7W;;=*N;A0$K%G%P%C%,$KF~$C$F(B @code{cputime(1)} $B$r<B9T$5$;$l$P7W;;;~4V$O(B  $B7W;;=*N;A0$K%G%P%C%,$KF~$C$F(B @code{cputime(1)} $B$r<B9T$5$;$l$P7W;;;~4V$O(B
 $BI=<($5$l$k(B.  $BI=<($5$l$k(B.
   \E
   \BEG
   @item
   Command @code{cputime()} with NON-ZERO argument enables @b{Asir} to display
   CPU time and GC time after every evaluation of top level @b{Asir} command.
   The command with argument 0 disables displaying them.
   @item
   Command @code{tstart()} starts measuring CPU time and GC time without
   arguments.  The parentheses @samp{()} may be omitted.
   @item
   Command @code{tstop()} stops measuring CPU time and GC time and displays
   them without arguments. The parentheses @samp{()} may be omitted.
   @item
   Command @code{cputime(@var{onoff})} has same meaning as
   @code{ctrl("cputime",@var{onoff})}.
   @item
   Nested use of @code{tstart()} and @code{tstop()} is not expected.
   If such an effect is desired, use @code{time()}.
   @item
   On and off states by @code{cputime()} have effects only to displaying
   mode.  Time for evaluation of every top level statement is always
   measured.
   Therefore, even after a computation has already started,
   you can let @b{Asir} display the timings, whenever you enter
   the debug-mode and execute @code{cputime(1)}.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 311  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
Line 607  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
 @end example  @end example
   
 @table @t  @table @t
 @item $B;2>H(B  \JP @item $B;2>H(B
 @fref{time}, @fref{ctrl}.  \EG @item References
   @fref{time}, @fref{currenttime}, @fref{ctrl}.
 @end table  @end table
   
 @node heap,,, $B$=$NB>(B  \JP @node timer,,, $B$=$NB>(B
   \EG @node timer,,, Miscellaneouses
   @subsection @code{timer}
   @findex timer
   
   @table @t
   @item timer(@var{interval},@var{expr},@var{val})
   \JP :: $B@)8B;~4V$D$-$G7W;;$r<B9T$9$k(B.
   \EG :: Compute an expression under the interval timer.
   @end table
   
   @table @var
   @item return
   \JP $B7k2L(B
   \EG result
   
   @item interval
   \JP $B@)8B;~4V(B ($BIC(B)
   \EG interval (second)
   
   @item expr
   \JP $B7W;;$9$k<0(B
   \EG expression to be computed
   
   @item val
   \JP $B%?%$%^$K$h$kCfCG;~$NLa$jCM(B
   \EG a value to be returned when the timer is expired
   @end table
   
   @itemize @bullet
   
   \BJP
   @item
   @code{timer()} $B$O(B, $B;~4V$r;XDj$7$F7W;;$r<B9T$9$k(B. $B;XDj;~4VFb$K7W;;$,40N;(B
   $B$7$?>l9g$=$NCM$rJV$9(B. $B;XDj;~4VFb$K7W;;$,40N;$7$J$+$C$?>l9g(B, $BBh(B 3 $B0z?t(B
   $B$rJV$9(B.
   
   @item
   $BBh(B 3 $B0z?t$NCM$O(B, $B7W;;$,40N;$7$?>l9g$NCM$H6hJL$G$-$kI,MW$,$"$k(B.
   \E
   
   \BEG
   @item
   @code{timer()} computes an expression under the interval timer.
   If the computation finishes within the specified interval, it
   returns the result of the computation. Otherwise it returns the third
   argument.
   
   @item
   The third argument should be distinguishable from the result on success.
   \E
   
   @end itemize
   
   @example
   [0] load("cyclic");
   1
   [10] timer(10,dp_gr_main(cyclic(7),[c0,c1,c2,c3,c4,c5,c6],1,1,0),0);
   interval timer expired (VTALRM)
   0
   [11]
   @end example
   
   \JP @node currenttime,,, $B$=$NB>(B
   \EG @node currenttime,,, Miscellaneouses
   @subsection @code{currenttime}
   @findex currenttime
   
   @table @t
   @item currenttime()
   \JP :: $B8=:_;~9o$r<hF@(B
   \EG :: Get current time.
   @end table
   
   @table @var
   @item return
   \JP 1970$BG/(B1$B7n(B1$BF|(B0$B;~(B0$BJ,(B0$BIC$+$i$N7P2aIC?t(B.
   \EG UNIX time.
   @end table
   
   @itemize @bullet
   
   @item
   \JP @code{currenttime()} $B$O8=:_;~9o$rJV$9(B.  UNIX $B$N>l9g(B, time(3) $B$r8F$s$G$$$k$@$1$G$"$k(B.
   \EG See also time(3) in UNIX manuals.
   
   @end itemize
   
   @example
   [0] currenttime();
   1071639228
   [1]
   @end example
   
   \JP @node sleep,,, $B$=$NB>(B
   \EG @node sleep,,, Miscellaneouses
   @subsection @code{sleep}
   @findex sleep
   
   @table @t
   @item sleep(@var{interval})
   \JP :: $B%W%m%;%9$N<B9T$rDd;_(B
   \EG :: Suspend computation for an interval.
   @end table
   
   @table @var
   @item return
   1
   
   @item interval
   \JP $BDd;_;~4V(B ($B%^%$%/%mIC(B)
   \EG interval (micro second)
   @end table
   
   @itemize @bullet
   
   @item
   \JP @code{sleep()} $B$O(B, $B%W%m%;%9$N<B9T$rDd;_$9$k(B.  UNIX $B$N>l9g(B, usleep $B$r8F$s$G$$$k$@$1$G$"$k(B.
   \EG See also usleep(3) in UNIX manuals.
   
   @end itemize
   
   @example
   [0] sleep(1000);
   1
   [1]
   @end example
   
   \JP @node heap,,, $B$=$NB>(B
   \EG @node heap,,, Miscellaneouses
 @subsection @code{heap}  @subsection @code{heap}
 @findex heap  @findex heap
   
 @table @t  @table @t
 @item heap()  @item heap()
 :: $B8=:_$N%R!<%W$NBg$-$5$rJV$9(B. ($BC10L(B:$B%P%$%H(B)  \JP :: $B8=:_$N%R!<%W$NBg$-$5$rJV$9(B. ($BC10L(B:$B%P%$%H(B)
   \EG :: Heap area size currently in use.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $B<+A3?t(B  \JP $B<+A3?t(B
   \EG non-negative integer
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 $B8=:_$N%R!<%W$NBg$-$5(B($BC10L(B : $B%P%$%H(B) $B$rJV$9(B. $B%R!<%W$H$O(B, @b{Asir} $B$N(B  $B8=:_$N%R!<%W$NBg$-$5(B($BC10L(B : $B%P%$%H(B) $B$rJV$9(B. $B%R!<%W$H$O(B, @b{Asir} $B$N(B
 $B$5$^$6$^$J?t<0$d(B, $B%f!<%6%W%m%0%i%`$J$I$,$*$+$l$k%a%b%j$NNN0h$G(B, $B%,!<%Y%8(B  $B$5$^$6$^$J?t<0$d(B, $B%f!<%6%W%m%0%i%`$J$I$,$*$+$l$k%a%b%j$NNN0h$G(B, $B%,!<%Y%8(B
Line 339  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
Line 768  on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l
 @item  @item
 $B<B%a%b%j$,>/$J$$>l9g$K$O(B, $B5/F0;~$N(B @code{-adj} $B%*%W%7%g%s$K$h$j(B,  $B<B%a%b%j$,>/$J$$>l9g$K$O(B, $B5/F0;~$N(B @code{-adj} $B%*%W%7%g%s$K$h$j(B,
 GC $B<gBN$N@_Dj$r9T$C$F$*$/I,MW$,$"$k(B.  GC $B<gBN$N@_Dj$r9T$C$F$*$/I,MW$,$"$k(B.
   \E
   \BEG
   @item
   Command @code{heap()} returns an integer which is the byte size
   of current @b{Asir} heap area.
   
   Heap is a memory area where various data for expressions and
   user programs of @b{Asir} and is managed by the garbage collector.
   While @b{Asir} is running, size of the heap is monotonously
   non-decreasing against the time elapsed.  If it happens to exceed the
   real memory size, most (real world) time is consumed for swapping between
   real memory and disk memory.
   @item
   For a platform with little real memory, it is recommended to set up
   @b{Asir} configuration tuned for GC functions by @code{-adj} option
   at the activation of @b{Asir}. (@xref{Command line options}.)
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 373  GC $B<gBN$N@_Dj$r9T$C$F$*$/I,MW$,$"$k(B. 
Line 819  GC $B<gBN$N@_Dj$r9T$C$F$*$/I,MW$,$"$k(B. 
 @end example  @end example
   
 @table @t  @table @t
 @item $B;2>H(B  \JP @item $B;2>H(B
 @fref{$B%3%^%s%I%i%$%s%*%W%7%g%s(B}.  \EG @item References
   \JP @fref{$B%3%^%s%I%i%$%s%*%W%7%g%s(B}.
   \EG @fref{Command line options}.
 @end table  @end table
   
 @node version,,, $B$=$NB>(B  \JP @node version,,, $B$=$NB>(B
   \EG @node version,,, Miscellaneouses
 @subsection @code{version}  @subsection @code{version}
 @findex version  @findex version
   
 @table @t  @table @t
 @item version()  @item version()
 :: @b{Asir} $B$N%P!<%8%g%s$rJV$9(B.  \JP :: @b{Asir} $B$N%P!<%8%g%s$rJV$9(B.
   \EG :: Version identification number of  @b{Asir}.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $B<+A3?t(B  \JP $B<+A3?t(B
   \EG integer
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 @b{Asir} $B$N%P!<%8%g%s$r(B 10 $B?J(B 6 $B7e$N<+A3?t$GJV$9(B. $B:G=i$N(B 2 $B7e$,(B  @b{Asir} $B$N%P!<%8%g%s$r<+A3?t$GJV$9(B.
 $B@>Nq$N2<(B 2 $B7e(B, $B<!$N(B 2 $B7e$,7n(B, $B:G8e$N(B 2 $B7e$,F|$rI=$9(B.  \E
   \BEG
   @item
   Command @code{version()} returns the version identification number,
   an integer of @b{Asir} in use.
   \E
 @end itemize  @end itemize
   
 @example  @example
 [0] version();  [0] version();
 990831  991214
 @end example  @end example
   
 @node shell,,, $B$=$NB>(B  \JP @node shell,,, $B$=$NB>(B
   \EG @node shell,,, Miscellaneouses
 @subsection @code{shell}  @subsection @code{shell}
 @findex shell  @findex shell
   
 @table @t  @table @t
 @item shell(@var{command})  @item shell(@var{command})
 :: @var{command} $B$r%7%'%k%3%^%s%I$H$7$F<B9T$9$k(B.  \JP :: @var{command} $B$r%7%'%k%3%^%s%I$H$7$F<B9T$9$k(B.
   \EG :: Execute shell commands described by a string @var{command}.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $B<+A3?t(B  \JP $B<+A3?t(B
   \EG integer
 @item command  @item command
 $BJ8;zNs(B  \JP $BJ8;zNs(B
   \EG string
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 @var{command} $B$r(B C $B$N(B @code{system()} $BH!?t$K$h$j%7%'%k%3%^%s%I$H$7$F<B9T$9$k(B.  @var{command} $B$r(B C $B$N(B @code{system()} $BH!?t$K$h$j%7%'%k%3%^%s%I$H$7$F<B9T$9$k(B.
 $B%7%'%k$N=*N;%9%F!<%?%9$rJV$9(B.  $B%7%'%k$N=*N;%9%F!<%?%9$rJV$9(B.
   \E
   \BEG
   Execute shell commands described by a string @var{command}
   by a C function @code{system()}.  This returns the exit status of shell
   as its return value.
   \E
 @end itemize  @end itemize
   
 @example  @example
 [0] shell("ls");  [0] shell("ls");
 alg             da              katsura         ralg            suit  alg           da            katsura       ralg          suit
 algt            defs.h          kimura          ratint          test  algt          defs.h        kimura        ratint        test
 alpi            edet            kimura3         robot           texput.log  alpi          edet          kimura3       robot         texput.log
 asir.o          fee             mfee            sasa            wang  asir.o        fee           mfee          sasa          wang
 asir_symtab     gr              mksym           shira           wang_data  asir_symtab   gr            mksym         shira         wang_data
 base            gr.h            mp              snf1            wt  base          gr.h          mp            snf1          wt
 bgk             help            msubst          solve  bgk           help          msubst        solve
 chou            hom             p               sp  chou          hom           p             sp
 const           ifplot          proot           strum  const         ifplot        proot         strum
 cyclic          is              r               sugar  cyclic        is            r             sugar
 0  0
 [1]  [1]
 @end example  @end example
   
 @node map,,, $B$=$NB>(B  \JP @node map,,, $B$=$NB>(B
   \EG @node map,,, Miscellaneouses
 @subsection @code{map}  @subsection @code{map}
 @findex map  @findex map
   
 @table @t  @table @t
 @item map(@var{function},@var{arg0},@var{arg1},...)  @item map(@var{function},@var{arg0},@var{arg1},...)
 :: $B%j%9%H(B, $BG[Ns$N3FMWAG$KH!?t$rE,MQ$9$k(B.  \JP :: $B%j%9%H(B, $BG[Ns$N3FMWAG$KH!?t$rE,MQ$9$k(B.
   \EG :: Applies a function to each member of a list or an array.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 @var{arg0} $B$HF1$87?$N%*%V%8%'%/%H(B  \JP @var{arg0} $B$HF1$87?$N%*%V%8%'%/%H(B
   \EG an object of the same type as @var{arg0}.
 @item function  @item function
 $BH!?tL>(B  \JP $BH!?tL>(B
   \EG the name of a function
 @item arg0  @item arg0
 $B%j%9%H(B, $B%Y%/%H%k(B, $B9TNs(B  \JP $B%j%9%H(B, $B%Y%/%H%k(B, $B9TNs(B
 @item arg1, ...  \EG list, vector or matrix
 $BG$0U(B ($B;D$j$N0z?t(B)  @item arg1  ...
   \JP $BG$0U(B ($B;D$j$N0z?t(B)
   \EG arbitrary (the rest of arguments)
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 @var{arg0} $B$N3FMWAG$r:G=i$N0z?t(B, @var{arg1} $B0J2<$N;D$j$N0z?t$H$7$F(B  @var{arg0} $B$N3FMWAG$r:G=i$N0z?t(B, @var{arg1} $B0J2<$N;D$j$N0z?t$H$7$F(B
 $BH!?t(B @var{function} $B$r8F$S=P$7(B, @var{arg0} $B$NBP1~$9$kMWAG$N0LCV$K(B  $BH!?t(B @var{function} $B$r8F$S=P$7(B, @var{arg0} $B$NBP1~$9$kMWAG$N0LCV$K(B
Line 473  cyclic          is              r               sugar
Line 948  cyclic          is              r               sugar
 @var{arg0} $B$,%j%9%H(B, $B%Y%/%H%k(B, $B9TNs0J30$N>l9g(B, $BC1$K(B @var{arg0},  @var{arg0} $B$,%j%9%H(B, $B%Y%/%H%k(B, $B9TNs0J30$N>l9g(B, $BC1$K(B @var{arg0},
 @var{arg1}, ... $B$r0z?t$H$7$F(B @var{function} $B$r8F$S=P$7$=$N(B  @var{arg1}, ... $B$r0z?t$H$7$F(B @var{function} $B$r8F$S=P$7$=$N(B
 $B7k2L$rJV$9(B.  $B7k2L$rJV$9(B.
   @item
   @code{map} $B$N0z?t(B @var{function} $B$GM?$($i$l$kH!?t$O(B, $BFbItE*$K$bH!?t$H(B
   $B$7$F<BAu$5$l$F$$$J$1$l$P$J$i$J$$(B.  $B$=$&$G$J$1$l$P(B parse error $B$K$J$k(B.
   $BNc$($P(B @code{map} $B<+?H$d(B @code{car}, @code{cdr} $B$J$I$OFbItE*$K$OH!?t$G(B
   $B$O$J$/(B, Asir $B$NJ8K!$K$*$1$k%-!<%o!<%I$H$7$F<BAu$5$l$F$$$k(B.  $B$7$?$,$C$F(B
   @code{map} $B$N0z?t$K(B @code{map} $B$r$H$k$3$H$O$G$-$J$$(B.
   \E
   \BEG
   @item
   Returns an object of the same type as @var{arg0}. Each member of the
   returned object is the return value of a function call where the first
   argument is the member of @var{arg0} corresponding to the member in
   the returned object and the rest of the argument are @var{arg1},
   @dots{}.
   @item
   @var{function} is a function name itself without @samp{"}.
   @item
   A program variable cannot be used as @var{function}.
   @item
   If @var{arg0} is neither list nor array this function simply
   returns the value of @var{function}(@var{arg0},@var{arg1},@dots{}).
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 481  cyclic          is              r               sugar
Line 978  cyclic          is              r               sugar
 [1,8,27]  [1,8,27]
 @end example  @end example
   
 @node flist,,, $B$=$NB>(B  \JP @node flist,,, $B$=$NB>(B
   \EG @node flist,,, Miscellaneouses
 @subsection @code{flist}  @subsection @code{flist}
 @findex flist  @findex flist
   
 @table @t  @table @t
 @item flist()  @item flist()
 :: $B8=:_Dj5A$5$l$F$$$kH!?tL>$rJ8;zNs%j%9%H$H$7$FJV$9(B.  \JP :: $B8=:_Dj5A$5$l$F$$$kH!?tL>$rJ8;zNs%j%9%H$H$7$FJV$9(B.
   \EG :: Returns the list of function names currently defined.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $BJ8;zNs$N%j%9%H(B  \JP $BJ8;zNs$N%j%9%H(B
   \EG list of character strings
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 $B8=:_Dj5A$5$l$F$$$kAH$_9~$_H!?t(B, $B%f!<%6Dj5AH!?t$NH!?tL>$rJ8;zNs%j%9%H(B  $B8=:_Dj5A$5$l$F$$$kAH$_9~$_H!?t(B, $B%f!<%6Dj5AH!?t$NH!?tL>$rJ8;zNs%j%9%H(B
 $B$H$7$FJV$9(B.  $B$H$7$FJV$9(B.
 @item  @item
 $B%7%9%F%`H!?t$N8e$K%f!<%6Dj5AH!?t$,B3$/(B.  $B%7%9%F%`H!?t$N8e$K%f!<%6Dj5AH!?t$,B3$/(B.
   \E
   \BEG
   @item
   Returns the list of names of built-in functions and user defined functions
   currently defined. The return value is a list of character strings.
   @item
   The names of built-in functions are followed by those of user defined
   functions.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 508  cyclic          is              r               sugar
Line 1018  cyclic          is              r               sugar
 [defpoly,newalg,mainalg,algtorat,rattoalg,getalg,alg,algv,...]  [defpoly,newalg,mainalg,algtorat,rattoalg,getalg,alg,algv,...]
 @end example  @end example
   
 @node delete_history,,, $B$=$NB>(B  \JP @node delete_history,,, $B$=$NB>(B
   \EG @node delete_history,,, Miscellaneouses
 @subsection @code{delete_history}  @subsection @code{delete_history}
 @findex delete_history  @findex delete_history
   
 @table @t  @table @t
 @item delete_history([@var{index}])  @item delete_history([@var{index}])
 :: $B%R%9%H%j$r>C5n$9$k(B.  \JP :: $B%R%9%H%j$r>C5n$9$k(B.
   \EG :: Deletes the history.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 0  0
 @item index  @item index
 $B>C5n$7$?$$%R%9%H%j$NHV9f(B  \JP $B>C5n$7$?$$%R%9%H%j$NHV9f(B
   \EG Index of history to be deleted.
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 $B0z?t$,$J$$$H$-(B, $B$3$l$^$G7W;;$7$?%R%9%H%j$rA4$F>C5n$9$k(B.  $B0z?t$,$J$$$H$-(B, $B$3$l$^$G7W;;$7$?%R%9%H%j$rA4$F>C5n$9$k(B.
 @item  @item
Line 537  cyclic          is              r               sugar
Line 1051  cyclic          is              r               sugar
 $BBg$-$J<0$,%R%9%H%j$H$7$F;D$C$?>l9g(B, $B0J9_$N%a%b%j4IM}$K;Y>c$rMh$9>l9g$,B?$$(B  $BBg$-$J<0$,%R%9%H%j$H$7$F;D$C$?>l9g(B, $B0J9_$N%a%b%j4IM}$K;Y>c$rMh$9>l9g$,B?$$(B
 $B$?$a(B, @code{bsave()} $B$J$I$G%U%!%$%k$K%;!<%V$7$F(B, @code{delete_history()}  $B$?$a(B, @code{bsave()} $B$J$I$G%U%!%$%k$K%;!<%V$7$F(B, @code{delete_history()}
 $B$K$h$j%R%9%H%j$r>C5n$7$F$*$/$N$,M-8z$G$"$k(B.  $B$K$h$j%R%9%H%j$r>C5n$7$F$*$/$N$,M-8z$G$"$k(B.
   \E
   \BEG
   @item
   Deletes all the histories without an argument.
   @item
   Deletes the history with index @var{index} if specified.
   @item
   A history is an expression which has been obtained by evaluating an input
   given for a prompt with an index. It can be taken out by @code{@@@var{index}},
   which means that the expression survives garbage collections.
   @item
   A large history may do harm in the subsequent memory management and
   deleting the history by @code{delete_history()}, after saving it in a file
   by @code{bsave()}, is often effective.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 548  cyclic          is              r               sugar
Line 1077  cyclic          is              r               sugar
 0  0
 @end example  @end example
   
 @node get_rootdir,,, $B$=$NB>(B  \JP @node get_rootdir,,, $B$=$NB>(B
   \EG @node get_rootdir,,, Miscellaneouses
 @subsection @code{get_rootdir}  @subsection @code{get_rootdir}
 @findex get_rootdir  @findex get_rootdir
   
 @table @t  @table @t
 @item get_rootdir()  @item get_rootdir()
 :: Asir $B$N%k!<%H%G%#%l%/%H%jL>$r<h$j=P$9(B  \JP :: Asir $B$N%k!<%H%G%#%l%/%H%jL>$r<h$j=P$9(B
   \EG :: Gets the name of @b{Asir} root directory.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $BJ8;zNs(B  \JP $BJ8;zNs(B
   \EG string
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 UNIX $BHG$N>l9g(B, $B4D6-JQ?t(B @code{ASIR_LIBDIR} $B$,Dj5A$5$l$F$$$k>l9g$K$O$=$NCM(B, $B$5$l$F$$$J$$>l9g(B  UNIX $BHG$N>l9g(B, $B4D6-JQ?t(B @code{ASIR_LIBDIR} $B$,Dj5A$5$l$F$$$k>l9g$K$O$=$NCM(B, $B$5$l$F$$$J$$>l9g(B
 $B$K$O(B @samp{/usr/local/lib/asir} $B$rJV$9(B.  $B$K$O(B @samp{/usr/local/lib/asir} $B$rJV$9(B.
Line 572  Windows $BHG$N>l9g(B, @samp{asirgui.exe} $B$N$"$k%G
Line 1105  Windows $BHG$N>l9g(B, @samp{asirgui.exe} $B$N$"$k%G
 @item  @item
 $B$3$N4X?t$,JV$9%G%#%l%/%H%jL>$r4p=`$H$7$?AjBP%Q%9L>$r;XDj$9$k$3$H$K$h$j(B, $B%$%s%9%H!<%k(B  $B$3$N4X?t$,JV$9%G%#%l%/%H%jL>$r4p=`$H$7$?AjBP%Q%9L>$r;XDj$9$k$3$H$K$h$j(B, $B%$%s%9%H!<%k(B
 $B$5$l$?>l=j$K$h$i$J$$%U%!%$%kFI$_9~$_%W%m%0%i%`$r=q$/$3$H$,$G$-$k(B.  $B$5$l$?>l=j$K$h$i$J$$%U%!%$%kFI$_9~$_%W%m%0%i%`$r=q$/$3$H$,$G$-$k(B.
   \E
   \BEG
   @item
   On UNIX it returns the value of an environment variable @code{ASIR_LIBDIR}
   or @samp{/usr/local/lib/asir} if @code{ASIR_LIBDIR} is not set.
   @item
   On Windows the name of @b{Asir} root directory is returned.
   @item
   By using relative path names from the value of this function,
   one can write programs which contain file operations independent
   of the install directory.
   \E
 @end itemize  @end itemize
   
   
   \JP @node getopt,,, $B$=$NB>(B
   \EG @node getopt,,, Miscellaneouses
   @subsection @code{getopt}
   @findex getopt
   
   @table @t
   @item getopt([@var{key}])
   \JP :: $B%*%W%7%g%s$NCM$rJV$9(B.
   \EG :: Returns the value of an option.
   @end table
   
   @table @var
   @item return
   \JP $B%*%V%8%'%/%H(B
   \EG object
   @end table
   
   @itemize @bullet
   \BJP
   @item
   $B%f!<%6Dj5A4X?t$O(B, $B8GDj8D?t0z?t$G$7$+@k8@$G$-$J$$(B. $B%f!<%6Dj5A4X?t$G(B
   $B2DJQ8D0z?t$r<B8=$9$kJ}K!$N0l$D$H$7$F(B, $B%*%W%7%g%s$K$h$k0z?t$N;XDj(B
   $B$,$"$k(B (@pxref{$B%*%W%7%g%s;XDj(B}). $B;XDj$5$l$?%*%W%7%g%s$r4X?tFb$G(B
   $B<u$1<h$k$?$a$K$3$N4X?t$rMQ$$$k(B.
   @item
   $BL50z?t$G8F$S=P$5$l$?>l9g(B, @code{getopt()} $B$O(B
   @code{[[key1,value1],[key2,value2],...]} $B$J$k%j%9%H$rJV$9(B.
   $B$3$3$G(B, @code{key} $B$O4X?t8F$S=P$7;~$K;XDj$5$l$?%*%W%7%g%s(B, @code{value}
   $B$O$=$NCM$G$"$k(B.
   @item
   $B4X?t8F$S=P$7$N:]$K(B @var{key} $B$,%*%W%7%g%s$H$7$F;XDj$5$l$F$$$k(B
   $B>l9g$K$O(B, $B$=$NCM$rJV$9(B. $B$b$7;XDj$,$J$$>l9g$K$O(B, VOID $B7?%*%V%8%'%/%H(B
   ($B7?<1JL;R(B -1) $B$rJV$9(B. @code{getopt()} $B$,JV$7$?CM$N7?$r(B @code{type()}
   $B$GD4$Y$k$3$H$G(B, $B$=$N%*%W%7%g%s$,;XDj$5$l$?$+$I$&$+D4$Y$k$3$H$,$G$-$k(B.
   @item
   $B4X?t8F$S=P$7$K$*$1$k%*%W%7%g%s$N;XDj$O(B, $B@55,$N0z?t$J$i$S$N8e$m$K(B,
   
   @example
   xxx(A,B,C,D|x=X,y=Y,z=Z)
   @end example
   
   $B$H$$$&Iw$K(B, @samp{|} $B$KB3$/(B, @var{key=value} $B$N(B @samp{,} $B$G6h@Z$i$l$?(B
   $BJB$S$rCV$/$3$H$G9T$&(B.
   \E
   \BEG
   @item
   When a user defined function is called, the number of arguments
   must be equal to that in the declaration of the function.
   A function with indefinite number of arguments can be realized
   by using @var{options} (@pxref{option}).
   The value of a specified option is retrieved by @code{getopt}.
   @item
   If @code{getopt()} is called with no argument, then it returns a list
   @code{[[key1,value1],} @code{[key2,value2],@dots{}]}.
   In the list, each @code{key}
   is an option which was specified when the function executing @code{getopt}
   was invoked, and @code{value} is the value of the option.
   @item
   If an option @var{key} is specified upon a function call, @code{getopt}
   return the value of the option. If such an option is not specified,
   the it returns an object of VOID type whose object identifier is
   -1. By examining the type of the returned value with @code{type()},
   one knows whether the option is set or not.
   @item
   Options are specified as follows:
   
   @example
   xxx(A,B,C,D|x=X,y=Y,z=Z)
   @end example
   
   That is, the options are specified by a sequence of @var{key=value} seperated
   by @samp{,}, after @samp{|}.
   \E
   @end itemize
   
   @table @t
   \JP @item $B;2>H(B
   \EG @item References
   \JP @fref{$B%*%W%7%g%s;XDj(B}, @fref{type}.
   \EG @fref{option}, @fref{type}.
   @end table
   
   \JP @node getenv,,, $B$=$NB>(B
   \EG @node getenv,,, Miscellaneouses
   @subsection @code{getenv}
   @findex getenv
   
   @table @t
   @item getenv(@var{name})
   \JP :: $B4D6-JQ?t$NCM$rJV$9(B.
   \EG :: Returns the value of an environment variable.
   @end table
   
   @table @var
   @item return
   @itemx name
   \JP $BJ8;zNs(B
   \EG string
   @end table
   
   @itemize @bullet
   @item
   \JP $B4D6-JQ?t(B @var{name} $B$NCM$rJV$9(B.
   \EG Returns the value of an environment variable @var{name}.
   @end itemize
   
   @example
   [0] getenv("HOME");
   /home/pcrf/noro
   @end example
   
   
   
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.20
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>