OpenXM/src/asir-doc/parts/builtin/misc.texi - view

Return to misc.texi CVS log

Up to [local] / OpenXM / src / asir-doc / parts / builtin

File: [local] / OpenXM / src / asir-doc / parts / builtin / misc.texi (download)

Revision 1.28, Thu Jun 6 04:33:11 2019 UTC (4 years, 11 months ago) by takayama
Branch: MAIN
CVS Tags: HEAD
Changes since 1.27: +3 -1 lines

no_debug_on_error is set for cfep and jupyter.

@comment $OpenXM: OpenXM/src/asir-doc/parts/builtin/misc.texi,v 1.28 2019/06/06 04:33:11 takayama Exp $
\BJP
@node $B$=$NB>(B,,, $BAH$_9~$_H!?t(B
@section $B$=$NB>(B
\E
\BEG
@node Miscellaneouses,,, Built-in Function
@section Miscellaneouses
\E

@menu
* ctrl::
* debug::
* error::
* help::
* time::
* cputime tstart tstop::
* timer::
* currenttime::
* sleep::
* heap::
* version::
* shell::
* map::
* flist::
* delete_history::
* get_rootdir::
* getopt::
* getenv::
@end menu

\JP @node ctrl,,, $B$=$NB>(B
\EG @node ctrl,,, Miscellaneouses
@subsection @code{ctrl}
@findex ctrl

@table @t
@item ctrl("@var{switch}"[,@var{obj}])
\JP :: $B4D6-@_Dj(B
\EG :: Sets the value of @var{switch}.
@item ctrl()
\JP :: $B4D6-$NI=<((B
\EG :: Show the values of @var{switch}'s.
@item ctrl(|desc=1)
\JP :: $B4D6-$*$h$S$=$NC;$$@bL@$NI=<((B
\EG :: Show the values of @var{swtich}'s and short descriptions
@end table

@table @var
@item return
\JP $B@_Dj$5$l$F$$$kCM(B
\EG value of @var{switch}
@item switch
\JP $B%9%$%C%AL>(B
\EG switch name
@item obj
\JP $B%Q%i%a%?(B
\EG parameter
@end table

@itemize @bullet
\BJP
@item
@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{obj} $B$,M?$($i$l$F$$$k$H$-(B, $B$=$NCM$r@_Dj$9$k(B.
@item
$B%9%$%C%A$OJ8;zNs$H$7$FF~NO$9$k(B. $B$9$J$o$A%@%V%k%/%)!<%H$G0O$`(B. 
@item
$B%9%$%C%A$O<!$NDL$j(B. 

@table @code
@item adj
$B%,!<%Y%C%8%3%l%/%7%g%s$NIQEY$NJQ99(B. 1 $B0J>e$NM-M}?t$,;XDj$G$-$k(B. 
$B%G%U%)%k%HCM$O(B 3. 1 $B$K6a$$Dx(B, $B%,!<%Y%C%8%3%l%/%7%g%s$;$:$K%R!<%W$r(B
$BBg$-$/$H$k$h$&$K$J$k(B. $B@0?tCM$O%3%^%s%I%i%$%s$G;XDj$G$-$k(B.
@xref{$B%3%^%s%I%i%$%s%*%W%7%g%s(B}.

@item allow_laurent
1 $B$N;~(B, $BC19`<0$N;X?t$KIi$N@0?t$r5v$9(B.

@item bigfloat
1 $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B @b{bigfloat} $B$KJQ49$5$l(B, $BIbF0>.?t1i;;$O(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. 
0 $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B, $BG\@:EYIbF0>.?t$KJQ49$5$l$k(B. 
@cindex PARI

@item cputime
1 $B$N;~(B CPU time $B$*$h$S(B GC time $B$rI=<((B, 0 $B$N;~I=<($7$J$$(B. @code{cputime()}
$B$r;2>H(B. 
@code{ctrl("cputime",@var{onoff})} $B$O(B @code{cputime(@var{onoff})} $B$HF1$8$G$"$k(B. 

@item debug_plot
1 $B$N;~(B, @code{ox_plot} $B$,%a%C%;!<%8%&%#%s%I%&$D$-$G5/F0$5$l$k(B.

@item debug_up
1$B$N;~(B, 1$BJQ?t@lMQB?9`<04D4X?t(B(@code{umul()}$B$J$I(B)$B<B9T;~$K%a%C%;!<%8$rI=<($9$k(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 diag_period
@code{nd_gr()}, @code{nd_gr_trace()} $B$r@F<!%$%G%"%k$KBP$7$F<B9T$9$k:](B, $BESCf$G<B9T$5$l$kCf4V4pDl4V$NAj8_4JLs(B
$B$NIQEY$r;XDj$9$k(B. $BCM$,(B @code{n} $B$J$i(B, $B?7$7$/4pDl$,(B @code{n}$B8D@8@.$5$l$k$?$S$KAj8_4JLs$,(B
$B<B9T$5$l$k(B.

@item double_output
1 $B$N;~(B, $BG\@:EYIbF0>.?t$O$D$M$K(B ddd.ddd $B$N7A$GI=<($5$l$k(B.

@item echo
1 $B$N;~$OI8=`F~NO$r7+$jJV$7$F=PNO$7(B, 0 $B$N;~$OI8=`F~NO$r7+$jJV$5$J$$(B.
@code{output} $B%3%^%s%I$rMQ$$$k:]$KM-8z$G$"$k(B.

@item evalef
0 $B$N;~(B eval $B$N0z?t$,I>2A$5$l$?$H$-$=$l0J>eI>2A$G$-$J$/$J$C$?>l9g(B, $BITDj85%j%9%H$K(B
$BEPO?$5$l$k(B. $B$?$H$($P(B eval(sin(0.1)) $B$H<B9T$9$k$H(B sin(0.1) $B$,$=$l0J>eI>2A$G$-$J$$$?$a(B
$BITDj85%j%9%H$KEPO?$5$l$k(B.
1 $B$N;~$O(B, $BEPO?$5$l$J$$(B.
$B=iEy4X?t$N?tCMI>2A$r7+$jJV$79T$&;~$O$3$N%*%W%7%g%s$r;HMQ$9$Y$-$G$"$k(B.
($B%G%U%)%k%HCM$O(B 0.)
@xref{ord}

@item error_in_timer
1 $B$N;~(B, $B%?%$%^!<=*N;;~$KDL>o$N%(%i!<=hM}$,<B9T$5$l$k(B.

@item f4_nocheck
1$B$N;~(B, @code{nd_f4}, @code{nd_f4_trace} $B$K$*$1$k9TNs$N4JLs$r(BCRT$B$G9T$&:]$K(B, $B7k2L$N(B
$B%A%'%C%/$r9T$o$J$$(B.

@item fake_ox_reset
@itemx no_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}.

@item fortran_output
1 $B$N;~(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 hex
1 $B$N;~(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. 

@item hideargs
1$B$N;~(B, $B4X?t8F$S=P$7$rI=<($9$k:]$K0z?t$,I=<($5$l$J$$(B.

@item loadpath
@code{ASIRLOADPATH} $B$r>e=q$-$9$k(B.

@item message
1 $B$N;~(B, @code{ox_asir}, @code{ox_plot} $B<B9T;~$K3+;O%a%C%;!<%8$rI=<($9$k(B.

@item new_hensel
1 $B$N;~(B, $BM-M}?tBN>e$N(B1$BJQ?tB?9`<0$N0x?tJ,2r$K$*$$$F(B, $B4X?t(B @code{hensel2()} $B$,MQ$$$i$l$k(B.

@item nez
EZGCD $B$N%"%k%4%j%:%`$N@ZBX$((B. $B%G%U%)%k%H$G(B 1 $B$G$"$j(B, $B$H$/$K@ZBX$($kI,MW(B
$B$O$J$$(B. 

@item no_debug_on_error
1 $B$N;~(B, $B%(%i!<;~$K%G%P%C%0%b!<%I$KF~$i$J$$(B.

@item no_prompt
1$B$N;~(B, $B%W%m%s%W%H$,I=<($5$l$J$$(B.

@item outputstyle
1 $B$N;~(B, $B9TNs(B, $B%Y%/%H%k$,(B @code{mat(...)}, @code{vect(...)} $B$N7A$GI=<($5$l$k(B.

@item ox_batch
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.)
@xref{$BJ,;67W;;(B}.

@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. 
0 $B$N$H$-$7$J$$(B. ($B%G%U%)%k%HCM$O(B 1.)
@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 plot_by_bigfloat
N $B$N$H$-(B, 10$B?J?t$G$N@:EY$r(B N $B7e$H$7$F(B, bigfloat $B$rMQ$$$F(B plot $B$r9T$&(B.
($B%G%U%)%k%H$G$O(B double $B$rMQ$$$F(B plot $B$r9T$&(B.)

@item print_quote
quote $B%G!<%?$NI=<(J}K!$r;XDj$9$k(B.
0 $B$N;~(B, quote $B%G!<%?$OC1$K(B @code{<...quoted...>}$B$HI=<($5$l$k(B. 1 $B$N;~(B, $B%j%9%H7A<0$GI=<($5$l$k(B.
2 $B$N;~(B, $B<+A3$J?t<0$N7A$GI=<($5$l$k(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 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 real_binary
1$B$N;~(B, $BG\@:EYIbF0>.?t$r(B2$B?JI=<($9$k(B.

@item real_digit
$BG\@:EYIbF0>.?t$NI=<($N7e?t$r;XDj$9$k(B.

@item show_crossref
1 $B$N;~(B, $B4X?tDj5A$rFI$_9~$`:]$K(B, $B%/%m%9%j%U%!%l%s%9$,I=<($5$l$k(B.

@item show_orderspec
1 $B$N;~(B, dp $B7O4X?t$K$h$k%0%l%V%J!<4pDl7W;;4X?t$KBP$9$kJ#9gE*$J9`=g=x$N;XDj;~$K(B
$B$=$N>\:Y$rI=<($9$k(B.

@item StrassenSize
Strassen-Winograd $B$K$h$k9TNs$N9bB.>h;;%"%k%4%j%:%`<B9T$K$*$1$k%Q%i%a%?$NCM$r@_Dj$9$k(B.

@item terse
1 $B$N;~(B, $B%f!<%6Dj5A(B callback $B<B9T;~$K%a%C%;!<%8$rI=<($7$J$$(B.

@item weight_check
1 $B$N;~(B, nd $B7O4X?t$K$h$k%0%l%V%J!<4pDl$K$*$$$F(B, $B;XDj$5$l$?(B weight $B$rMQ$$$?(Bweight $B$N(Boverflow $B%A%'%C%/$r9T$&(B.
@item verbose
1 $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k(B. 

@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{setbprec 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 no_debug_on_error
When 1, asir or ox_asir do not get into the debug mode.
@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}.
@item plot_by_bigfloat
If its value N is not equal to zero, then plotting is done by bigfloat.
(The double numbers are used as the default.)
@item evalef
When it is set to 0, the arguments of eval are registered to the list of
indeterminants when arguments are no longer to be simplified.
For example, when this flag is 0, sin(0.1) is registered to the list of 
indeterminants when eval(sin(0.1)) is evaluated.
When it is set to 1, arguments are numerically evaluated.
It is recommended to turn on this option, when you repeat to evaluate elementary functions numerically.
(The default value is 0.)
@xref{ord}
@end table
\E
@end itemize

@example
[1917] ctrl();
[[oxpari_start,0],[oxpari_id,-1],... snip ....,[plot_by_bigfloat,0],[debug_plot,0]]
[1918] map(print,ctrl(|desc=1));
[oxpari_start,0,oxpari starting function.]
[oxpari_id,-1,Id of ox_pari.]
... snip ...
[plot_by_bigfloat,0,If set to 1, computation is done by using MPFR bigfloat functions in ox_plot.]
[debug_plot,0,If set to 1, ox_plot is executed with the message window.]
@end example

@table @t
\JP @item $B;2>H(B
\EG @item References
@fref{cputime tstart tstop}, @fref{output},
@fref{pari}, @fref{setbprec setprec}, @fref{eval deval}.
@end table

@noindent
ChangeLog
@itemize @bullet
@item @xref{ChangeLog}
\BEG
@item plot_by_bigfloat switch is added on 2017.09.04. The following files are changed.
\E
\BJP
@item $B7g$1$F$$$?%9%$%C%A$N@bL@$rDI2C$7$?(B (2018.3.29).
@item plot_by_bigfloat $B%9%$%C%A$O(B 2017.09.04 $B$K2C$($i$l$?(B. $BJQ99$r<u$1$?%U%!%$%k$O2<5-$N$H$*$j(B.
\E
@item 1.54 ctrl.c,
  1.14 bf.c,
  1.75 tcpf.c,
  1.13 calc.c,
  1.36 if.c,
  1.25 ifplot.h,
  1.33 plotf.c
@end itemize

\JP @node debug,,, $B$=$NB>(B
\EG @node debug,,, Miscellaneouses
@subsection @code{debug}
@findex debug

@table @t
@item debug
\JP :: $B%G%P%C%0%b!<%I$KF~$k(B. 
\EG :: Forces to enter into debugging mode.
@end table

@itemize @bullet
\BJP
@item
@code{debug} $B$OL50z?t$NH!?t$G$"$k$,(B, @samp{()} $B$J$7$G8F$S=P$;$k(B. 
@item
$B%G%P%C%0%b!<%I$KF~$k$H%W%m%s%W%H$,(B @code{(debug)} $B$H$J$j(B, $B%3%^%s%I(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
$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

@example
[1] debug;
(debug) quit
0
[2] 
@end example

\JP @node error,,, $B$=$NB>(B
\EG @node error,,, Miscellaneouses
@subsection @code{error}
@findex error

@table @t
@item error(@var{message})
\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

@table @var
@item message
\JP $BJ8;zNs(B
\EG string
@end table

@itemize @bullet
\BJP
@item
$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
$B%G%P%C%0%b!<%I$KF~$k(B. @code{error()} $B$O(B, $B%f!<%6H!?t$NFbIt$G$3$N(B
$BF0:n$HF1MM$NF0:n$r9T$o$;$k$?$a$NH!?t$G$"$k(B. 
@item
$B0z?t$O(B, @code{error()} $B$,8F$S=P$5$l$k:]$KI=<($5$l$k%a%C%;!<%8$G(B, 
$BJ8;zNs$G$"$k(B. 
@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$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

@example
% cat mod3
def mod3(A) @{
        if ( type(A) >= 2 )
                error("invalid argument");
        else
                return A % 3;
@}
end$
% asir
[0] load("mod3");
1
[3] mod3(5);
2
[4] mod3(x);
invalid argument
stopped in mod3 at line 3 in file "./mod3"
3                       error("invalid argument");
(debug) print A
A = x
(debug) quit
return to toplevel
[4] 
@end example

@table @t
\JP @item $B;2>H(B
\EG @item References
@fref{debug}.
@end table

\JP @node help,,, $B$=$NB>(B
\EG @node help,,, Miscellaneouses
@subsection @code{help}
@findex help

@table @t
@item help(["@var{function}"])
\JP :: $BH!?t$N@bL@$rI=<($9$k(B. 
\EG :: Displays the description of function @var{function}.
@end table

@table @var
@item return
0
@item function
\JP $BH!?tL>(B
\EG function name
@end table

@itemize @bullet
\BJP
@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
$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$"$k$$$O(B @samp{more} $B$r8F$S=P$7$F$=$N%U%!%$%k$rI=<($9$k(B. 
@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, 
$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

\JP @node time,,, $B$=$NB>(B
\EG @node time,,, Miscellaneouses
@subsection @code{time}
@findex time

@table @t
@item time()
\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

@table @var
@item return 
\JP $B%j%9%H(B
\EG list
@end table

@itemize @bullet
\BJP
@item
CPU $B;~4V$*$h$S(B GC $B;~4V$NI=<($K4X$9$k%3%^%s%I$G$"$k(B. 
@item
GC $B;~4V$H$O(B, $B%,!<%Y%8%3%l%/%?$K$h$j>CHq$5$l$?$H8+$J$5$l$k;~4V(B, 
CPU $B;~4V$O(B, $BA4BN$N(B CPU $B;~4V$+$i(B GC $B;~4V$r0z$$$?;D$j$G(B, $BC10L$OIC$G$"$k(B. 
@item
@code{time()} $B$O0z?t$J$7$G(B, $B%;%C%7%g%s3+;O$+$i8=:_$^$G$N(B CPU $B;~4V(B, 
GC $B;~4V(B, $B8=:_$^$G$KMW5a$5$l$?%a%b%j$N$N$YMFNL(B, $B$*$h$S%;%C%7%g%s3+;O$+$i(B
$B8=:_$^$G$N7P2a;~4V$NI=<($r$9$k(B. 
$B$9$J$o$A(B, @code{[CPU $B;~4V(B ($BIC(B), GC $B;~4V(B ($BIC(B), $B%a%b%jNL(B ($B%o!<%I(B), $B7P2a;~4V(B ($BIC(B)]}
$B$J$k%j%9%H$rJV$9(B. 1 $B%o!<%I$ODL>o(B 4 $B%P%$%H$G$"$k(B. 
@item
$B7W;;$N<B9T3+;O;~(B, $B=*N;;~$N(B @code{time()} $B$+$i(B, $B$=$N7W;;$KBP$9$k(B
CPU $B;~4V(B, GC $B;~4V$,$o$+$k(B. 
@item
$B%a%b%jNL$OB?G\D9?t$G$O$J$$$?$a(B, $B$"$kCM$r1[$($k$HL50UL#$JCM$H$J$k$?$a(B
$B$"$/$^$G$bL\0B$H$7$FMQ$$$k$Y$-$G$"$k(B. 
@item
@code{ctrl()} $B$d(B @code{cputime()} $B$K$h$j(B @code{cputime} $B%9%$%C%A$,(B
on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l$D$NC10L$H$7$F(B, 
$B$=$N<B9T;~4V$,I=<($5$l$k(B. $B$7$+$7(B, $B%W%m%0%i%`$NFbIt$J$I$G(B, $BFCDj$N(B
$B7W;;$KBP$9$k7W;;;~4V$rCN$j$?$$;~$K$O(B, @code{time()} $B$J$I$r;H$&(B
$BI,MW$,$"$k(B. 
@item
@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$,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

@example
[72] T0=time();
[2.390885,0.484358,46560,9.157768]
[73] G=hgr(katsura(4),[u4,u3,u2,u1,u0],2)$
[74] T1=time();
[8.968048,7.705907,1514833,63.359717]
[75] ["CPU",T1[0]-T0[0],"GC",T1[1]-T0[1]]; 
[CPU,6.577163,GC,7.221549]
@end example

@table @t
\JP @item $B;2>H(B
\EG @item References
@fref{cputime tstart tstop}, @fref{currenttime}.
@end table

\JP @node cputime tstart tstop,,, $B$=$NB>(B
\EG @node cputime tstart tstop,,, Miscellaneouses
@subsection @code{cputime}, @code{tstart}, @code{tstop}
@findex cputime
@findex tstart
@findex tstop

@table @t
@item cputime(@var{onoff})
\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()
\JP :: CPU time $B7WB,3+;O(B. 
\EG :: Resets and starts timer for CPU time and GC time.
@item tstop()
\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

@table @var
@item return 
0
@item onoff
\JP $B%U%i%0(B ($BG$0U(B)
\EG flag (arbitrary)
@end table

@itemize @bullet
\BJP
@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. 
@item
@code{tsart} $B$O0z?t$J$7(B, @samp{()} $B$J$7$G(B, CPU time $B7WB,$r3+;O$9$k(B. 
@item
@code{tstop} $B$O0z?t$J$7(B, @samp{()} $B$J$7$G(B, CPU time $B7WB,$r=*N;(B, 
$B$*$h$SI=<($9$k(B. 
@item
@code{cputime(@var{onoff})} $B$O(B @code{ctrl("cputime",@var{onoff})} $B$HF1$8$G$"$k(B.
@item
@code{tstart}, @code{tstop} $B$O(B, $BF~$l;R$K$7$F;H$o$l$k$3$H$OA[Dj$7$F$$$J$$(B
$B$?$a(B, $B$=$N$h$&$J2DG=@-$,$"$k>l9g$K$O(B, @code{time()} $B$K$h$k7WB,$r9T$&(B
$BI,MW$,$"$k(B.  
@item
@code{cputime()} $B$K$h$k(B on, off $B$O(B, $BC1$KI=<($N(B on, off $B$G$"$j(B, $B%H%C%W%l%Y%k(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
$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

@example
[49] tstart$
[50] fctr(x^10-y^10);
[[1,1],[x+y,1],[x^4-y*x^3+y^2*x^2-y^3*x+y^4,1],[x-y,1],
[x^4+y*x^3+y^2*x^2+y^3*x+y^4,1]]
[51] tstop$
80msec + gc : 40msec
@end example

@table @t
\JP @item $B;2>H(B
\EG @item References
@fref{time}, @fref{currenttime}, @fref{ctrl}.
@end table

\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}
@findex heap

@table @t
@item heap()
\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

@table @var
@item return 
\JP $B<+A3?t(B
\EG non-negative integer
@end table

@itemize @bullet
\BJP
@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
$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%3%l%/%?$K$h$j4IM}$5$l$F$$$k(B. $B%W%m%0%i%`$NF0:nCf$O(B, $B%R!<%W$NBg$-$5$O(B
$BC1D4Hs8:>/$G$"$j(B, $B<B%a%b%j$NNL$r$3$($FBg$-$/$J$C$?>l9g$K$O(B, OS $B$K$h$k(B
$B%9%o%C%W%(%j%"$X$NFI$_=q$-$,$[$H$s$I$N7W;;;~4V$r@j$a$k$3$H$K$J$k(B. 
@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, 
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

@example
% asir -adj 16  
[0] load("fctrdata")$
0
[97] cputime(1)$
0msec
[98] heap();
524288
0msec
[99] fctr(Wang[8])$
3.190sec + gc : 3.420sec
[100] heap();
1118208
0msec
[101] quit;
% asir
[0] load("fctrdata")$   
0
[97] cputime(1)$   
0msec
[98] heap();    
827392
0msec
[99] fctr(Wang[8])$
3.000sec + gc : 1.180sec
[100] heap();       
1626112
0msec
[101] quit;
@end example

@table @t
\JP @item $B;2>H(B
\EG @item References
\JP @fref{$B%3%^%s%I%i%$%s%*%W%7%g%s(B}.
\EG @fref{Command line options}.
@end table

\JP @node version,,, $B$=$NB>(B
\EG @node version,,, Miscellaneouses
@subsection @code{version}
@findex version

@table @t
@item version()
\JP :: @b{Asir} $B$N%P!<%8%g%s$rJV$9(B. 
\EG :: Version identification number of  @b{Asir}.
@end table

@table @var
@item return 
\JP $B<+A3?t(B
\EG integer  
@end table

@itemize @bullet
\BJP
@item
@b{Asir} $B$N%P!<%8%g%s$r<+A3?t$GJV$9(B.
\E
\BEG
@item
Command @code{version()} returns the version identification number, 
an integer of @b{Asir} in use.
\E
@end itemize

@example
[0] version();
991214
@end example

\JP @node shell,,, $B$=$NB>(B
\EG @node shell,,, Miscellaneouses
@subsection @code{shell}
@findex shell

@table @t
@item shell(@var{command})
\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

@table @var
@item return 
\JP $B<+A3?t(B
\EG integer
@item command
\JP $BJ8;zNs(B
\EG string
@end table

@itemize @bullet
\BJP
@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. 
$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

@example
[0] shell("ls");
alg           da            katsura       ralg          suit
algt          defs.h        kimura        ratint        test
alpi          edet          kimura3       robot         texput.log
asir.o        fee           mfee          sasa          wang
asir_symtab   gr            mksym         shira         wang_data
base          gr.h          mp            snf1          wt
bgk           help          msubst        solve
chou          hom           p             sp
const         ifplot        proot         strum
cyclic        is            r             sugar
0
[1] 
@end example

\JP @node map,,, $B$=$NB>(B
\EG @node map,,, Miscellaneouses
@subsection @code{map}
@findex map

@table @t
@item map(@var{function},@var{arg0},@var{arg1},...)
\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

@table @var
@item return
\JP @var{arg0} $B$HF1$87?$N%*%V%8%'%/%H(B
\EG an object of the same type as @var{arg0}.
@item function
\JP $BH!?tL>(B
\EG the name of a function
@item arg0
\JP $B%j%9%H(B, $B%Y%/%H%k(B, $B9TNs(B
\EG list, vector or matrix
@item arg1  ...
\JP $BG$0U(B ($B;D$j$N0z?t(B)
\EG arbitrary (the rest of arguments)
@end table

@itemize @bullet
\BJP
@item
@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!?t8F$S=P$7$N7k2L$,F~$C$?F1$87?$N%*%V%8%'%/%H$r@8@.$7$FJV$9(B. 
@item
@var{function} $B$O(B, $B%@%V%k%/%)!<%H$N$J$$H!?tL>$rMQ$$$k(B. 
@item
@var{function} $B$K%W%m%0%i%`JQ?t$O;H$($J$$(B. 
@item
@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
$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

@example
[82] def afo(X) @{ return X^3; @}
[83] map(afo,[1,2,3]);
[1,8,27]
@end example

\JP @node flist,,, $B$=$NB>(B
\EG @node flist,,, Miscellaneouses      
@subsection @code{flist}
@findex flist

@table @t
@item flist([mname])
\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.
@item mname
\JP $B%b%8%e!<%kL>(B
\EG a module name
@end table

@table @var
@item return
\JP $BJ8;zNs$N%j%9%H(B
\EG list of character strings
@end table

@itemize @bullet
\BJP
@item
$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%b%8%e!<%kL>$,;XDj$5$l$?>l9g(B, $B$=$N%b%8%e!<%k$GDj5A$5$l$F$$$k(B
$B4X?tL>$N$_$rJV$9(B.
@item
$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.
If a module name is specified, only the names of functions defined in the module
are returned.
@item 
The names of built-in functions are followed by those of user defined
functions.
\E
@end itemize

@example
[77] flist();
[defpoly,newalg,mainalg,algtorat,rattoalg,getalg,alg,algv,...]
@end example

\JP @node delete_history,,, $B$=$NB>(B
\EG @node delete_history,,, Miscellaneouses
@subsection @code{delete_history}
@findex delete_history

@table @t
@item delete_history([@var{index}])
\JP :: $B%R%9%H%j$r>C5n$9$k(B. 
\EG :: Deletes the history.
@end table

@table @var
@item return
0
@item index
\JP $B>C5n$7$?$$%R%9%H%j$NHV9f(B
\EG Index of history to be deleted.
@end table

@itemize @bullet
\BJP
@item
$B0z?t$,$J$$$H$-(B, $B$3$l$^$G7W;;$7$?%R%9%H%j$rA4$F>C5n$9$k(B. 
@item
$B0z?t$,$"$k$H$-(B, $B$=$NHV9f$N7k2L$N$_>C5n$9$k(B. 
@item
$B$3$3$G%R%9%H%j$H$O(B, $BHV9f$D$-$N%W%m%s%W%H$KBP$7$F$NF~NO$rI>2A$7$FF@$i$l$?<0(B
$B$G(B, $B$3$N<0$O(B @code{@@@var{number}} $B$K$h$j<h$j=P$9$3$H$,$G$-$k(B. $B$3$N$3$H$O(B, 
$B%,!<%Y%C%8%3%l%/%7%g%s$N:]$K$b$3$N<0$,@8$-;D$k$3$H$r0UL#$9$k(B. 
@item
$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$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

@example
[0] (x+y+z)^100$
[1] @@0;
...
[2] delete_history(0);
[3] @@0;
0
@end example

\JP @node get_rootdir,,, $B$=$NB>(B
\EG @node get_rootdir,,, Miscellaneouses
@subsection @code{get_rootdir}
@findex get_rootdir

@table @t
@item get_rootdir()
\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

@table @var
@item return
\JP $BJ8;zNs(B
\EG string
@end table

@itemize @bullet
\BJP
@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
$B$K$O(B @samp{/usr/local/lib/asir} $B$rJV$9(B. 
@item
Windows $BHG$N>l9g(B, @samp{asirgui.exe} $B$N$"$k%G%#%l%/%H%j(B (@samp{bin} $B$H$$$&L>A0$N$O$:$G$"$k(B)
$B$N?F%G%#%l%/%H%j$,JV$5$l$k(B. 
@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$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


\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