=================================================================== RCS file: /home/cvs/OpenXM/src/asir-doc/parts/builtin/misc.texi,v retrieving revision 1.1.1.1 retrieving revision 1.18 diff -u -p -r1.1.1.1 -r1.18 --- OpenXM/src/asir-doc/parts/builtin/misc.texi 1999/12/08 05:47:44 1.1.1.1 +++ OpenXM/src/asir-doc/parts/builtin/misc.texi 2003/12/21 17:36:29 1.18 @@ -1,5 +1,12 @@ +@comment $OpenXM: OpenXM/src/asir-doc/parts/builtin/misc.texi,v 1.17 2003/12/18 10:26:20 ohara 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:: @@ -8,6 +15,9 @@ * help:: * time:: * cputime tstart tstop:: +* timer:: +* currenttime:: +* sleep:: * heap:: * version:: * shell:: @@ -15,27 +25,35 @@ * flist:: * delete_history:: * get_rootdir:: +* getopt:: +* getenv:: @end menu -@node ctrl,,, $B$=$NB>(B +\JP @node ctrl,,, $B$=$NB>(B +\EG @node ctrl,,, Miscellaneouses @subsection @code{ctrl} @findex ctrl @table @t @item ctrl("@var{switch}"[,@var{obj}]) -:: $B4D6-@_Dj(B +\JP :: $B4D6-@_Dj(B +\EG :: Sets the value of @var{switch}. @end table @table @var @item return -$B@_Dj$5$l$F$$$kCM(B +\JP $B@_Dj$5$l$F$$$kCM(B +\EG value of @var{switch} @item switch -$B%9%$%C%AL>(B +\JP $B%9%$%C%AL>(B +\EG switch name @item obj -$B%Q%i%a%?(B +\JP $B%Q%i%a%?(B +\EG parameter @end table @itemize @bullet +\BJP @item @b{Asir} $B$NH$r9T$&(B. @item @var{switch} $B$N$_$N>l9g(B, $B$=$N%9%$%C%A$N8=:_$N>uBV$rJV$9(B. @@ -43,7 +61,7 @@ @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.?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. off $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B, $BG\@:EYIbF0>.?t$KJQ49$5$l$k(B. @cindex PARI @@ -68,36 +86,142 @@ 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}. @item verbose 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 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. +@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 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} +@xref{$BJ,;67W;;(B}. @item ox_check 1 $B$N$H$-(B, $BAw?.%G!<%?$rAjH(B +\JP @item $B;2>H(B +\EG @item References @fref{cputime tstart tstop}, @fref{output}, -@fref{pari}, @fref{setprec}, @fref{eval}. +@fref{pari}, @fref{setprec}, @fref{eval deval}. @end table -@node debug,,, $B$=$NB>(B +\JP @node debug,,, $B$=$NB>(B +\EG @node debug,,, Miscellaneouses @subsection @code{debug} @findex debug @table @t @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 @itemize @bullet +\BJP @item @code{debug} $B$OL50z?t$NH!?t$G$"$k$,(B, @samp{()} $B$J$7$G8F$S=P$;$k(B. @item @@ -105,6 +229,18 @@ on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k $BuBV$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 @@ -114,21 +250,25 @@ on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k [2] @end example -@node error,,, $B$=$NB>(B +\JP @node error,,, $B$=$NB>(B +\EG @node error,,, Miscellaneouses @subsection @code{error} @findex error @table @t @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 @table @var @item message -$BJ8;zNs(B +\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 @@ -140,6 +280,23 @@ on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k @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 @@ -168,52 +325,89 @@ return to toplevel @end example @table @t -@item $B;2>H(B +\JP @item $B;2>H(B +\EG @item References @fref{debug}. @end table -@node help,,, $B$=$NB>(B +\JP @node help,,, $B$=$NB>(B +\EG @node help,,, Miscellaneouses @subsection @code{help} @findex help @table @t @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 @table @var @item return 0 @item function -$BH!?tL>(B +\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-jp} +$B$K$"$k%U%!%$%k$,I=<($5$l$k(B. $B$=$&$G$J$$>l9g(B, @samp{help-eg} +$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-jp} is displayed. If its value does not begin with +@code{"japan"} or @code{"ja_JP"}, then the file in @samp{help-eg} +is displayed. +@item +On Windows HTML-style help is available from the menu. +\E @end itemize -@node time,,, $B$=$NB>(B +\JP @node time,,, $B$=$NB>(B +\EG @node time,,, Miscellaneouses @subsection @code{time} @findex time @table @t @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 @table @var @item return -$B%j%9%H(B +\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 @@ -241,6 +435,46 @@ 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 $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 @@ -254,11 +488,13 @@ on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l @end example @table @t -@item $B;2>H(B -@fref{cputime tstart tstop}. +\JP @item $B;2>H(B +\EG @item References +@fref{cputime tstart tstop}, @fref{currenttime}. @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} @findex cputime @findex tstart @@ -266,21 +502,33 @@ on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l @table @t @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() -:: 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() -:: 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 @table @var @item return 0 @item onoff -$B%U%i%0(B ($BG$0U(B) +\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 @@ -299,6 +547,32 @@ 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, $B7W;;=*N;A0$K%G%P%C%,$KF~$C$F(B @code{cputime(1)} $B$rl9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l @end example @table @t -@item $B;2>H(B -@fref{time}, @fref{ctrl}. +\JP @item $B;2>H(B +\EG @item References +@fref{time}, @fref{currenttime}, @fref{ctrl}. @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;;$rl9g$=$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$rl9g(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$Nl9g(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() -:: $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 @table @var @item return -$B<+A3?t(B +\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 @@ -339,6 +746,23 @@ on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l @item $B/$J$$>l9g$K$O(B, $B5/F0;~$N(B @code{-adj} $B%*%W%7%g%s$K$h$j(B, GC $BH(B -@fref{$B%3%^%s%I%i%$%s%*%W%7%g%s(B}. +\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 -@node version,,, $B$=$NB>(B +\JP @node version,,, $B$=$NB>(B +\EG @node version,,, Miscellaneouses @subsection @code{version} @findex version @table @t @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 @table @var @item return -$B<+A3?t(B +\JP $B<+A3?t(B +\EG integer @end table @itemize @bullet +\BJP @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@>Nq$N2<(B 2 $B7e(B, $B(B +\JP @node shell,,, $B$=$NB>(B +\EG @node shell,,, Miscellaneouses @subsection @code{shell} @findex shell @table @t @item shell(@var{command}) -:: @var{command} $B$r%7%'%k%3%^%s%I$H$7$F(B +\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},...) -:: $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 @table @var @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 -$BH!?tL>(B +\JP $BH!?tL>(B +\EG the name of a function @item arg0 -$B%j%9%H(B, $B%Y%/%H%k(B, $B9TNs(B -@item arg1, ... -$BG$0U(B ($B;D$j$N0z?t(B) +\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 @@ -473,6 +926,28 @@ 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{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(B +\JP @node flist,,, $B$=$NB>(B +\EG @node flist,,, Miscellaneouses @subsection @code{flist} @findex flist @table @t @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 @table @var @item return -$BJ8;zNs$N%j%9%H(B +\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. @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. +@item +The names of built-in functions are followed by those of user defined +functions. +\E @end itemize @example @@ -508,23 +996,27 @@ cyclic is r sugar [defpoly,newalg,mainalg,algtorat,rattoalg,getalg,alg,algv,...] @end example -@node delete_history,,, $B$=$NB>(B +\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}]) -:: $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 @table @var @item return 0 @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 @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 @@ -537,6 +1029,21 @@ 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 $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 @@ -548,21 +1055,25 @@ cyclic is r sugar 0 @end example -@node get_rootdir,,, $B$=$NB>(B +\JP @node get_rootdir,,, $B$=$NB>(B +\EG @node get_rootdir,,, Miscellaneouses @subsection @code{get_rootdir} @findex get_rootdir @table @t @item get_rootdir() -:: Asir $B$N%k!<%H%G%#%l%/%H%jL>$r$rl9g(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. @@ -572,7 +1083,131 @@ Windows $BHG$N>l9g(B, @samp{asirgui.exe} $B$N$"$k%G @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$rl9g(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