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.1.1.1 and 1.3

version 1.1.1.1, 1999/12/08 05:47:44

version 1.3, 1999/12/21 02:47:33

Line 1

@comment $OpenXM$

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

Line 22

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

Line 58

@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 80 on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k

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

0 $B$N$H$-$7$J$$(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 hex

If 1 is set, integers are displayed as hexadecimal numbers with prefix

@code{0x}. if -1 is set, hexadecimal numbers are desplayed with

@samp{|} inserted at every 8 hexadecimal digits.

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

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

@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 105 on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k

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

@xref{Debugger} for details.

@end itemize

@example

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

Line 206 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 140 on $B$N;~(B, $BH!?t$N:FDj5A;~$K%a%C%;!<%8$rI=<($9$k

Line 236 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 168 return to toplevel

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

Line 197 return to toplevel

Line 315 return to toplevel

@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

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 241 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 380 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 254 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 433 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 266 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 447 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 299 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 492 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 311 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 530 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 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 339 on $B$K$J$C$F$$$k>l9g$K$O(B, $B%H%C%W%l%Y%k$NJ8$r0l

Line 563 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 373 GC $B<gBN$N@_Dj$r9T$C$F$*$/I,MW$,$"$k(B.

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

Line 440 cyclic is r sugar

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

\EG list, vector or matrix

@item arg1, ...

$BG$0U(B ($B;D$j$N0z?t(B)

\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 473 cyclic is r sugar

Line 742 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 481 cyclic is r sugar

Line 766 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 508 cyclic is r sugar

Line 806 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 537 cyclic is r sugar

Line 839 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 548 cyclic is r sugar

Line 865 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 572 Windows $BHG$N>l9g(B, @samp{asirgui.exe} $B$N$"$k%G

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

\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

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

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

\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

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