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

Diff for /OpenXM/src/asir-doc/parts/asir.texi between version 1.1 and 1.20

version 1.1, 1999/12/08 05:47:44 version 1.20, 2020/09/08 09:16:57
Line 1 
Line 1 
   @comment $OpenXM: OpenXM/src/asir-doc/parts/asir.texi,v 1.19 2014/03/11 01:46:19 takayama Exp $
   \BJP
 @node $B%f!<%68@8l(B Asir,,, Top  @node $B%f!<%68@8l(B Asir,,, Top
 @chapter $B%f!<%68@8l(B Asir  @chapter $B%f!<%68@8l(B Asir
   \E
   \BEG
   @node User language Asir,,, Top
   @chapter User language @b{Asir}
   \E
   
 @noindent  @noindent
   \BJP
 @b{Asir} $B$NAH$_9~$_H!?t$O(B, $B0x?tJ,2r(B, GCD $B$J$I$N7W;;$r9T$&$b$N(B, $B%U%!(B  @b{Asir} $B$NAH$_9~$_H!?t$O(B, $B0x?tJ,2r(B, GCD $B$J$I$N7W;;$r9T$&$b$N(B, $B%U%!(B
 $B%$%kF~=PNO$r9T$&$b$N(B, $B$"$k$$$O?t<0$N0lIt$r<h$j=P$9$b$N$J$I$5$^$6$^$J$b$N(B  $B%$%kF~=PNO$r9T$&$b$N(B, $B$"$k$$$O?t<0$N0lIt$r<h$j=P$9$b$N$J$I$5$^$6$^$J$b$N(B
 $B$,MQ0U$5$l$F$$$k$,(B, $B%f!<%6$,<B:]$K9T$$$?$$$3$H$r<B9T$5$;$k$?$a$K$O0l(B  $B$,MQ0U$5$l$F$$$k$,(B, $B%f!<%6$,<B:]$K9T$$$?$$$3$H$r<B9T$5$;$k$?$a$K$O0l(B
 $BHL$K$O%f!<%68@8l$K$h$k%W%m%0%i%`$r=q$/I,MW$,$"$k(B. $B%f!<%68@8l$b(B  $BHL$K$O%f!<%68@8l$K$h$k%W%m%0%i%`$r=q$/I,MW$,$"$k(B. $B%f!<%68@8l$b(B
 @b{Asir} $B$H8F$P$l$k(B. $B0J2<$G$O(B, $B%f!<%68@8l$NJ8K!5,B'$*$h$S<B:]$N%f!<(B  @b{Asir} $B$H8F$P$l$k(B. $B0J2<$G$O(B, $B%f!<%68@8l$NJ8K!5,B'$*$h$S<B:]$N%f!<(B
 $B%68@8l%W%m%0%i%`$rNc$H$7$?%W%m%0%i%`$N=q$-J}$K$D$$$F=R$Y$k(B.  $B%68@8l%W%m%0%i%`$rNc$H$7$?%W%m%0%i%`$N=q$-J}$K$D$$$F=R$Y$k(B.
   \E
   \BEG
   @b{Asir} provides many built-in functions, which perform algebraic
   computations, e.g., factorization and GCD computation, file I/O,
   extract a part of an algebraic expression, etc.
   In practice, you will often encounter a specific problem for which
   @b{Asir} does not provide a direct solution.  For such cases, you have
   to write a program in a certain user language.  The user language for
   @b{Asir} is also called @b{Asir}.  In the following, we describe the
   Syntax and then show how to write a user program by several examples.
   \E
   
 @menu  @menu
   \BJP
 * $BJ8K!(B (C $B8@8l$H$N0c$$(B)::  * $BJ8K!(B (C $B8@8l$H$N0c$$(B)::
 * $B%f!<%6Dj5AH!?t$N=q$-J}(B::  * $B%f!<%6Dj5AH!?t$N=q$-J}(B::
   \E
   \BEG
   * Syntax (Difference from C language)::
   * Writing user defined functions::
   \E
 @end menu  @end menu
   
   
   \BJP
 @node $BJ8K!(B (C $B8@8l$H$N0c$$(B),,, $B%f!<%68@8l(B Asir  @node $BJ8K!(B (C $B8@8l$H$N0c$$(B),,, $B%f!<%68@8l(B Asir
 @section $BJ8K!(B (C $B8@8l$H$N0c$$(B)  @section $BJ8K!(B (C $B8@8l$H$N0c$$(B)
   \E
   \BEG
   @node Syntax (Difference from C language),,, User language Asir
   @section Syntax --- Difference from C language
   \E
   
 @noindent  @noindent
   \BJP
 @b{Asir} $B$NJ8K!$O(B C $B8@8l$K=`5r$7$F$$$k(B.  @b{Asir} $B$NJ8K!$O(B C $B8@8l$K=`5r$7$F$$$k(B.
 $B$*$b$JAj0cE@$O<!$NDL$j$G$"$k(B. $B0J2<$G(B, $BJQ?t$H$O(B @b{Asir} $B$K$*$1$k(B  $B$*$b$JAj0cE@$O<!$NDL$j$G$"$k(B. $B0J2<$G(B, $BJQ?t$H$O(B @b{Asir} $B$K$*$1$k(B
 $B%W%m%0%i%`MQ$NJQ?t(B, $B$9$J$o$ABgJ8;z$G;O$^$kJ8;zNs$r0UL#$9$k$3$H$H$9$k(B.  $B%W%m%0%i%`MQ$NJQ?t(B, $B$9$J$o$ABgJ8;z$G;O$^$kJ8;zNs$r0UL#$9$k$3$H$H$9$k(B.
   \E
   \BEG
   The syntax of @b{Asir} is based on C language.
   Main differences are as follows.
   In this section, a variable does not mean an indeterminate, but
   a program variable which is written by a string which begins with a
   capital alphabetical letter in @b{Asir}.
   \E
   
 @itemize @bullet  @itemize @bullet
 @item  @item
 $BJQ?t$N7?$,$J$$(B.  \JP $BJQ?t$N7?$,$J$$(B.
   \EG No types for variables.
   @*
   \BJP
 $B4{$K@bL@$7$?$H$*$j(B, @b{Asir} $B$G07$o$l$kBP>]<+?H$OA4$F2?$i$+$N7?(B  $B4{$K@bL@$7$?$H$*$j(B, @b{Asir} $B$G07$o$l$kBP>]<+?H$OA4$F2?$i$+$N7?(B
 $B$r;}$C$F$$$k(B. $B$7$+$7(B, $B%W%m%0%i%`JQ?t<+BN$O(B, $B$I$N$h$&$JBP>]$G$b(B  $B$r;}$C$F$$$k(B. $B$7$+$7(B, $B%W%m%0%i%`JQ?t<+BN$O(B, $B$I$N$h$&$JBP>]$G$b(B
 $BBeF~$G$-$k$H$$$&0UL#$G7?$,$J$$$N$G$"$k(B.  $BBeF~$G$-$k$H$$$&0UL#$G7?$,$J$$$N$G$"$k(B.
   \E
   \BEG
   As is already mentioned, any object in @b{Asir} has their respective
   types.  A program variable, however, is type-less, that is, any typed
   object can be assigned to it.
   \E
   
 @example  @example
 [0] A = 1;  [0] A = 1;
Line 43 
Line 91 
 @end example  @end example
   
 @item  @item
   \BJP
 $BH!?tFb$NJQ?t$O(B, $B%G%U%)%k%H$G$O2>0z?t$r$3$a$F$9$Y$F6I=jJQ?t(B.  $BH!?tFb$NJQ?t$O(B, $B%G%U%)%k%H$G$O2>0z?t$r$3$a$F$9$Y$F6I=jJQ?t(B.
   @*
 $B$?$@$7(B, @code{extern} $B@k8@$5$l$?JQ?t$O(B, $B%H%C%W%l%Y%k$K$*$1$kBg0hJQ?t$H$J$k(B.  $B$?$@$7(B, @code{extern} $B@k8@$5$l$?JQ?t$O(B, $B%H%C%W%l%Y%k$K$*$1$kBg0hJQ?t$H$J$k(B.
   
 $B$9$J$o$A(B, $BJQ?t$N%9%3!<%W$OBg0hJQ?t$H6I=jJQ?t$N(B 2 $B<oN`$KC1=c2=$5$l$F$$$k(B.  $B$9$J$o$A(B, $BJQ?t$N%9%3!<%W$OBg0hJQ?t$H6I=jJQ?t$N(B 2 $B<oN`$KC1=c2=$5$l$F$$$k(B.
 $B%H%C%W%l%Y%k(B, $B$9$J$o$A%W%m%s%W%H$KBP$7$FF~NO$5$l$?JQ?t$OA4$FBg0hJQ?t(B  $B%H%C%W%l%Y%k(B, $B$9$J$o$A%W%m%s%W%H$KBP$7$FF~NO$5$l$?JQ?t$OA4$FBg0hJQ?t(B
 $B$H$7$FEPO?$5$l$k(B. $B$^$?H!?tFb$G$O<!$N$$$:$l$+$H$J$k(B.  $B$H$7$FEPO?$5$l$k(B. $B$^$?H!?tFb$G$O<!$N$$$:$l$+$H$J$k(B.
   \E
   \BEG
   Variables, together with formal parameters, in a function (procedure)
   are all local to the function by default.
   @*
   Variables can be global at the top level,
   if they are declared with the key word @code{extern}.
   Thus, the scope rule of @b{Asir} is very simple.
   There are only two types of variables: global variables and local
   variables.
   A name that is input to the @b{Asir}'s prompt at the top level
   is denotes a global variable commonly accessed at the top level.
   In a function (procedure) the following rules are applied.
   \E
   
 @enumerate  @enumerate
 @item  @item
   \BJP
 $BH!?t$,Dj5A$5$l$k%U%!%$%k$K$*$$$F(B, $B$=$NH!?tDj5A0JA0$K(B, $B$"$k(B  $BH!?t$,Dj5A$5$l$k%U%!%$%k$K$*$$$F(B, $B$=$NH!?tDj5A0JA0$K(B, $B$"$k(B
 $BJQ?t$,(B @code{extern} $B@k8@$5$l$F$$$k>l9g(B, $BH!?tFb$N$=$NJQ?t$bBg0hJQ?t(B  $BJQ?t$,(B @code{extern} $B@k8@$5$l$F$$$k>l9g(B, $BH!?tFb$N$=$NJQ?t$bBg0hJQ?t(B
 $B$H$7$F07$o$l$k(B.  $B$H$7$F07$o$l$k(B.
   \E
   \BEG
   If a variable is declared as global by an @code{extern} statement in
   a function, the variable used in that function denotes a global variable
   at the top level.
   Furthermore, if a variable in a function is preceded by an @code{extern}
   declaration outside the function but in a file where the function is
   defined, all the appearance of that variable in the same file denote
   commonly a global variable at the top level.
   \E
   
 @item  @item
 @code{extern} $B@k8@$5$l$F$$$J$$JQ?t$O$=$NH!?t$K6I=jE*$H$J$k(B.  \JP @code{extern} $B@k8@$5$l$F$$$J$$JQ?t$O$=$NH!?t$K6I=jE*$H$J$k(B.
   \BEG
   A variable in a function is local to that function, if it is not declared
   as global by an @code{extern} declaration.
   \E
 @end enumerate  @end enumerate
   
 @example  @example
Line 77  end$
Line 155  end$
 @end example  @end example
   
 @item  @item
 $B%W%m%0%i%`JQ?t$OBgJ8;z$G;O$^$j(B, $BITDj85(B, $BH!?t$O>.J8;z$G;O$^$k(B.  \JP $B%W%m%0%i%`JQ?t$OBgJ8;z$G;O$^$j(B, $BITDj85(B, $BH!?t$O>.J8;z$G;O$^$k(B.
   \EG Program variables and algebraic indeterminates are distinguished in @b{Asir}.
   @*
   \BJP
 $B$3$NE@$O(B, $B4{B8$N?t<0=hM}%7%9%F%`$N$[$H$s$I$H0[$J$kE@$G$"$k(B. @b{Asir}  $B$3$NE@$O(B, $B4{B8$N?t<0=hM}%7%9%F%`$N$[$H$s$I$H0[$J$kE@$G$"$k(B. @b{Asir}
 $B$,$3$N;EMM$r:NMQ$7$?$N$O(B, $B%f!<%6$,ITDj85$N$D$b$j$G;HMQ$7$?JQ?t$K(B  $B$,$3$N;EMM$r:NMQ$7$?$N$O(B, $B%f!<%6$,ITDj85$N$D$b$j$G;HMQ$7$?JQ?t$K(B
 $B$J$s$i$+$NCM$,BeF~$5$l$F$$$?>l9g$K:.Mp$r>7$/(B, $B$H$$$&(B, $B4{B8$N(B  $B$J$s$i$+$NCM$,BeF~$5$l$F$$$?>l9g$K:.Mp$r>7$/(B, $B$H$$$&(B, $B4{B8$N(B
 $B%7%9%F%`$K$"$j$,$A$J>u67$rHr$1$k$?$a$G$"$k(B.  $B%7%9%F%`$K$"$j$,$A$J>u67$rHr$1$k$?$a$G$"$k(B.
   \E
   \BEG
   The names of program variables must begin with a capital letter;
   while the names of indeterminates and functions must begin with
   a small letter.
   
   This is an unique point that differs from almost all other existing
   computer algebra systems.  The distinction between program variables
   and indeterminates is adopted to avoid the possible and usual confusion
   that may arise in a situation where a name is used as an indeterminate
   but, as it was, the name has been already assigned some value.
   To use different type of letters, capital and small, was a matter of
   syntactical convention like Prolog, but it is convenient to distinguish
   variables and indeterminates in a program.
   \E
   
 @item  @item
 @code{switch} $BJ8(B, @code{goto} $B$,$J$$(B.  \JP @code{switch} $BJ8(B, @code{goto} $B$,$J$$(B.
   \EG No @code{switch} statements, and @code{goto} statements.
   @*
   \JP @code{goto} $B$,$J$$$?$a(B, $BB?=E%k!<%W$r0lEY$KH4$1$k$N$,$d$dJ#;($K$J$k>l9g$,$"$k(B.
   \EG Lack of @code{goto} statement makes it rather bothering to exit from within multiple loops.
   
 @code{goto} $B$,$J$$$?$a(B, $BB?=E%k!<%W$r0lEY$KH4$1$k$N$,$d$dJ#;($K$J$k>l9g$,$"$k(B.  
   
 @item  @item
 $B%3%s%^<0$O(B, @code{for (A;B;C)} $B$^$?$O(B, @code{while(A)} $B$N(B @code{A}, @code{B}, @code{C} $B$K$N$_;H$&$3$H$,$G$-$k(B.  \BJP
   $B%3%s%^<0$O(B, @code{for (A;B;C)} $B$^$?$O(B, @code{while(A)} $B$N(B @code{A},
   @code{B}, @code{C} $B$K$N$_;H$&$3$H$,$G$-$k(B.
   \E
   \BEG
   Comma expressions are allowed only in @code{A}, @code{B} and @code{C}
   of the constructs @code{for (A;B;C)} or @code{while(A)}.
   \E
   @*
   \JP $B$3$l$O(B, $B%j%9%H$r@5<0$J%*%V%8%'%/%H$H$7$F2C$($?$3$H$K$h$k(B.
   \EG This limitation came from adopting lists as legal data objects for @b{Asir}.
   
 $B$3$l$O(B, $B%j%9%H$r@5<0$J%*%V%8%'%/%H$H$7$F2C$($?$3$H$K$h$k(B.  
   
 @end itemize  @end itemize
   
 @noindent  @noindent
 $B0J>e$O@)8B$G$"$k$,(B, $B3HD%$H$7$F$O<!$NE@$,5s$2$i$l$k(B.  \JP $B0J>e$O@)8B$G$"$k$,(B, $B3HD%$H$7$F$O<!$NE@$,5s$2$i$l$k(B.
   \EG The above are limitations; extensions are listed as follows.
   
 @itemize @bullet  @itemize @bullet
 @item  @item
 $BM-M}<0$KBP$9$k7W;;$r(B, $BDL>o$N(B C $B$K$*$1$k7W;;$HF1MM$K$G$-$k(B.  \JP $BM-M}<0$KBP$9$k7W;;$r(B, $BDL>o$N(B C $B$K$*$1$k7W;;$HF1MM$K$G$-$k(B.
   \BEG
   Arithmetic for rational expressions can be done in the
   same manner as is done for numbers in C language.
   \E
   
 @item  @item
 $B%j%9%H$,07$($k(B.  \JP $B%j%9%H$,07$($k(B.
   \EG Lists are available for data objects.
   
   \BJP
 $B9=B$BN$rMQ$$$k$^$G$b$J$$MWAG$N=89gBN$r(B, $B%j%9%H$GI=$9$3$H$,$G$-(B,  $B9=B$BN$rMQ$$$k$^$G$b$J$$MWAG$N=89gBN$r(B, $B%j%9%H$GI=$9$3$H$,$G$-(B,
 C $B$GD>@\=q$/>l9g$KHf3S$7$F%W%m%0%i%`$,C;$/(B, $BFI$_$d$9$/=q$1$k(B.  C $B$GD>@\=q$/>l9g$KHf3S$7$F%W%m%0%i%`$,C;$/(B, $BFI$_$d$9$/=q$1$k(B.
   \E
   \BEG
   Lists are conveniently used to represent a certain collection of objects.
   Use of lists enables to write programs more easily, shorter and more
   comprehensible than use of structure like C programs.
   \E
   
   \BJP
   @item
   $B%f!<%6Dj5AH!?t$K$*$1$k0l9T%X%k%W(B.  Emacs-Lisp $B$KN`;w$7$?5!G=$G$"$k(B.
   $B>\$7$/$O(B, @xref{$B%f!<%6Dj5AH!?t(B} $B$r8+$h(B.
   \E
   
   @item
   \JP $B%f!<%6Dj5AH!?t$K$*$1$k%*%W%7%g%s;XDj(B.
   \EG Options can be specified in calling user defined functions.
   
   \JP $B$3$l$K4X$7$F$O(B, @xref{$B%*%W%7%g%s;XDj(B}.
   \EG @xref{option}.
 @end itemize  @end itemize
   
   \BJP
   @noindent
   Asir $B$G$O<!$N8l6g$,%-!<%o!<%I$H$7$FDj$a$i$l$F$$$k(B.
   @itemize
   @item C $B8@8l$KM3Mh(B:
   
   @code{break}, @code{continue}, @code{do}, @code{else}, @code{extern},
   @code{for}, @code{if}, @code{return}, @code{static}, @code{struct},
   @code{while}
   @item C $B8@8l$+$i$N3HD%(B:
   
   @code{def}, @code{endmodule}, @code{function}, @code{global},
   @code{local}, @code{localf}, @code{module}
   @item $BH!?t(B:
   
   @code{car}, @code{cdr}, @code{getopt}, @code{newstruct}, @code{map},
   @code{pari}, @code{quote}, @code{recmap}, @code{timer}
   @end itemize
   \E
   
   \BJP
 @node $B%f!<%6Dj5AH!?t$N=q$-J}(B,,, $B%f!<%68@8l(B Asir  @node $B%f!<%6Dj5AH!?t$N=q$-J}(B,,, $B%f!<%68@8l(B Asir
 @section $B%f!<%6Dj5AH!?t$N=q$-J}(B  @section $B%f!<%6Dj5AH!?t$N=q$-J}(B
   \E
   \BEG
   @node Writing user defined functions,,, User language Asir
   @section Writing user defined functions
   \E
   
 @menu  @menu
   \BJP
 * $B%f!<%6Dj5AH!?t(B::  * $B%f!<%6Dj5AH!?t(B::
 * $BJQ?t$*$h$SITDj85(B::  * $BJQ?t$*$h$SITDj85(B::
 * $B0z?t(B::  * $B0z?t(B::
Line 122  C $B$GD>@\=q$/>l9g$KHf3S$7$F%W%m%0%i%`$,C;$/(B, $BF
Line 280  C $B$GD>@\=q$/>l9g$KHf3S$7$F%W%m%0%i%`$,C;$/(B, $BF
 * return $BJ8(B::  * return $BJ8(B::
 * if $BJ8(B::  * if $BJ8(B::
 * $B%k!<%W(B break return continue::  * $B%k!<%W(B break return continue::
   * $B9=B$BNDj5A(B::
 * $B$5$^$6$^$J<0(B::  * $B$5$^$6$^$J<0(B::
 * $B%W%j%W%m%;%C%5(B::  * $B%W%j%W%m%;%C%5(B::
   * $B%*%W%7%g%s;XDj(B::
   * $B%b%8%e!<%k(B::
   \E
   \BEG
   * User defined functions::
   * variables and indeterminates::
   * parameters and arguments::
   * comments::
   * statements::
   * return statement::
   * if statement::
   * loop break return continue::
   * structure definition::
   * various expressions::
   * preprocessor::
   * option::
   * module::
   \E
 @end menu  @end menu
   
   \BJP
 @node $B%f!<%6Dj5AH!?t(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node $B%f!<%6Dj5AH!?t(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $B%f!<%6Dj5AH!?t(B  @subsection $B%f!<%6Dj5AH!?t(B
   \E
   \BEG
   @node User defined functions,,, Writing user defined functions
   @subsection User defined functions
   \E
   
 @noindent  @noindent
   \BJP
 $B%f!<%6$K$h$kH!?t$NDj5A$O(B @samp{def} $BJ8$G9T$&(B. $BJ8K!%(%i!<$OFI$_9~$_;~$K(B  $B%f!<%6$K$h$kH!?t$NDj5A$O(B @samp{def} $BJ8$G9T$&(B. $BJ8K!%(%i!<$OFI$_9~$_;~$K(B
 $B$"$kDxEY%A%'%C%/$5$l(B, $B$*$*$h$=$N>l=j$,I=<($5$l$k(B.  $B$"$kDxEY%A%'%C%/$5$l(B, $B$*$*$h$=$N>l=j$,I=<($5$l$k(B.
 $B4{$K(B($B0z?t$N8D?t$K4X78$J$/(B)$BF1L>$NH!?t$,Dj5A$5$l$F$$$k>l9g$K$O(B,  $B4{$K(B($B0z?t$N8D?t$K4X78$J$/(B)$BF1L>$NH!?t$,Dj5A$5$l$F$$$k>l9g$K$O(B,
 $B$=$NH!?t$O:FDj5A$5$l$k(B. @code{ctrl()} $BH!?t$K$h$j(B @code{verbose} $B%U%i%0(B  $B$=$NH!?t$O:FDj5A$5$l$k(B. @code{ctrl()} $BH!?t$K$h$j(B @code{verbose} $B%U%i%0(B
 $B$,(B on $B$K$J$C$F$$$k>l9g(B,  $B$,(B on $B$K$J$C$F$$$k>l9g(B,
   \E
   \BEG
   To define functions by an user himself, @samp{def} statement must be used.
   Syntactical errors are detected in the parsing phase
   of @b{Asir}, and notified with an indication of where @b{Asir} found the error.
   If a function with the same name is already defined (regardless to
   its arity,) the new definition will override the old one, and the user
   will be told by a message,
   \E
   
 @example  @example
 afo() redefined.  afo() redefined.
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$H$$$&%a%C%;!<%8$,I=<($5$l$k(B. $B$"$kH!?t$NDj5A$K$*$$$F(B, $B$^$@L$Dj5A$NH!?t(B  $B$H$$$&%a%C%;!<%8$,I=<($5$l$k(B. $B$"$kH!?t$NDj5A$K$*$$$F(B, $B$^$@L$Dj5A$NH!?t(B
 $B$r8F$S=P$7$F$$$F$b(B, $BDj5A;~$K$O%(%i!<$K$J$i$J$$(B. $B<B9T;~$KL$Dj5A$NH!?t(B  $B$r8F$S=P$7$F$$$F$b(B, $BDj5A;~$K$O%(%i!<$K$J$i$J$$(B. $B<B9T;~$KL$Dj5A$NH!?t(B
 $B$r8F$S=P$=$&$H$7$?>l9g$K%(%i!<$H$J$k(B.  $B$r8F$S=P$=$&$H$7$?>l9g$K%(%i!<$H$J$k(B.
   \E
   \BEG
   on the screen when a flag @code{verbose} is set to a non-zero value by
   @code{ctrl()}.
   Recursive definition, and of course, recursive use of functions are
   available.
   A call for an yet undefined function in a function definition is not
   detected as an error.  An error will be detected at execution of the
   call of that yet undefined function.
   \E
 @example  @example
 @tex  @tex
 /* $X!$ */  /* $X!$ */
Line 158  def f(X) @{ 
Line 361  def f(X) @{ 
 @}  @}
   
 @tex  @tex
 /* ${_i}C_j ( 0 \le i \le N, 0 \le j \le i )$ */  \JP /* ${_i}C_j ( 0 \le i \le N, 0 \le j \le i )$ */
   \EG /* ${_i}C_j ( 0 \le i \le N, 0 \le j \le i )$ */
 @end tex  @end tex
   
 def c(N)  def c(N)
Line 171  def c(N)
Line 375  def c(N)
         @}          @}
     return A;      return A;
 @}  @}
   
   @tex
   /* $A+B$ */
   @end tex
   
   def add(A,B)
   "add two numbers."
   @{
       return A+B;
   @}
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 2 $B$DL\$NNc$G$O(B, $BD9$5(B @code{N+1} $B$N%Y%/%H%k(B (@code{A}$B$H$9$k(B) $B$,JV$5$l$k(B.  2 $B$DL\$NNc$G$O(B, $BD9$5(B @code{N+1} $B$N%Y%/%H%k(B (@code{A}$B$H$9$k(B) $B$,JV$5$l$k(B.
 @code{A[I]} $B$OD9$5(B @code{I+1} $B$NG[Ns$G$"$j(B, $B$=$N$=$l$>$l$NMWAG$,(B  @code{A[I]} $B$OD9$5(B @code{I+1} $B$NG[Ns$G$"$j(B, $B$=$N$=$l$>$l$NMWAG$,(B
   \E
   \BEG
   In the second example, @code{c(N)} returns a vector, say @code{A}, of length
   @code{N+1}.  @code{A[I]} is a vector of length @code{I+1}, and
   each element is again a vector which contains
   \E
 @iftex  @iftex
 @tex  @tex
 ${_I}C_J$  ${_I}C_J$
 @end tex  @end tex
 @end iftex  @end iftex
 @ifinfo  @ifnottex
 ICJ  ICJ
 @end ifinfo  @end ifnottex
 $B$rMWAG$H$9$kG[Ns$G$"$k(B.  \JP $B$rMWAG$H$9$kG[Ns$G$"$k(B.
   \EG as its elements.
   
 @noindent  @noindent
   \BJP
   3 $B$DL\$NNc$G$O(B, $B0z?tJB$S$N$"$H$KJ8;zNs$,CV$+$l$F$$$k$,!"$3$l$O(B
   Emacs-Lisp $B$N4X?tDj5A$KN`;w$N5!G=$G!"%X%k%WMQ$NJ8;zNs$G$"$k!#(B
   $B$3$NNc$N>l9g!"(B@code{help(add)} $B$K$h$C$F$3$NJ8;zNs$,=PNO$5$l$k!#(B
   \E
   @table @t
   \JP @item $B;2>H(B
   \EG @item References
   @fref{help}.
   @end table
   
   @noindent
   \BJP
 $B0J2<$G$O(B, C $B$K$h$k%W%m%0%i%_%s%0$N7P83$,$J$$?M$N$?$a$K(B, @b{Asir} $B8@8l(B  $B0J2<$G$O(B, C $B$K$h$k%W%m%0%i%_%s%0$N7P83$,$J$$?M$N$?$a$K(B, @b{Asir} $B8@8l(B
 $B$K$h$k%W%m%0%i%`$N=q$-J}$r2r@b$9$k(B.  $B$K$h$k%W%m%0%i%`$N=q$-J}$r2r@b$9$k(B.
   \E
   \BEG
   In the following, the manner of writing @b{Asir} programs is exhibited
   for those who have no experience in writing C programs.
   \E
   
   \BJP
 @node $BJQ?t$*$h$SITDj85(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node $BJQ?t$*$h$SITDj85(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $BJQ?t$*$h$SITDj85(B  @subsection $BJQ?t$*$h$SITDj85(B
   \E
   
 @noindent  @noindent
   \BJP
 $B4{$K=R$Y$?DL$j(B, @b{Asir} $B$K$*$$$F$O%W%m%0%i%`JQ?t$HITDj85$rL@3N$K(B  $B4{$K=R$Y$?DL$j(B, @b{Asir} $B$K$*$$$F$O%W%m%0%i%`JQ?t$HITDj85$rL@3N$K(B
 $B6hJL$7$F$$$k(B.  $B6hJL$7$F$$$k(B.
   \E
   \BEG
   @node variables and indeterminates,,, Writing user defined functions
   @subsection variables and indeterminates
   \E
   
 @table @b  @table @b
   \BJP
 @item $BJQ?t(B  @item $BJQ?t(B
 $BBgJ8;z$G;O$^$j(B, $B%"%k%U%!%Y%C%H(B, $B?t;z(B, @samp{_} $B$+$i$J$kJ8;zNs(B  $BBgJ8;z$G;O$^$j(B, $B%"%k%U%!%Y%C%H(B, $B?t;z(B, @samp{_} $B$+$i$J$kJ8;zNs(B
   \E
   \BEG
   @item variables (program variables)
   A program variable is a string that begins with a capital
   alphabetical letter followed by any numbers of alphabetical letters,
   digits and @samp{_}.
   \E
   
   \BJP
 $BJQ?t$"$k$$$O%W%m%0%i%`JQ?t$H$O(B, @b{Asir} $B$N$5$^$6$^$J7?$NFbIt7A<0$r(B  $BJQ?t$"$k$$$O%W%m%0%i%`JQ?t$H$O(B, @b{Asir} $B$N$5$^$6$^$J7?$NFbIt7A<0$r(B
 $B3JG<$9$k$?$a$NH"$G$"$j(B, $B3JG<$5$l$?FbIt7A<0$,(B, $B$3$NJQ?t$NCM$G$"$k(B.  $BJQ(B  $B3JG<$9$k$?$a$NH"$G$"$j(B, $B3JG<$5$l$?FbIt7A<0$,(B, $B$3$NJQ?t$NCM$G$"$k(B.  $BJQ(B
 $B?t$,<0$NMWAG$H$7$FI>2A$5$l$k;~$O(B, $B$=$3$K<}$a$i$l$?CM$KCV$-49$($i$l$k(B.  $B?t$,<0$NMWAG$H$7$FI>2A$5$l$k;~$O(B, $B$=$3$K<}$a$i$l$?CM$KCV$-49$($i$l$k(B.
 $B$9$J$o$A(B, $BFbIt7A<0$NCf$K$O%W%m%0%i%`JQ?t$O8=$l$J$$(B. $BJQ?t$OA4$F(B 0 $B$G(B  $B$9$J$o$A(B, $BFbIt7A<0$NCf$K$O%W%m%0%i%`JQ?t$O8=$l$J$$(B. $BJQ?t$OA4$F(B 0 $B$G(B
 $B=i4|2=$5$l$F$$$k(B.  $B=i4|2=$5$l$F$$$k(B.
   \E
   \BEG
   A program variable is thought of a box (a carrier) which can contain
   @b{Asir} objects of various types.  The content is called the `value'
   of that variable.  When an expression in a program is to be evaluated,
   the variable appearing in the expression is first replaced by its value
   and then the expression is evaluated to some value and stored in
   the memory.  Thus, no program variable appears in objects in the
   internal form.
   All the program variables are initialized to the value 0.
   \E
   
 @example  @example
 [0] X^2+X+1;  [0] X^2+X+1;
Line 216  ICJ
Line 484  ICJ
 7  7
 @end example  @end example
   
   \BJP
 @item $BITDj85(B  @item $BITDj85(B
 $B>.J8;z$G;O$^$j(B, $B%"%k%U%!%Y%C%H(B, $B?t;z(B, @samp{_} $B$+$i$J$kJ8;zNs(B  $B>.J8;z$G;O$^$j(B, $B%"%k%U%!%Y%C%H(B, $B?t;z(B, @samp{_} $B$+$i$J$kJ8;zNs(B,
   $B$^$?$O%7%s%0%k%/%*!<%H$G0O$^$l$?J8;zNs(B, $B$b$7$/$OH!?t7A<0(B.
 $BITDj85$H$O(B, $BB?9`<04D$r9=@.$9$k:]$KE:2C$5$l$kJQ?t$r$$$&(B. @b{Asir} $B$K(B  $BITDj85$H$O(B, $BB?9`<04D$r9=@.$9$k:]$KE:2C$5$l$kJQ?t$r$$$&(B.  @b{Asir} $B$K(B
 $B$*$$$F$O(B, $BITDj85$OCM$r$b$?$J$$D61[E*$J85$G$"$j(B, $BITDj85$X$NCM$NBeF~$O(B  $B$*$$$F$O(B, $BITDj85$OCM$r$b$?$J$$D61[E*$J85$G$"$j(B, $BITDj85$X$NCM$NBeF~$O(B
 $B5v$5$l$J$$(B.  $B5v$5$l$J$$(B.
   \E
   \BEG
   @item indeterminates
   An indeterminate is a string that begins with a small alphabetical letter
   followed by any numbers of alphabetical letters, digits and @samp{_}.
   
   An indeterminate is a transcendental element, so-called variable,
   which is used to construct polynomial rings.
   An indeterminate cannot have any value.  No assignment is allowed to it.
   \E
   
 @example  @example
 [3] X=x;  [3] X=x;
 x  x
 [4] X^2+X+1;  [4] X^2+X+1;
 x^2+x+1  x^2+x+1
   [5] A='Dx'*(x-1)+x*y-y;
   (y+Dx)*x-y-Dx
   [6] function foo(x,y);
   [7] B=foo(x,y)*x^2-1;
   foo(x,y)*x^2-1
 @end example  @end example
 @end table  @end table
   
   \BJP
 @node $B0z?t(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node $B0z?t(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $B0z?t(B  @subsection $B0z?t(B
   \E
   \BEG
   @node parameters and arguments,,, Writing user defined functions
   @subsection parameters and arguments
   \E
   
 @example  @example
 def sum(N) @{  def sum(N) @{
Line 243  def sum(N) @{
Line 533  def sum(N) @{
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$3$l$O(B, 1 $B$+$i(B @code{N} $B$^$G$N<+A3?t$NOB$r5a$a$kH!?t(B @code{sum()} $B$N(B  $B$3$l$O(B, 1 $B$+$i(B @code{N} $B$^$G$N<+A3?t$NOB$r5a$a$kH!?t(B @code{sum()} $B$N(B
 $BDj5A$G$"$k(B. $B$3$NNc$K$*$1$k(B @code{sum(N)} $B$N(B @code{N} $B$,0z?t$G$"$k(B.  $BDj5A$G$"$k(B. $B$3$NNc$K$*$1$k(B @code{sum(N)} $B$N(B @code{N} $B$,0z?t$G$"$k(B.
 $B$3$NNc$O(B, 1 $B0z?tH!?t$NNc$G$"$k$,(B, $B0lHL$K0z?t$N8D?t$OG$0U$G$"$j(B,  $B$3$NNc$O(B, 1 $B0z?tH!?t$NNc$G$"$k$,(B, $B0lHL$K0z?t$N8D?t$OG$0U$G$"$j(B,
Line 252  def sum(N) @{
Line 543  def sum(N) @{
 $B9TNs$r0z?t$KEO$7$?>l9g$G$"$k(B. $B$3$N>l9g$b(B, $BEO$5$l$?JQ?t$=$N$b$N$r=q$-(B  $B9TNs$r0z?t$KEO$7$?>l9g$G$"$k(B. $B$3$N>l9g$b(B, $BEO$5$l$?JQ?t$=$N$b$N$r=q$-(B
 $BBX$($k$3$H$O(B, $B$=$NH!?t$K6I=jE*$JA`:n$G$"$k$,(B, $BMWAG$r=q$-49$($?>l9g(B,  $BBX$($k$3$H$O(B, $B$=$NH!?t$K6I=jE*$JA`:n$G$"$k$,(B, $BMWAG$r=q$-49$($?>l9g(B,
 $B$=$l$O(B, $B8F$S=P$7B&$N%Y%/%H%k(B, $B9TNs$NMWAG$r=q$-49$($k$3$H$K$J$k(B.  $B$=$l$O(B, $B8F$S=P$7B&$N%Y%/%H%k(B, $B9TNs$NMWAG$r=q$-49$($k$3$H$K$J$k(B.
   \E
   \BEG
   This is an example definition of a function that sums up integers
   from 1 to @code{N}.  The @code{N} in @code{sum(N)} is called the
   (formal) parameter of @code{sum(N)}.
   The example shows a function of the single argument.
   In general, any number of parameters can be specified by separating
   by commas (@samp{,}).
   A (formal) parameter accepts a value given as an argument (or an actual
   parameter) at a function call of the function.
   Since the value of the argument is given to the formal parameter,
   any modification to the parameter does not usually affect the argument
   (or actual parameter).  However, there are a few exceptions: vector
   arguments and matrix arguments.
   
   Let @code{A} be a program variable and assigned to a vector value
   @code{[ a, b ]}.
   If A is given as an actual parameter to a formal parameter, say @code{V},
   of a function, then an assignment in the function to the vector element
   designator @code{V[1]}, say @code{V[1]=c;}, causes modification of the
   actual parameter @code{A} resulting @code{A} to have an altered value
   @code{[ a c ]}.  Thus, if a vector is given to a formal parameter of
   a function, then its element (and subsequently the vector itself) in
   the calling side is modified through modification of the formal parameter
   by a vector element designator in the called function.
   The same applies to a matrix argument.
   Note that, even in such case where a vector (or a matrix) is given to
   a formal parameter, the assignment to the whole parameter itself has
   only a local effect within the function.
   \E
   
 @example  @example
 def clear_vector(M) @{  def clear_vector(M) @{
Line 263  def clear_vector(M) @{
Line 584  def clear_vector(M) @{
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$3$NH!?t$O(B, $B0z?t$N%Y%/%H%k$r(B 0 $B%Y%/%H%k$K=i4|2=$9$k$?$a$NH!?t$G$"$k(B.  $B$3$NH!?t$O(B, $B0z?t$N%Y%/%H%k$r(B 0 $B%Y%/%H%k$K=i4|2=$9$k$?$a$NH!?t$G$"$k(B.
 $B$^$?(B, $B%Y%/%H%k$r0z?t$KEO$9$3$H$K$h$j(B, $BJ#?t$N7k2L$r0z?t$N%Y%/%H%k$K(B  $B$^$?(B, $B%Y%/%H%k$r0z?t$KEO$9$3$H$K$h$j(B, $BJ#?t$N7k2L$r0z?t$N%Y%/%H%k$K(B
 $B<}G<$7$FJV$9$3$H$,$G$-$k(B. $B<B:]$K$O(B, $B$3$N$h$&$J>l9g$K$O(B, $B7k2L$r%j%9%H(B  $B<}G<$7$FJV$9$3$H$,$G$-$k(B. $B<B:]$K$O(B, $B$3$N$h$&$J>l9g$K$O(B, $B7k2L$r%j%9%H(B
 $B$K$7$FJV$9$3$H$b$G$-$k(B. $B>u67$K1~$8$F;H$$$o$1$9$k$3$H$,K>$^$7$$(B.  $B$K$7$FJV$9$3$H$b$G$-$k(B. $B>u67$K1~$8$F;H$$$o$1$9$k$3$H$,K>$^$7$$(B.
   \E
   \BEG
   This function will clear off the vector given as its argument to the
   formal parameter @code{M} and return a 0 vector.
   
   Passing a vector as an argument to a function enables returning
   multiple results by packing each result in a vector element.
   Another alternative to return multiple results is to use a list.
   Which to use depends on cases.
   \E
   
   \BJP
 @node $B%3%a%s%H(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node $B%3%a%s%H(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $B%3%a%s%H(B  @subsection $B%3%a%s%H(B
   \E
   \BEG
   @node comments,,, Writing user defined functions
   @subsection comments
   \E
   
 @noindent  @noindent
 C $B$HF1MM(B @samp{/*} $B$H(B @samp{*/} $B$G0O$^$l$?ItJ,$O%3%a%s%H$H$7$F07$o$l$k(B.  \JP C $B$HF1MM(B @samp{/*} $B$H(B @samp{*/} $B$G0O$^$l$?ItJ,$O%3%a%s%H$H$7$F07$o$l$k(B.
   \BEG
   The text enclosed by @samp{/*} and @samp{*/} (containing @samp{/*} and
   @samp{*/}) is treated as a comment and has no effect to the program
   execution as in C programs.
   \E
   
 @example  @example
 /*  /*
Line 283  def afo(X) @{
Line 626  def afo(X) @{
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B%3%a%s%H$OJ#?t9T$KEO$C$F$b9=$o$J$$$,(B, $BF~$l;R$K$9$k$3$H$O$G$-$J$$(B.  $B%3%a%s%H$OJ#?t9T$KEO$C$F$b9=$o$J$$$,(B, $BF~$l;R$K$9$k$3$H$O$G$-$J$$(B.
 @samp{/*} $B$,$$$/$D$"$C$F$b:G=i$N$b$N$N$_$,M-8z$H$J$j(B, $B:G=i$K8=$l$?(B  @samp{/*} $B$,$$$/$D$"$C$F$b:G=i$N$b$N$N$_$,M-8z$H$J$j(B, $B:G=i$K8=$l$?(B
 @samp{*/} $B$G%3%a%s%H$O=*N;$7$?$H8+$J$5$l$k(B. $B%W%m%0%i%`$J$I$G(B, $B%3%a%s%H(B  @samp{*/} $B$G%3%a%s%H$O=*N;$7$?$H8+$J$5$l$k(B. $B%W%m%0%i%`$J$I$G(B, $B%3%a%s%H(B
 $B$r4^$`2DG=@-$,$"$kItJ,$r%3%a%s%H%"%&%H$7$?>l9g$K$O(B, @code{#if 0},  $B$r4^$`2DG=@-$,$"$kItJ,$r%3%a%s%H%"%&%H$7$?>l9g$K$O(B, @code{#if 0},
 @code{#endif}$B$r;H$($P$h$$(B. (@xref{$B%W%j%W%m%;%C%5(B})  @code{#endif}$B$r;H$($P$h$$(B. (@xref{$B%W%j%W%m%;%C%5(B}.)
   \E
   \BEG
   A comment can span to several lines, but it cannot be nested.
   Only the first @samp{/*} is effective no matter how many @samp{/*}'s
   in the subsequent text exist, and the comment terminates at the first
   @samp{*/}.
   
   In order to comment out a program part that may contain comments in it,
   use the pair, @code{#if 0} and @code{#endif}. (@xref{preprocessor}.)
   \E
   
 @example  @example
 #if 0  #if 0
Line 297  def bfo(X) @{
Line 651  def bfo(X) @{
 #endif  #endif
 @end example  @end example
   
   \BJP
 @node $BJ8(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node $BJ8(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $BJ8(B  @subsection $BJ8(B
   \E
   \BEG
   @node statements,,, Writing user defined functions
   @subsection statements
   \E
   
 @noindent  @noindent
   \BJP
 @b{Asir} $B$N%f!<%6H!?t$O(B,  @b{Asir} $B$N%f!<%6H!?t$O(B,
   
 @example  @example
Line 310  def $BL>A0(B($B0z?t(B,$B0z?t(B,...,$B0z?t(B) @
Line 671  def $BL>A0(B($B0z?t(B,$B0z?t(B,...,$B0z?t(B) @
     ...      ...
     $BJ8(B      $BJ8(B
 @}  @}
   \E
   \BEG
   An user function of @b{Asir} is defined in the following form.
   
   @example
   def name(parameter, parameter,...,parameter) @{
       statement
       statement
       ...
       statement
   @}
   \E
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$H$$$&7A$GDj5A$5$l$k(B. $B$3$N$h$&$K(B, $BJ8$OH!?t$N4pK\E*9=@.MWAG$G$"$j(B, $B%W%m(B  $B$H$$$&7A$GDj5A$5$l$k(B. $B$3$N$h$&$K(B, $BJ8$OH!?t$N4pK\E*9=@.MWAG$G$"$j(B, $B%W%m(B
 $B%0%i%`$r=q$/$?$a$K$O(B, $BJ8$,$I$N$h$&$J$b$N$G$"$k$+CN$i$J$1$l$P$J$i$J$$(B.  $B%0%i%`$r=q$/$?$a$K$O(B, $BJ8$,$I$N$h$&$J$b$N$G$"$k$+CN$i$J$1$l$P$J$i$J$$(B.
 $B:G$bC1=c$JJ8$H$7$F(B, $BC1J8$,$"$k(B. $B$3$l$O(B,  $B:G$bC1=c$JJ8$H$7$F(B, $BC1J8$,$"$k(B. $B$3$l$O(B,
   \E
   \BEG
   As you can see, the statement is a fundamental element of the
   function.
   Therefore, in order to write a program, you have to learn what
   the statement is.  The simplest statement is the simple statement.
   One example is an expression with a terminator (@samp{;} or @samp{$}.)
   \E
   
 @example  @example
 S = sum(N);  S = sum(N);
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$N$h$&$K(B, $B<0$K=*C<5-9f(B (@samp{;} $B$^$?$O(B @samp{$}) $B$r$D$1$?$b$N$G$"$k(B.  $B$N$h$&$K(B, $B<0$K=*C<5-9f(B (@samp{;} $B$^$?$O(B @samp{$}) $B$r$D$1$?$b$N$G$"$k(B.
 $B$3$NC1J85Z$SN`;w$N(B @code{return} $BJ8(B, @code{break} $BJ8$J$I$,J8$N:G>.9=@.(B  $B$3$NC1J85Z$SN`;w$N(B @code{return} $BJ8(B, @code{break} $BJ8$J$I$,J8$N:G>.9=@.(B
 $BC10L$H$J$k(B. @code{if} $BJ8$d(B @code{for} $BJ8$NDj5A(B (@xref{$BJ8K!$N>\:Y(B}) $B$r8+$l(B  $BC10L$H$J$k(B. @code{if} $BJ8$d(B @code{for} $BJ8$NDj5A(B (@ref{$BJ8K!$N>\:Y(B}) $B$r8+$l(B
 $B$P$o$+$kDL$j(B, $B$=$l$i$NK\BN$O(B, $BC1$J$k0l$D$NJ8$H$7$FDj5A$5$l$F$$$k(B. $BDL>o(B  $B$P$o$+$kDL$j(B, $B$=$l$i$NK\BN$O(B, $BC1$J$k0l$D$NJ8$H$7$FDj5A$5$l$F$$$k(B. $BDL>o(B
 $B$O(B, $BK\BN$K$OJ#?t$NJ8$,=q$1$k$3$H$,I,MW$H$J$k(B.  $B$3$N$h$&$J>l9g(B,  $B$O(B, $BK\BN$K$OJ#?t$NJ8$,=q$1$k$3$H$,I,MW$H$J$k(B.  $B$3$N$h$&$J>l9g(B,
 @samp{@{} $B$H(B @samp{@}} $B$GJ8$NJB$S$r3g$C$F(B, $B0l$D$NJ8$H$7$F07$&$3$H$,$G(B  @samp{@{} $B$H(B @samp{@}} $B$GJ8$NJB$S$r3g$C$F(B, $B0l$D$NJ8$H$7$F07$&$3$H$,$G(B
 $B$-$k(B. $B$3$l$rJ#J8$H8F$V(B.  $B$-$k(B. $B$3$l$rJ#J8$H8F$V(B.
   \E
   \BEG
   A `@code{return} statement' and `@code{break} statement' are also
   primitives to construct `statements.'
   As you can see the syntactic definition of `@code{if} statement' and
   `@code{for} statement', each of their bodies consists of a single
   `statement.'  Usually, you need several statements in such a body.
   To solve this contradictory requirement, you may use the `compound
   statement.'  A `compound statement' is a sequence of `statement's
   enclosed by a left brace @samp{@{} and a right brace @samp{@}}.
   Thus, you can use multiple statement as if it were a single statement.
   \E
   
 @example  @example
 if ( I == 0 ) @{  if ( I == 0 ) @{
Line 339  if ( I == 0 ) @{
Line 734  if ( I == 0 ) @{
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 @samp{@}} $B$N8e$m$K$O=*C<5-9f$OI,MW$J$$(B. $B$J$<$J$i(B, @samp{@{} $BJ8JB$S(B  @samp{@}} $B$N8e$m$K$O=*C<5-9f$OI,MW$J$$(B. $B$J$<$J$i(B, @samp{@{} $BJ8JB$S(B
 @samp{@}}$B$,4{$KJ8$H$J$C$F$$$F(B, @code{if} $BJ8$NMW@A$rK~$?$7$F$$$k$+$i$G(B  @samp{@}}$B$,4{$KJ8$H$J$C$F$$$F(B, @code{if} $BJ8$NMW@A$rK~$?$7$F$$$k$+$i$G(B
 $B$"$k(B.  $B$"$k(B.
   \E
   \BEG
   No terminator symbol is necessary after @samp{@}},
   because @samp{@{} statement sequence @samp{@}} already forms a statement,
   and it satisfies the syntactical requirement of the
   `@code{if} statement.'
   \E
   
   \BJP
 @node return $BJ8(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node return $BJ8(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection @code{return} $BJ8(B  @subsection @code{return} $BJ8(B
   \E
   \BEG
   @node return statement,,, Writing user defined functions
   @subsection @code{return} statement
   \E
   
 @noindent  @noindent
 @code{return} $BJ8$O(B,  \JP @code{return} $BJ8$O(B,
   \EG There are two forms of @code{return} statement.
   
 @example  @example
 return $B<0(B;  \JP return $B<0(B;
   \EG return expression;
   
 return;  return;
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$N(B 2 $B$D$N7A<0$,$"$k(B. $B$$$:$l$bH!?t$+$iH4$1$k$?$a$NJ8$G$"$k(B. $BA0<T$O(B  $B$N(B 2 $B$D$N7A<0$,$"$k(B. $B$$$:$l$bH!?t$+$iH4$1$k$?$a$NJ8$G$"$k(B. $BA0<T$O(B
 $BH!?t$NCM$H$7$F(B $B<0(B $B$rJV$9(B. $B8e<T$G$O(B, $BH!?t$NCM$H$7$F2?$,JV$5$l$k$+(B  $BH!?t$NCM$H$7$F(B $B<0(B $B$rJV$9(B. $B8e<T$G$O(B, $BH!?t$NCM$H$7$F2?$,JV$5$l$k$+(B
 $B$O$o$+$i$J$$(B.  $B$O$o$+$i$J$$(B.
   \E
   \BEG
   Both forms are used for exiting from a function.
   The former returns the value of the expression as a function value.
   The function value of the latter is not defined.
   \E
   
   \BJP
 @node if $BJ8(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node if $BJ8(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection @code{if} $BJ8(B  @subsection @code{if} $BJ8(B
   \E
   \BEG
   @node if statement,,, Writing user defined functions
   @subsection @code{if} statement
   \E
   
 @noindent  @noindent
 @code{if} $BJ8$K$O(B  \JP @code{if} $BJ8$K$O(B
   \EG There are two forms of @code{if} statement.
   
 @example  @example
   \BJP
 if ( $B<0(B )             if ( $B<0(B )  if ( $B<0(B )             if ( $B<0(B )
     $BJ8(B       $B5Z$S(B         $BJ8(B      $BJ8(B       $B5Z$S(B         $BJ8(B
 else  else
     $BJ8(B      $BJ8(B
   \E
   \BEG
   if ( expression )             if ( expression )
        statement       and           statement
   else
        statement
   \E
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$N(B 2 $B<oN`$,$"$k(B. $B$3$l$i$NF0:n$OL@$i$+$G$"$k$,(B, $BJ8$N0LCV$K(B @code{if} $BJ8(B  $B$N(B 2 $B<oN`$,$"$k(B. $B$3$l$i$NF0:n$OL@$i$+$G$"$k$,(B, $BJ8$N0LCV$K(B @code{if} $BJ8(B
 $B$,Mh$?>l9g$KCm0U$rMW$9$k(B. $B<!$NNc$r9M$($F$_$h$&(B.  $B$,Mh$?>l9g$KCm0U$rMW$9$k(B. $B<!$NNc$r9M$($F$_$h$&(B.
   \E
   \BEG
   The interpretation of these forms are obvious.  However, be careful
   when another @code{if} statement comes at the place for `statement'.
   Let us examine the following example.
   \E
   
 @example  @example
   \BJP
 if ( $B<0(B )  if ( $B<0(B )
     if ( $B<0(B ) $BJ8(B      if ( $B<0(B ) $BJ8(B
 else  else
     $BJ8(B      $BJ8(B
   \E
   \BEG
   if ( expression1 )
       if ( expression2 ) statement1
   else
       statement2
   \E
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$3$N>l9g(B, $B;z2<$2$+$i$O(B, @code{else} $B0J2<$O(B, $B:G=i$N(B @code{if} $B$KBP1~$9$k(B  $B$3$N>l9g(B, $B;z2<$2$+$i$O(B, @code{else} $B0J2<$O(B, $B:G=i$N(B @code{if} $B$KBP1~$9$k(B
 $B$h$&$K8+$($k$,(B, $B%Q!<%6$O(B, $B<+F0E*$K(B 2 $BHVL\$N(B @code{if} $B$KBP1~$9$k$HH=CG$9$k(B.  $B$h$&$K8+$($k$,(B, $B%Q!<%6$O(B, $B<+F0E*$K(B 2 $BHVL\$N(B @code{if} $B$KBP1~$9$k$HH=CG$9$k(B.
 $B$9$J$o$A(B, 2 $B<oN`$N(B @code{if} $BJ8$r5v$7$?$?$a$K(B, $BJ8K!$K[#Kf@-$,8=$l(B, $B$=$l$r(B  $B$9$J$o$A(B, 2 $B<oN`$N(B @code{if} $BJ8$r5v$7$?$?$a$K(B, $BJ8K!$K[#Kf@-$,8=$l(B, $B$=$l$r(B
 $B2r>C$9$k$?$a$K(B, @code{else} $B0J2<$O(B, $B:G$b6a$$(B @code{if} $B$KBP1~$9$k$H(B  $B2r>C$9$k$?$a$K(B, @code{else} $B0J2<$O(B, $B:G$b6a$$(B @code{if} $B$KBP1~$9$k$H(B
 $B$$$&5,B'$,E,MQ$5$l$k$N$G$"$k(B. $B=>$C$F(B, $B$3$NNc$O(B,  $B$$$&5,B'$,E,MQ$5$l$k$N$G$"$k(B. $B=>$C$F(B, $B$3$NNc$O(B,
   \E
   \BEG
   One might guess @code{statement2} after @code{else} corresponds with the
   first @code{if ( expression1 )} by its appearance of indentation.
   But, as a matter of fact, the @code{Asir} parser decides that it
   correspond with the second @code{if ( expression2 )}.
   Ambiguity due to such two kinds of forms of @code{if} statement is
   thus solved by introducing a rule that a statement preceded by an
   @code{else} matches to the nearest preceding @code{if}.
   
   Therefore, rearrangement of the above example for improving readability
   according to the actual interpretation gives the following.
   \E
   
 @example  @example
   \BJP
 if ( $B<0(B ) @{  if ( $B<0(B ) @{
     if ( $B<0(B ) $BJ8(B else $BJ8(B      if ( $B<0(B ) $BJ8(B else $BJ8(B
 @}  @}
   \E
   \BEG
   if ( expression1 ) @{
       if ( expression2 ) statement1 else statement2
   @}
   \E
 @end example  @end example
   
 @noindent  @noindent
 $B$H$$$&0UL#$H$J$k(B. $B;z2<$2$KBP1~$5$;$k$?$a$K$O(B,  \JP $B$H$$$&0UL#$H$J$k(B. $B;z2<$2$KBP1~$5$;$k$?$a$K$O(B,
   \BEG
   On the other hand, in order to reflect the indentation, it must be
   written as the following.
   \E
   
 @example  @example
   \BJP
 if ( $B<0(B ) @{  if ( $B<0(B ) @{
     if ( $B<0(B ) $BJ8(B      if ( $B<0(B ) $BJ8(B
 @} else  @} else
     $BJ8(B      $BJ8(B
   \E
   \BEG
   if ( expression1 ) @{
       if ( expression2 ) statement1
   @} else
       statement2
   \E
 @end example  @end example
   
 @noindent  @noindent
 $B$H$7$J$1$l$P$J$i$J$$(B.  \JP $B$H$7$J$1$l$P$J$i$J$$(B.
   
   \BJP
   @noindent
   $B4X?t$NCf$G$J$/(B, top level $B$G(B @code{if} $BJ8$rMQ$$$k$H$-$O(B @code{$} $B$^$?$O(B @code{;}
   $B$G=*N;$9$kI,MW$,$"$k(B.
   $B$3$l$i$,$J$$$H<!$NJ8$,$h$_$H$P$5$l$k(B.
   \E
   \BEG
   @noindent
   When @code{if} is used in the top level, the @code{if} expression should be
   terminated with @code{$} or @code{;}.
   If there is no terminator, the next expression will be skipped to be evaluated.
   \E
   
   \BJP
 @node $B%k!<%W(B break return continue,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node $B%k!<%W(B break return continue,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $B%k!<%W(B, @code{break}, @code{return}, @code{continue}  @subsection $B%k!<%W(B, @code{break}, @code{return}, @code{continue}
   \E
   \BEG
   @node loop break return continue,,, Writing user defined functions
   @subsection @code{loop}, @code{break}, @code{return}, @code{continue}
   \E
   
 @noindent  @noindent
   \BJP
 $B%k!<%W$r9=@.$9$kJ8$O(B, @code{while} $BJ8(B, @code{for} $BJ8(B, @code{do} $BJ8(B  $B%k!<%W$r9=@.$9$kJ8$O(B, @code{while} $BJ8(B, @code{for} $BJ8(B, @code{do} $BJ8(B
 $B$N(B 3 $B<oN`$,$"$k(B.  $B$N(B 3 $B<oN`$,$"$k(B.
   \E
   \BEG
   There are three kinds of statements for loops (repetitions):
   the @code{while} statement, the @code{for} statement, and  the
   @code{do} statement.
   \E
   
 @itemize @bullet  @itemize @bullet
 @item  @item
 @code{while} $BJ8(B  \JP @code{while} $BJ8(B
   \EG @code{while} statement
   @*
   \JP $B7A<0$O(B,
   \EG It has the following form.
   
 $B7A<0$O(B,  
   
 @example  @example
 while ( $B<0(B ) $BJ8(B  \JP while ( $B<0(B ) $BJ8(B
   \EG while ( expression ) statement
 @end example  @end example
   
 @noindent  @noindent
   \BJP
 $B$G(B, $B$3$l$O(B, $B<0(B $B$rI>2A$7$F(B, $B$=$NCM$,(B 0 $B$G$J$$8B$j(B $BJ8(B $B$r<B9T$9$k$H$$$&(B  $B$G(B, $B$3$l$O(B, $B<0(B $B$rI>2A$7$F(B, $B$=$NCM$,(B 0 $B$G$J$$8B$j(B $BJ8(B $B$r<B9T$9$k$H$$$&(B
 $B0UL#$H$J$k(B. $B$?$H$($P(B $B<0(B $B$,(B 1 $B$J$i$P(B, $BC1=c$JL58B%k!<%W$H$J$k(B.  $B0UL#$H$J$k(B. $B$?$H$($P(B $B<0(B $B$,(B 1 $B$J$i$P(B, $BC1=c$JL58B%k!<%W$H$J$k(B.
   \E
   \BEG
   This statement specifies that @code{statement} is repeatedly evaluated
   as far as the @code{expression} evaluates to a non-zero value.
   If the expression 1 is given to the @code{expression}, it forms an
   infinite loop.
   \E
   
 @item  @item
 @code{for} $BJ8(B  \JP @code{for} $BJ8(B
   \EG @code{for} statement
   @*
   \JP $B7A<0$O(B,
   \EG It has the following form.
   
 $B7A<0$O(B,  
   
 @example  @example
 for ( $B<0JB$S(B-1; $B<0(B; $B<0JB$S(B-2 ) $BJ8(B  \JP for ( $B<0JB$S(B-1; $B<0(B; $B<0JB$S(B-2 ) $BJ8(B
   \EG for ( expr list-1; expr; expr list-2 ) statement
 @end example  @end example
   
 $B$G(B, $B$3$l$O(B  \JP $B$G(B, $B$3$l$O(B
   \EG This is equivalent to the program
   
 @example  @example
   \BJP
 $B<0JB$S(B-1 ($B$rC1J8JB$S$K$7$?$b$N(B)  $B<0JB$S(B-1 ($B$rC1J8JB$S$K$7$?$b$N(B)
 while ( $B<0(B ) @{  while ( $B<0(B ) @{
     $BJ8(B      $BJ8(B
     $B<0JB$S(B-2 ($B$rC1J8JB$S$K$7$?$b$N(B)      $B<0JB$S(B-2 ($B$rC1J8JB$S$K$7$?$b$N(B)
 @}  @}
   \E
   \BEG
   expr list-1 (transformed into a sequence of simple statement)
   while ( expr ) @{
       statement
       expr list-2 (transformed into a sequence of simple statement)
   @}
   \E
 @end example  @end example
   
 $B$HEy2A$G$"$k(B.  \JP $B$HEy2A$G$"$k(B.
   
 @item  @item
 @code{do} $BJ8(B  \JP @code{do} $BJ8(B
   \EG @code{do} statement
   @*
 @example  @example
   \BJP
 do @{  do @{
     $BJ8(B      $BJ8(B
 @} while ( $B<0(B )  @} while ( $B<0(B )
   \E
   \BEG
   do @{
       statement
   @} while ( expression )
   \E
 @end example  @end example
   
   \BJP
 $B$O(B, $B@h$K(B $BJ8$r<B9T$7$F$+$i>r7o<0$K$h$kH=Dj$r9T$&=j$,(B @code{while} $BJ8(B  $B$O(B, $B@h$K(B $BJ8$r<B9T$7$F$+$i>r7o<0$K$h$kH=Dj$r9T$&=j$,(B @code{while} $BJ8(B
 $B$H0[$J$C$F$$$k(B.  $B$H0[$J$C$F$$$k(B.
   \E
   \BEG
   This statement differs from @code{while} statement by the location of
   the termination condition: This statement first execute the
   @code{statement} and then check the condition, whereas @code{while}
   statement does it in the reverse order.
   \E
 @end itemize  @end itemize
   
 @noindent  @noindent
   \BJP
 $B%k!<%W$rH4$1=P$9<jCJ$H$7$F(B,  $B%k!<%W$rH4$1=P$9<jCJ$H$7$F(B,
 @code{break} $BJ85Z$S(B @code{return} $BJ8$,$"$k(B. $B$^$?(B, $B%k!<%W$N@)8f$r(B  @code{break} $BJ85Z$S(B @code{return} $BJ8$,$"$k(B. $B$^$?(B, $B%k!<%W$N@)8f$r(B
 $B$"$k0LCV$K0\$9<jCJ$H$7$F(B @code{continue} $BJ8$,$"$k(B.  $B$"$k0LCV$K0\$9<jCJ$H$7$F(B @code{continue} $BJ8$,$"$k(B.
   \E
   \BEG
   As means for exiting from loops, there are @code{break} statement and
   @code{return} statement.  The @code{continue} statement allows to move
   the control to a certain point of the loop.
   \E
 @itemize @bullet  @itemize @bullet
   
 @item  @item
 @code{break}  @code{break}
   @*
 @code{break} $BJ8$O(B, $B$=$l$r0O$`%k!<%W$r0l$D$@$1H4$1$k(B.  \JP @code{break} $BJ8$O(B, $B$=$l$r0O$`%k!<%W$r0l$D$@$1H4$1$k(B.
   \EG The @code{break} statement is used to exit the inner most loop.
 @item  @item
 @code{return}  @code{return}
   @*
   \BJP
 @code{return} $BJ8$O(B, $B0lHL$KH!?t$+$iH4$1$k$?$a$NJ8$G$"$j(B,  @code{return} $BJ8$O(B, $B0lHL$KH!?t$+$iH4$1$k$?$a$NJ8$G$"$j(B,
 $B%k!<%W$NCf$+$i$G$bM-8z$G$"$k(B.  $B%k!<%W$NCf$+$i$G$bM-8z$G$"$k(B.
   \E
   \BEG
   The @code{return} statement is usually used to exit from a function call
   and it is also effective in a loop.
   \E
   
 @item  @item
 @code{continue}  @code{continue}
   @*
   \BJP
 @code{continue} $BJ8$O(B, $B%k!<%W$NK\BN$NJ8$NKvC<$K@)8f$r0\$9(B.  @code{continue} $BJ8$O(B, $B%k!<%W$NK\BN$NJ8$NKvC<$K@)8f$r0\$9(B.
 $BNc$($P(B @code{for} $BJ8$G$O(B, $B:G8e$N<0JB$S$N<B9T$r9T$$(B, @code{while}  $BNc$($P(B @code{for} $BJ8$G$O(B, $B:G8e$N<0JB$S$N<B9T$r9T$$(B, @code{while}
 $BJ8$G$O>r7o<0$NH=Dj$K0\$k(B.  $BJ8$G$O>r7o<0$NH=Dj$K0\$k(B.
   \E
   \BEG
   The @code{continue} statement is used to move the control to the end
   point of the loop body.
   For example, the last expression list will be evaluated in a @code{for}
   statement, and the termination condition will be evaluated in a
   @code{while} statement.
   \E
 @end itemize  @end itemize
   
   \BJP
   @node $B9=B$BNDj5A(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
   @subsection $B9=B$BNDj5A(B
   \E
   \BEG
   @node structure definition,,, Writing user defined functions
   @subsection structure definition
   \E
   
   \BJP
   $B9=B$BN$H$O(B, $B3F@.J,$NMWAG$,L>A0$G%"%/%;%9$G$-$k8GDjD9G[Ns$H;W$C$F$h$$(B.
   $B3F9=B$BN$OL>A0$G6hJL$5$l$k(B. $B9=B$BN$O(B, @code{struct} $BJ8$K$h$j@k8@$5$l$k(B.
   $B9=B$BN$,@k8@$5$l$k$H$-(B, asir $B$OFbIt$G9=B$BN$N$=$l$>$l$N7?$K8GM-$N<1JL(B
   $BHV9f$r$D$1$k(B.  $B$3$NHV9f$O(B, $BAH$_9~$_4X?t(B @code{struct_type} $B$K$h$j<hF@(B
   $B$G$-$k(B.
   $B$"$k7?$N9=B$BN$O(B, $BAH$_9~$_4X?t(B @code{newstruct} $B$K$h$j@8@.$5$l$k(B.
   $B9=B$BN$N3F%a%s%P$O(B, $B1i;;;R(B @code{->} $B$K$h$j%"%/%;%9$9$k(B.
   $B%a%s%P$,9=B$BN$N>l9g(B, @code{->} $B$K$h$k;XDj$OF~$l;R$K$G$-$k(B.
   \E
   
   \BEG
   A structure data type is a fixed length array and each component of the array
   is accessed by its name. Each type of structure is distinguished by its name.
   A structure data type is declared by @code{struct} statement.
   A structure object is generated by a builtin function @code{newstruct}.
   Each member of a structure is accessed by an operatator @code{->}.
   If a member of a structure is again a structure, then the specification
   by @code{->} can be nested.
   \E
   
   @example
   [1] struct rat @{num,denom@};
   0
   [2] A = newstruct(rat);
   @{0,0@}
   [3] A->num = 1;
   1
   [4] A->den = 2;
   2
   [5] A;
   @{1,2@}
   [6] struct_type(A);
   1
   @end example
   
   @table @t
   \JP @item $B;2>H(B
   \EG @item References
   @fref{newstruct}, @fref{struct_type}
   @end table
   
   \BJP
 @node $B$5$^$6$^$J<0(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node $B$5$^$6$^$J<0(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $B$5$^$6$^$J<0(B  @subsection $B$5$^$6$^$J<0(B
   \E
   \BEG
   @node various expressions,,, Writing user defined functions
   @subsection various expressions
   \E
   
 @noindent  @noindent
 $B<g$J<0$N9=@.MWAG$H$7$F$O(B, $B<!$N$h$&$J$b$N$,$"$k(B.  \JP $B<g$J<0$N9=@.MWAG$H$7$F$O(B, $B<!$N$h$&$J$b$N$,$"$k(B.
   \EG Major elements to construct expressions are the following:
   
 @itemize @bullet  @itemize @bullet
 @item  @item
 $B2C8:>h=|(B, $BQQ(B  \JP $B2C8:>h=|(B, $BQQ(B
   \EG addition, subtraction, multiplication, division, exponentiation
   @*
   \BJP
 $BQQ$O(B, @samp{^} $B$K$h$jI=$9(B. $B=|;;(B @samp{/} $B$O(B, $BBN$H$7$F$N1i;;$KMQ$$$k(B.  $BQQ$O(B, @samp{^} $B$K$h$jI=$9(B. $B=|;;(B @samp{/} $B$O(B, $BBN$H$7$F$N1i;;$KMQ$$$k(B.
 $BNc$($P(B, @code{2/3} $B$OM-M}?t$N(B @code{2/3} $B$rI=$9(B.  $BNc$($P(B, @code{2/3} $B$OM-M}?t$N(B @code{2/3} $B$rI=$9(B.
 $B@0?t=|;;(B, $BB?9`<0=|;;(B ($B>jM>$r4^$`1i;;(B) $B$K$OJLESAH$_9~$_H!?t$,MQ0U$5$l$F$$$k(B.  $B@0?t=|;;(B, $BB?9`<0=|;;(B ($B>jM>$r4^$`1i;;(B) $B$K$OJLESAH$_9~$_H!?t$,MQ0U$5$l$F$$$k(B.
   \E
   \BEG
   The exponentiation is denoted by @samp{^}. (This differs from C language.)
   Division denoted by @samp{/} is used to operate in a field, for example,
   @code{2/3} results in a rational number @code{2/3}.
   For integer division and polynomial division, both including remainder
   operation, built-in functions are provided.
   \E
   
 @example  @example
 x+1  A^2*B*afo X/3  x+1  A^2*B*afo X/3
 @end example  @end example
   
 @item  @item
 $B%$%s%G%C%/%9$D$-$NJQ?t(B  \JP $B%$%s%G%C%/%9$D$-$NJQ?t(B
   \EG programming variables with indices
   @*
   \BJP
 $B%Y%/%H%k(B, $B9TNs(B, $B%j%9%H$NMWAG$O%$%s%G%C%/%9$rMQ$$$k$3$H$K$h$j<h$j=P$;$k(B.  $B%Y%/%H%k(B, $B9TNs(B, $B%j%9%H$NMWAG$O%$%s%G%C%/%9$rMQ$$$k$3$H$K$h$j<h$j=P$;$k(B.
 $B%$%s%G%C%/%9$O(B 0 $B$+$i;O$^$k$3$H$KCm0U$9$k(B. $B<h$j=P$7$?MWAG$,%Y%/%H%k(B,  $B%$%s%G%C%/%9$O(B 0 $B$+$i;O$^$k$3$H$KCm0U$9$k(B. $B<h$j=P$7$?MWAG$,%Y%/%H%k(B,
 $B9TNs(B, $B%j%9%H$J$i(B, $B$5$i$K%$%s%G%C%/%9$r$D$1$k$3$H$bM-8z$G$"$k(B.  $B9TNs(B, $B%j%9%H$J$i(B, $B$5$i$K%$%s%G%C%/%9$r$D$1$k$3$H$bM-8z$G$"$k(B.
   \E
   \BEG
   An element of a vector, a matrix or a list can be referred to by
   indexing.
   Note that the indices begin with number 0.  When the referred element
   is again a vector, a matrix or a list, repeated indexing is also
   effective.
   \E
   
 @example  @example
 V[0] M[1][2]  V[0] M[1][2]
 @end example  @end example
   
 @item  @item
 $BHf3S1i;;(B  \JP $BHf3S1i;;(B
   \EG comparison operation
   @*
   \BJP
 $BEy$7$$(B (@samp{==}), $BEy$7$/$J$$(B (@samp{!=}), $BBg>.(B (@samp{>}, @samp{<},  $BEy$7$$(B (@samp{==}), $BEy$7$/$J$$(B (@samp{!=}), $BBg>.(B (@samp{>}, @samp{<},
 @samp{>=}, @samp{<=}) $B$N(B 2 $B9`1i;;$,$"$k(B. $B??$J$i$PM-M}?t$N(B 1, $B56$J$i$P(B  @samp{>=}, @samp{<=}) $B$N(B 2 $B9`1i;;$,$"$k(B. $B??$J$i$PM-M}?t$N(B 1, $B56$J$i$P(B
 0 $B$rCM$K;}$D(B.  0 $B$rCM$K;}$D(B.
   \E
   \BEG
   There are comparison operations
   @samp{==} for equivalence, @samp{!=} for non-equivalence,
   @samp{>}, @samp{<},@samp{>=}, and @samp{<=} for larger or smaller.
   The results of these operations are either value 1 for the truth,
   or 0 for the false.
   \E
   
 @item  @item
 $BO@M}<0(B  \JP $BO@M}<0(B
   \EG logical expression
   @*
   \BJP
 $BO@M}@Q(B (@samp{&&}), $BO@M}OB(B (@samp{||}) $B$N(B 2 $B9`1i;;$H(B, $BH]Dj(B (@samp{!})  $BO@M}@Q(B (@samp{&&}), $BO@M}OB(B (@samp{||}) $B$N(B 2 $B9`1i;;$H(B, $BH]Dj(B (@samp{!})
 $B$,MQ0U$5$l$F$$$k(B. $BCM$O$d$O$j(B 1, 0 $B$G$"$k(B.  $B$,MQ0U$5$l$F$$$k(B. $BCM$O$d$O$j(B 1, 0 $B$G$"$k(B.
   \E
   \BEG
   There are two binary logical operations
   @samp{&&} for logical @samp{conjunction}(and),
   @samp{||} for logical @samp{disjunction}(or),
   and one unary logical operation @samp{!} for logical @samp{negation}(not).
   The results of these operations are either value 1 for the truth,
   and 0 for the false.
   \E
   
 @item  @item
 $BBeF~(B  \JP $BBeF~(B
   \EG assignment
   @*
   \BJP
 $BDL>o$NBeF~$O(B @samp{=} $B$G9T$&(B. $B$3$N$[$+(B, $B;;=Q1i;;;R$HAH$_9g$o$;$F(B  $BDL>o$NBeF~$O(B @samp{=} $B$G9T$&(B. $B$3$N$[$+(B, $B;;=Q1i;;;R$HAH$_9g$o$;$F(B
 $BFC<l$JBeF~$r9T$&$3$H$b$G$-$k(B.  $BFC<l$JBeF~$r9T$&$3$H$b$G$-$k(B.
   \E
   \BEG
   Value assignment of a program variable is usually done by @samp{=}.
   There are special assignments combined with arithmetic operations.
   \E
 (@samp{+=}, @samp{-=}, @samp{*=}, @samp{/=}, @samp{^=})  (@samp{+=}, @samp{-=}, @samp{*=}, @samp{/=}, @samp{^=})
   
 @example  @example
 A = 2  A *= 3 ($B$3$l$O(B A = A*3 $B$HF1$8(B; $B$=$NB>$N1i;;;R$bF1MM(B)  \JP A = 2  A *= 3 ($B$3$l$O(B A = A*3 $B$HF1$8(B; $B$=$NB>$N1i;;;R$bF1MM(B)
   \EG A = 2  A *= 3 (the same as A = A*3; The others are alike.)
 @end example  @end example
 @item  @item
 $BH!?t8F$S=P$7(B  \JP $BH!?t8F$S=P$7(B
   \EG function call
 $BH!?t8F$S=P$7$b<0$N0l<o$G$"$k(B.  @*
   \JP $BH!?t8F$S=P$7$b<0$N0l<o$G$"$k(B.
   \EG A function call is also an expression.
 @item  @item
 @samp{++}, @samp{--}  @samp{++}, @samp{--}
   @*
 $B$3$l$i$O(B, $BJQ?t$NA08e$K$D$$$F(B, $B$=$l$>$l<!$N$h$&$JA`:n(B, $BCM$rI=$9(B.  \JP $B$3$l$i$O(B, $BJQ?t$NA08e$K$D$$$F(B, $B$=$l$>$l<!$N$h$&$JA`:n(B, $BCM$rI=$9(B.
   \BEG
   These operators are attached to or before a program variable,
   and denote special operations and values.
   \E
 @example  @example
   \BJP
 A++  $BCM$O85$N(B A $B$NCM(B, A = A+1  A++  $BCM$O85$N(B A $B$NCM(B, A = A+1
 A--  $BCM$O85$N(B A $B$NCM(B, A = A-1  A--  $BCM$O85$N(B A $B$NCM(B, A = A-1
 ++A  A = A+1, $BCM$OJQ2=8e$NCM(B  ++A  A = A+1, $BCM$OJQ2=8e$NCM(B
 --A  A = A-1, $BCM$OJQ2=8e$NCM(B  --A  A = A-1, $BCM$OJQ2=8e$NCM(B
   \E
   \BEG
   A++  the expression value is the previous value of A, and A = A+1
   A--  the expression value is the previous value of A, and A = A-1
   ++A  A = A+1, and the value is the one after increment of A
   --A  A = A-1, and the value is the one after decrement of A
   \E
 @end example  @end example
   
 @end itemize  @end itemize
   
   \BJP
 @node $B%W%j%W%m%;%C%5(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B  @node $B%W%j%W%m%;%C%5(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $B%W%j%W%m%;%C%5(B  @subsection $B%W%j%W%m%;%C%5(B
   \E
   \BEG
   @node preprocessor,,, Writing user defined functions
   @subsection preprocessor
   \E
   
 @noindent  @noindent
   \BJP
 @b{Asir} $B$N%f!<%68@8l$O(B C $B8@8l$rLO$7$?$b$N$G$"$k(B. C $B$NFCD'$H$7$F(B,  @b{Asir} $B$N%f!<%68@8l$O(B C $B8@8l$rLO$7$?$b$N$G$"$k(B. C $B$NFCD'$H$7$F(B,
 $B%W%j%W%m%;%C%5(B @code{cpp} $B$K$h$k%^%/%mE83+(B, $B%U%!%$%k$N%$%s%/%k!<%I(B  $B%W%j%W%m%;%C%5(B @code{cpp} $B$K$h$k%^%/%mE83+(B, $B%U%!%$%k$N%$%s%/%k!<%I(B
 $B$,$"$k$,(B, @b{Asir} $B$K$*$$$F$b%f!<%68@8l%U%!%$%k$NFI$_9~$_$N:](B  $B$,$"$k$,(B, @b{Asir} $B$K$*$$$F$b%f!<%68@8l%U%!%$%k$NFI$_9~$_$N:](B
 @code{cpp} $B$rDL$7$F$+$iFI$_9~$`$3$H$H$7$?(B. $B$3$l$K$h$j%f!<%68@8l(B  @code{cpp} $B$rDL$7$F$+$iFI$_9~$`$3$H$H$7$?(B. $B$3$l$K$h$j%f!<%68@8l(B
 $B%U%!%$%kCf$G(B @code{#include}, @code{#define}, @code{#if} $B$J$I$,;H$($k(B.  $B%U%!%$%kCf$G(B @code{#include}, @code{#define}, @code{#if} $B$J$I$,;H$($k(B.
   \E
   \BEG
   he @b{Asir} user language imitates C language.  A typical features of
   C language include macro expansion and file inclusion by the
   preprocessor @code{cpp}.  Also, @b{Asir} read in user program files
   through @code{cpp}.  This enables @b{Asir} user to use
   @code{#include}, @code{#define}, @code{#if} etc. in his programs.
   \E
   
 @itemize @bullet  @itemize @bullet
 @item  @item
 @code{#include}  @code{#include}
   @*
   \BJP
   UNIX $B$G$O(B $B%$%s%/%k!<%I%U%!%$%k$O(B, Asir $B$N%i%$%V%i%j%G%#%l%/%H%j(B
   ($B4D6-JQ?t(B @b{ASIR_LIBDIR} $B$G;XDj$5$l$?%G%#%l%/%H%j(B)
   $B$H(B @code{#include} $B$,=q$+$l$F$$$k%U%!%$%k$HF1$8%G%#%l%/%H%j$r%5!<%A$9$k(B.
   UNIX $B0J30$G$O(B @code{cpp} $B$KFC$K0z?t$rEO$5$J$$$?$a(B,
   @code{#include} $B$,=q$+$l$F$$$k%U%!%$%k$HF1$8%G%#%l%/%H%j$N$_$r%5!<%A$9$k(B.
   \E
   \BEG
   Include files are searched within the same directory as the file
   containing @code{#include} so that no arguments are passed to @code{cpp}.
   \E
   
 @code{cpp} $B$KFC$K0z?t$rEO$5$J$$$?$a(B, $B%$%s%/%k!<%I%U%!%$%k$O(B,  
 @code{#include} $B$,=q$+$l$F$$$k%U%!%$%k$HF1$8%G%#%l%/%H%j$G%5!<%A$5$l$k(B.  
   
 @item  @item
 @code{#define}  @code{#define}
   @*
   \JP $B$3$l$O(B, C $B$K$*$1$k$N$HA4$/F1MM$KMQ$$$k$3$H$,$G$-$k(B.
   \EG This can be used just as in C language.
   
 $B$3$l$O(B, C $B$K$*$1$k$N$HA4$/F1MM$KMQ$$$k$3$H$,$G$-$k(B.  
   
 @item  @item
 @code{#if}  @code{#if}
   @*
   \BJP
 @code{/*}, @code{*/} $B$K$h$k%3%a%s%H$OF~$l;R$K$G$-$J$$$N$G(B, $B%W%m%0%i%`(B  @code{/*}, @code{*/} $B$K$h$k%3%a%s%H$OF~$l;R$K$G$-$J$$$N$G(B, $B%W%m%0%i%`(B
 $B$NBg$-$JItJ,$r%3%a%s%H%"%&%H$9$k:]$K(B, @code{#if 0}, @code{#endif}  $B$NBg$-$JItJ,$r%3%a%s%H%"%&%H$9$k:]$K(B, @code{#if 0}, @code{#endif}
 $B$r;H$&$HJXMx$G$"$k(B.  $B$r;H$&$HJXMx$G$"$k(B.
   \E
   \BEG
   This is conveniently used to comment out a large part of a user program
   that may contain comments by @code{/*} and @code{*/},
   because such comments cannot be nested.
   \E
 @end itemize  @end itemize
   
 @noindent  @noindent
 $B<!$NNc$O(B, @samp{defs.h} $B$K$"$k%^%/%mDj5A$G$"$k(B.  \JP $B<!$NNc$O(B, @samp{defs.h} $B$K$"$k%^%/%mDj5A$G$"$k(B.
   \EG the following are the macro definitions in @samp{defs.h}.
   
 @example  @example
 #define ZERO 0  #define ZERO 0
Line 632  A--  $BCM$O85$N(B A $B$NCM(B, A = A-1
Line 1352  A--  $BCM$O85$N(B A $B$NCM(B, A = A-1
 #define MAX(a,b) ((a)>(b)?(a):(b))  #define MAX(a,b) ((a)>(b)?(a):(b))
 @end example  @end example
   
   \BJP
   @noindent
   C $B$N%W%j%W%m%;%C%5$rN.MQ$7$F$$$k$?$a(B, $B%W%j%W%m%;%C%5$O(B @code{$} $B$r@5$7$/=hM}$G$-$J$$(B.
   $B$?$H$($P(B @code{LIST} $B$,Dj5A$5$l$F$$$F$b(B
   @code{LIST$}$B$OCV49$5$l$J$$(B. @code{$} $B$NA0$K6uGr$r$*$$$F(B
   @code{LIST $} $B$H=q$+$J$$$H$$$1$J$$(B.
   \E
   \BEG
   @noindent
   Since we are utilizing the C preprocessor, it cannot properly preprocess expressions
   with @code{$}.
   For example, even if @code{LIST} is defined, @code{LIST} in the expression
   @code{LIST$} is not replaced.  Add a blank before @code{$}, i.e.,
   write as @code{LIST $} to make the proprocessor replace it properly.
   \E
   
   \BJP
   @node $B%*%W%7%g%s;XDj(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
   @subsection $B%*%W%7%g%s;XDj(B
   \E
   \BEG
   @node option,,, Writing user defined functions
   @subsection option
   \E
   
   \BJP
   $B%f!<%6Dj5A4X?t$,(B @var{N} $BJQ?t$G@k8@$5$l$?>l9g(B, $B$=$N4X?t$O(B, @var{N}
   $BJQ?t$G$N8F$S=P$7$N$_$,5v$5$l$k(B.
   \E
   \BEG
   If a user defined function is declared with @var{N} arguments,
   then the function is callable with @var{N} arguments only.
   \E
   
   @example
   [0] def factor(A) @{ return fctr(A); @}
   [1] factor(x^5-1,3);
   evalf : argument mismatch in factor()
   return to toplevel
   @end example
   
   \BJP
   $BITDj8D0z?t$N4X?t$r%f!<%68@8l$G5-=R$7$?$$>l9g(B, $B%j%9%H(B, $BG[Ns$rMQ$$$k$3$H$G(B
   $B2DG=$H$J$k$,(B, $B<!$N$h$&$J$h$jJ,$+$j$d$9$$J}K!$b2DG=$G$"$k(B.
   \E
   \BEG
   A function with indefinite number of arguments can be realized by
   using a list or an array as its argument. Another method is available
   as follows:
   \E
   
   @example
   % cat factor
   def factor(F)
   @{
       Mod = getopt(mod);
       ModType = type(Mod);
       if ( ModType == 1 ) /* 'mod' is not specified. */
           return fctr(F);
       else if ( ModType == 0 ) /* 'mod' is a number */
           return modfctr(F,Mod);
   @}
   @end example
   
   @example
   [0] load("factor")$
   [1] factor(x^5-1);
   [[1,1],[x-1,1],[x^4+x^3+x^2+x+1,1]]
   [2] factor(x^5-1|mod=11);
   [[1,1],[x+6,1],[x+2,1],[x+10,1],[x+7,1],[x+8,1]]
   @end example
   
   \BJP
   2 $BHVL\$N(B @code{factor()} $B$N8F$S=P$7$K$*$$$F(B, $B4X?tDj5A$N:]$K@k8@$5$l$?0z(B
   $B?t(B @code{x^5-1}$B$N8e$m$K(B @code{|mod=11} $B$,CV$+$l$F$$$k(B. $B$3$l$O(B, $B4X?t<B9T;~(B
   $B$K(B, @code{mod} $B$H$$$&(B keyword $B$KBP$7$F(B @code{11} $B$H$$$&CM$r3d$jEv$F$k$3$H(B
   $B$r;XDj$7$F$$$k(B. $B$3$l$r%*%W%7%g%s;XDj$H8F$V$3$H$K$9$k(B. $B$3$NCM$O(B
   @code{getopt(mod)} $B$G<h$j=P$9$3$H$,$G$-$k(B. 1 $BHVL\$N8F$S=P$7$N$h$&$K(B
   @code{mod} $B$KBP$9$k%*%W%7%g%s;XDj$,$J$$>l9g$K$O(B, @code{getopt(mod)} $B$O7?(B
   $B<1JL;R(B -1 $B$N%*%V%8%'%/%H$rJV$9(B. $B$3$l$K$h$j(B, $B;XDj$,$J$$>l9g$NF0:n$r(B if $BJ8(B
   $B$K$h$j5-=R$G$-$k(B. @samp{|} $B$N8e$m$K$O(B, $BG$0U8D$N%*%W%7%g%s$r(B, @samp{,}
   $B$G6h@Z$C$F;XDj$9$k$3$H$,$G$-$k(B.
   \E
   \BEG
   In the second call of @code{factor()}, @code{|mod=11} is placed
   after the argument @code{x^5-1}, which appears in the declaration of
   @code{factor()}. This means that the value @code{11} is assigned to
   the keyword @code{mod} when the function is executed. The value
   can be retrieved by @code{getopt(mod)}. We call such machinery
   @var{option}. If the option for @var{mod} is not specified,
   @code{getopt(mod)} returns an object whose type is -1. By this
   feature, one can describe the behaviour of the function when
   the option is not specified by @var{if} statements.
   After @samp{|} one can append any number of options seperated by @samp{,}.
   \E
   @example
   [100] xxx(1,2,x^2-1,[1,2,3]|proc=1,index=5);
   @end example
   
   \BJP
   $B$5$i$K(B, $B%*%W%7%g%s$r(B @code{key1=value1,key2=value2,...} $B$N$h$&$K(B
   @samp{,} $B$G6h@Z$C$FEO$9Be$o$j$K(B, $BFCJL$J%-!<%o!<%I(B @code{option_list}
   $B$H%*%W%7%g%s%j%9%H(B @code{[["key1",value1],["key2",value2],...]}
   $B$rMQ$$$FEO$9$3$H$b2DG=$G$"$k(B.
   \E
   \BEG
   Optinal arguments may be given as a list
   with the key word @code{option_list}
   as
   @code{option_list=[["key1",value1],["key2",value2],...]}.
   It is equivalent to pass the optional arguments as
   @code{key1=value1,key2=value2,...}.
   \E
   
   @example
   [101] dp_gr_main([x^2+y^2-1,x*y-1]|option_list=[["v",[x,y]],["order",[[x,5,y,1]]]]);
   @end example
   
   \BJP
   $BFC$K(B, $B0z?t$J$7$N(B @code{getopt()} $B$O%*%W%7%g%s%j%9%H$rJV$9$N$G(B,
   $B%*%W%7%g%s$r$H$k4X?t$+$i(B, $B%*%W%7%g%s$r$H$k4X?t$r8F$S=P$9$H$-$K$OM-MQ$G$"$k(B.
   \E
   \BEG
   Since @code{getopt()} returns an option list,
   the optional argument @code{option_list=...} is useful when
   we call functions with optional arguments from
   a function with optional arguments to pass
   the all optional parameters.
   \E
   
   @example
   % cat foo.rr
   def foo(F)
   @{
       OPTS=getopt();
       return factor(F|option_list=OPTS);
   @}
   @end example
   
   @example
   [3] load("foo.rr")$
   [4] foo(x^5-1|mod=11);
   [[1,1],[x+6,1],[x+2,1],[x+10,1],[x+7,1],[x+8,1]]
   @end example
   
   \BJP
   @node $B%b%8%e!<%k(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
   @subsection $B%b%8%e!<%k(B
   \E
   \BEG
   @node module,,, Writing user defined functions
   @subsection module
   \E
   
   \BJP
   $B%i%$%V%i%j$GDj5A$5$l$F$$$k4X?t(B, $BJQ?t$r%+%W%;%k2=$9$k;EAH$_$,(B
   $B%b%8%e!<%k(B (module) $B$G$"$k(B.
   $B$O$8$a$K%b%8%e!<%k$rMQ$$$?%W%m%0%i%`$NNc$r$"$2$h$&(B.
   \E
   \BEG
   Function names and variables in a library may be
   encapsulated by module.
   Let us see an example of using module
   \E
   
   @example
   module stack;
   
   static Sp $
   Sp = 0$
   static Ssize$
   Ssize = 100$
   static Stack $
   Stack = newvect(Ssize)$
   localf push $
   localf pop $
   
   def push(A) @{
     if (Sp >= Ssize) @{print("Warning: Stack overflow\nDiscard the top"); pop();@}
     Stack[Sp] = A;
     Sp++;
   @}
   def pop() @{
     local A;
     if (Sp <= 0) @{print("Stack underflow"); return 0;@}
     Sp--;
     A = Stack[Sp];
     return A;
   @}
   endmodule;
   
   def demo() @{
     stack.push(1);
     stack.push(2);
     print(stack.pop());
     print(stack.pop());
   @}
   @end example
   
   \BJP
   $B%b%8%e!<%k$O(B @code{module} $B%b%8%e!<%kL>(B  $B!A(B @code{endmodule}$B$G0O$`(B.
   $B%b%8%e!<%k$OF~$l;R$K$O$G$-$J$$(B.
   $B%b%8%e!<%k$NCf$@$1$G;H$&Bg0hJQ?t$O(B @code{static} $B$G@k8@$9$k(B.
   $B$3$NJQ?t$O%b%8%e!<%k$N30$+$i$O;2>H$b$G$-$J$$$7JQ99$b$G$-$J$$(B.
   @code{static} $BJQ?t$O$9$Y$F$N4X?tDj5A$NA0$K@k8@$7$J$$$H$$$1$J$$(B.
   $B%Q!<%5!<$,%o%s%Q%9$N$?$a(B, $B@k8@$N$J$$JQ?t$O<+F0E*$K6I=jJQ?t$H$_$J$5$l$k$+$i$G$"$k(B.
   $B%b%8%e!<%k$N30$NBg0hJQ?t$O(B @code{extern} $B$G@k8@$9$k(B.
   \E
   \BEG
   Module is encapsulated by the sentences
   @code{module} module name
   and
   @code{endmodule}.
   A variable of a module is declared with the key word @code{static}.
   The static variables cannot be refered nor changed out of the module,
   but it can be refered and changed in any functions in the module.
   The @code{static} variables must be declared before the definitions of functions,
   because the one-path parser of asir automatically assume variables as local variables
   if there is no declaration for them.
   A global variable which can be refered and changed in or out of the module
   is declared with the key word @code{extern}.
   \E
   
   \BJP
   $B%b%8%e!<%kFbIt$GDj5A$9$k4X?t$O(B @code{localf} $B$rMQ$$$F@k8@$7$J$$$H$$$1$J$$(B.
   $B>e$NNc$G$O(B @code{push} $B$H(B @code{pop} $B$r@k8@$7$F$$$k(B.
   $B$3$N@k8@$OI,?\$G$"$k(B.
   \E
   \BEG
   Any function defined in a module must be declared forward
   with the keyword @code{localf}.
   In the example above, @code{push} and @code{pop} are declared.
   This declaration is necessary.
   \E
   
   \BJP
   $B%b%8%e!<%k(B @code{moduleName} $B$GDj5A$5$l$?4X?t(B @code{functionName} $B$r(B
   $B%b%8%e!<%k$N30$+$i8F$V$K$O(B
        @code{moduleName.functionName($B0z?t(B1, $B0z?t(B2, ... )}
   $B$J$k7A<0$G$h$V(B.
   $B%b%8%e!<%k$NCf$+$i$O(B, $B4X?tL>$N$_$G$h$$(B.
   $B<!$NNc$G$O(B, $B%b%8%e!<%k$N30$+$i%b%8%e!<%k(B @code{stack} $B$GDj5A$5$l$?4X?t(B @code{push},
   @code{pop} $B$r8F$s$G$$$k(B.
   \E
   \BEG
   A function @code{functionName} defined in a module @code{moduleName}
   can be called by the expression
   @code{moduleName.functioName(arg1, arg2, ...)}
   out of the module.
   Inside the module, @code{moduleName.} is not necessary.
   In the example below, the functions @code{push} and @code{pop} defined
   in the module @code{stack} are called out of the module.
   \E
   
   @example
    stack.push(2);
    print( stack.pop() );
    2
   @end example
   
   \BJP
   $B%b%8%e!<%k$GMQ$$$k4X?tL>$O6I=jE*$G$"$k(B.
   $B$D$^$j%b%8%e!<%k$N30$dJL$N%b%8%e!<%k$GDj5A$5$l$F$$$k4X?tL>$HF1$8L>A0$,(B
   $BMxMQ$G$-$k(B.
   \E
   \BEG
   Any function name defined in a module is local.
   In other words, the same function name may be used out of the module
   to define a different function.
   \E
   
   \BJP
   $B%b%8%e!<%k5!G=$OBg5,LO%i%$%V%i%j$N3+H/$rA[Dj$7$F$$$k(B.
   $B%i%$%V%i%j$rI,MW$K1~$8$FJ,3d%m!<%I$9$k$K$O(B, $B4X?t(B @code{module_definedp} $B$rMQ$$$k$N$,(B
   $BJXMx$G$"$k(B.
   $B%G%^%s%I%m!<%I$O$?$H$($P<!$N$h$&$K9T$J$($PNI$$(B.
   \E
   \BEG
   The module structure of asir is introduced to develop large libraries.
   In order to load libraries on demand, the command @code{module_definedp}
   will be useful.
   The below is an example of demand loading.
   \E
   
   @example
   if (!module_definedp("stack")) load("stack.rr") $
   @end example
   
   \BJP
   asir $B$G$O6I=jJQ?t$N@k8@$OITMW$G$"$C$?(B.
   $B$7$+$7%b%8%e!<%k(B stack $B$NNc$r8+$l$PJ,$+$k$h$&$K(B, @code{local A;} $B$J$k7A<0$G(B
   $B6I=jJQ?t$r@k8@$G$-$k(B.
   $B%-!<%o!<%I(B @code{local} $B$rMQ$$$k$H(B, $B@k8@5!G=$,M-8z$H$J$k(B.
   $B@k8@5!G=$rM-8z$K$9$k$H(B, $B@k8@$5$l$F$J$$JQ?t$O%m!<%I$NCJ3,$G(B
   $B%(%i!<$r5/$3$9(B.
   $BJQ?tL>$N%?%$%W%_%9$K$h$kM=4|$7$J$$%H%i%V%k$rKI$0$K$O(B,
   $B@k8@5!G=$rM-8z$K$7$F%W%m%0%i%`$9$k$N$,$h$$(B.
   \E
   \BEG
   It is not necessary to declare local variables in asir.
   As you see in the example of the stack module,
   we may declare local variables by the key word @code{local}.
   Once this key word is used, asir requires to declare all the
   variables.
   In order to avoid some troubles to develop a large libraries,
   it is recommended to use @code{local} declarations.
   \E
   
   \BJP
   $B%b%8%e!<%kFb$N4X?t$r$=$N%b%8%e!<%k$,Dj5A$5$l$kA0$K(B
   $B8F$S=P$9$h$&$J4X?t$r=q$/$H$-$K$O(B, $B$=$N4X?t$NA0$G%b%8%e!<%k$r<!$N$h$&$K(B
   $B%W%m%H%?%$%W@k8@$7$F$*$/I,MW$,$"$k(B.
   \E
   \BEG
   When we need to call a function in a module before the module is defined,
   we must make a prototype declaration as the example below.
   \E
   
   @example
   /* Prototype declaration of the module stack */
   module stack;
   localf push $
   localf pop $
   endmodule;
   
   def demo() @{
     print("----------------");
     stack.push(1);
     print(stack.pop());
     print("---------------");
   @}
   
   module stack;
     /* The body of the module stack */
   endmodule;
   @end example
   
   \BJP
   $B%b%8%e!<%k$NCf$+$i%H%C%W%l%Y%k$GDj5A$5$l$F$$$k4X?t$r8F$V$K$O(B,
   $B2<$NNc$N$h$&$K(B @code{::} $B$rMQ$$$k(B.
   \E
   \BEG
   In order to call functions defined in the top level from the inside
   of a module, we use @code{::} as in the example below.
   \E
   @example
   def afo() @{
     S = "afo, afo";
     return S;
   @}
   module abc;
   localf foo,afo $
   
   def foo() @{
     G = ::afo();
     return G;
   @}
   def afo() @{
     return "afo, afo in abc";
   @}
   endmodule;
   end$
   
   [1200] abc.foo();
   afo, afo
   [1201] abc.afo();
   afo, afo in abc
   @end example
   
   @table @t
   \JP @item $B;2>H(B
   \EG @item References
   @fref{module_list}, @fref{module_definedp}, @fref{remove_module}.
   @end table
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.20
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>