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

Return to misc.texi CVS log

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

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

version 1.2, 1999/12/10 06:58:50

version 1.14, 2003/10/19 04:57:00

Line 1

@comment $OpenXM: OpenXM/src/asir-doc/parts/builtin/misc.texi,v 1.13 2003/08/22 00:44:57 noro Exp $

\BJP

@node $B$=$NB>(B,,, $BAH$_9~$_H!?t(B

@section $B$=$NB>(B

\BEG

@node Miscellaneouses,,, Built-in Function

@section Miscellaneouses

@menu

* ctrl::

Line 8

Line 15

* help::

* time::

* cputime tstart tstop::

* timer::

* heap::

* version::

* shell::

Line 16

Line 24

* 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$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.

Line 44

Line 59

@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.

$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

@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()}

Line 58 on $B$N;~$OI8=`F~NO$r7+$jJV$7$F=PNO$7(B, off $B$N;~

Line 73 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.

@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

@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

Line 69 off $B$N;~(B, $BF~NO$5$l$?IbF0>.?t$O(B, $BG\@:EYI

Line 84 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.

@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!<%?$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}

@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}.

@end table

\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 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}.

@end table

@end itemize

@table @t

@item $B;2>H(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

Line 106 on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k

Line 214 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.

@item

$B%G%P%C%0%b!<%I$K$D$$$F$N>\:Y$O(B @xref{$B%G%P%C%,(B}.

\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.

@end itemize

@example

Line 115 on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k

Line 235 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

Line 141 on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k

Line 265 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.

\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.

@end itemize

@example

Line 169 return to toplevel

Line 310 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

@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.

\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.

@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.

@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

Line 242 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 420 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.

\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.

@end itemize

@example

Line 255 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 473 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

\JP @item $B;2>H(B

\EG @item References

@fref{cputime tstart tstop}.

@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

Line 267 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 487 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.

@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.

@end table

@table @var

@item return

@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

Line 300 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 532 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$r<B9T$5$;$l$P7W;;;~4V$O(B

$BI=<($5$l$k(B.

\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)}.

@end itemize

@example

Line 312 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 570 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

\JP @item $B;2>H(B

\EG @item References

@fref{time}, @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;;$r<B9T$9$k(B.

\BEG

:: 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.

\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.

@end itemize

@example

[0] load("cyclic");

[10] timer(10,dp_gr_main(cyclic(7),[c0,c1,c2,c3,c4,c5,c6],1,1,0),0);

interval timer expired (VTALRM)

[11]

@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

Line 340 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 668 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

@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.

\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}.)

@end itemize

@example

Line 374 GC $B<gBN$N@_Dj$r9T$C$F$*$/I,MW$,$"$k(B.

Line 719 GC $B<gBN$N@_Dj$r9T$C$F$*$/I,MW$,$"$k(B.

@end example

@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

@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{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.

\BEG

Command @code{version()} returns the version identification number

, an integer of @b{Asir} in use.

@end itemize

@example

[0] version();

990831

991214

@end example

@node shell,,, $B$=$NB>(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<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

@table @var

@item return

$B<+A3?t(B

\JP $B<+A3?t(B

\EG integer

@item command

$BJ8;zNs(B

\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.

\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.

@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

[1]

@end example

@node map,,, $B$=$NB>(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

\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

@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

Line 474 cyclic is r sugar

Line 847 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.

\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{}).

@end itemize

@example

Line 482 cyclic is r sugar

Line 871 cyclic is r sugar

[1,8,27]

@end example

@node flist,,, $B$=$NB>(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.

\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.

@end itemize

@example

Line 509 cyclic is r sugar

Line 911 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

@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

Line 538 cyclic is r sugar

Line 944 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.

\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.

@end itemize

@example

Line 549 cyclic is r sugar

Line 970 cyclic is r sugar

@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<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

@table @var

@item return

$BJ8;zNs(B

\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.

Line 573 Windows $BHG$N>l9g(B, @samp{asirgui.exe} $B$N$"$k%G

Line 998 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.

\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.

@end itemize

@node getopt,,, $B$=$NB>(B

\JP @node getopt,,, $B$=$NB>(B

\EG @node getopt,,, Miscellaneouses

@subsection @code{getopt}

@findex getopt

@table @t

@item getopt(@var{key})

@item getopt([@var{key}])

:: $B%*%W%7%g%s$NCM$rJV$9(B.

\JP :: $B%*%W%7%g%s$NCM$rJV$9(B.

\EG :: Returns the value of an option.

@end table

@table @var

@item return

$BG$0U(B

\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()}

Line 610 xxx(A,B,C,D|x=X,y=Y,z=Z)

Line 1056 xxx(A,B,C,D|x=X,y=Y,z=Z)

$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.

\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{|}.

@end itemize

@table @t

@item $B;2>H(B

\JP @item $B;2>H(B

@fref{$B%*%W%7%g%s;XDj(B}, @fref{type}.

\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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>