=================================================================== RCS file: /home/cvs/OpenXM/src/asir-doc/parts/asir.texi,v retrieving revision 1.1.1.1 retrieving revision 1.19 diff -u -p -r1.1.1.1 -r1.19 --- OpenXM/src/asir-doc/parts/asir.texi 1999/12/08 05:47:44 1.1.1.1 +++ OpenXM/src/asir-doc/parts/asir.texi 2014/03/11 01:46:19 1.19 @@ -1,35 +1,83 @@ +@comment $OpenXM: OpenXM/src/asir-doc/parts/asir.texi,v 1.18 2005/07/25 12:23:05 takayama Exp $ +\BJP @node $B%f!<%68@8l(B Asir,,, Top @chapter $B%f!<%68@8l(B Asir +\E +\BEG +@node User language Asir,,, Top +@chapter User language @b{Asir} +\E @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%$%kF~=PNO$r9T$&$b$N(B, $B$"$k$$$O?t<0$N0lIt$r]<+?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 $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 [0] A = 1; @@ -43,21 +91,51 @@ @end example @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. +@* $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 $Bl9g(B, $BH!?tFb$N$=$NJQ?t$bBg0hJQ?t(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 -@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 @example @@ -77,43 +155,123 @@ end$ @end example @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$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%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 -@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 -$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 @noindent -$B0J>e$O@)8B$G$"$k$,(B, $B3HD%$H$7$F$Oe$O@)8B$G$"$k$,(B, $B3HD%$H$7$F$Oo$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 -$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, 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 +\BJP +@noindent +Asir $B$G$O@\=q$/>l9g$KHf3S$7$F%W%m%0%i%`$,C;$/(B, $BF * return $BJ8(B:: * if $BJ8(B:: * $B%k!<%W(B break return continue:: +* $B9=B$BNDj5A(B:: * $B$5$^$6$^$J<0(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 +\BJP @node $B%f!<%6Dj5AH!?t(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B @subsection $B%f!<%6Dj5AH!?t(B +\E +\BEG +@node User defined functions,,, Writing user defined functions +@subsection User defined functions +\E @noindent +\BJP $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. $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$,(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 afo() redefined. @end example @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$r8F$S=P$7$F$$$F$b(B, $BDj5A;~$K$O%(%i!<$K$J$i$J$$(B. $Bl9g$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 @tex /* $X!$ */ @@ -158,7 +361,8 @@ def f(X) @{ @} @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 def c(N) @@ -171,11 +375,28 @@ def c(N) @} return A; @} + +@tex +/* $A+B$ */ +@end tex + +def add(A,B) +"add two numbers." +@{ + return A+B; +@} @end example @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. @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 @tex ${_I}C_J$ @@ -184,28 +405,75 @@ ${_I}C_J$ @ifinfo ICJ @end ifinfo -$B$rMWAG$H$9$kG[Ns$G$"$k(B. +\JP $B$rMWAG$H$9$kG[Ns$G$"$k(B. +\EG as its elements. @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 $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 @subsection $BJQ?t$*$h$SITDj85(B +\E @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 $B6hJL$7$F$$$k(B. +\E +\BEG +@node variables and indeterminates,,, Writing user defined functions +@subsection variables and indeterminates +\E @table @b +\BJP @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 +\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 $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$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. +\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 [0] X^2+X+1; @@ -216,23 +484,45 @@ ICJ 7 @end example +\BJP @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 - -$BITDj85$H$O(B, $BB?9`<04D$r9=@.$9$k:]$KE:2C$5$l$kJQ?t$r$$$&(B. @b{Asir} $B$K(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 $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. +\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 [3] X=x; x [4] 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 table +\BJP @node $B0z?t(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B @subsection $B0z?t(B +\E +\BEG +@node parameters and arguments,,, Writing user defined functions +@subsection parameters and arguments +\E @example def sum(N) @{ @@ -243,6 +533,7 @@ def sum(N) @{ @end example @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 $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, @@ -252,6 +543,36 @@ 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 $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. +\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 def clear_vector(M) @{ @@ -263,16 +584,38 @@ def clear_vector(M) @{ @end example @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$^$?(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. $Bl9g$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. +\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 @subsection $B%3%a%s%H(B +\E +\BEG +@node comments,,, Writing user defined functions +@subsection comments +\E @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 /* @@ -283,11 +626,22 @@ def afo(X) @{ @end example @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. @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 $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 #if 0 @@ -297,10 +651,17 @@ def bfo(X) @{ #endif @end example +\BJP @node $BJ8(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B @subsection $BJ8(B +\E +\BEG +@node statements,,, Writing user defined functions +@subsection statements +\E @noindent +\BJP @b{Asir} $B$N%f!<%6H!?t$O(B, @example @@ -310,25 +671,59 @@ def $BL>A0(B($B0z?t(B,$B0z?t(B,...,$B0z?t(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 @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%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, +\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 S = sum(N); @end example @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$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$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 $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 if ( I == 0 ) @{ @@ -339,261 +734,586 @@ if ( I == 0 ) @{ @end example @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$,4{$KJ8$H$J$C$F$$$F(B, @code{if} $BJ8$NMW@A$rK~$?$7$F$$$k$+$i$G(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 @subsection @code{return} $BJ8(B +\E +\BEG +@node return statement,,, Writing user defined functions +@subsection @code{return} statement +\E @noindent -@code{return} $BJ8$O(B, +\JP @code{return} $BJ8$O(B, +\EG There are two forms of @code{return} statement. @example -return $B<0(B; +\JP return $B<0(B; +\EG return expression; return; @end example @noindent +\BJP $B$N(B 2 $B$D$N7A<0$,$"$k(B. $B$$$:$l$bH!?t$+$iH4$1$k$?$a$NJ8$G$"$k(B. $BA0l9g$KCm0U$rMW$9$k(B. $Bl9g(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$9$J$o$A(B, 2 $BC$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, +\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 +\BJP if ( $B<0(B ) @{ if ( $B<0(B ) $BJ8(B else $BJ8(B @} +\E +\BEG +if ( expression1 ) @{ + if ( expression2 ) statement1 else statement2 +@} +\E @end example @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 +\BJP if ( $B<0(B ) @{ if ( $B<0(B ) $BJ8(B @} else $BJ8(B +\E +\BEG +if ( expression1 ) @{ + if ( expression2 ) statement1 +@} else + statement2 +\E @end example @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$$$H2A$7$F(B, $B$=$NCM$,(B 0 $B$G$J$$8B$j(B $BJ8(B $B$rr7o<0$K$h$kH=Dj$r9T$&=j$,(B @code{while} $BJ8(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 @noindent +\BJP $B%k!<%W$rH4$1=P$9r7o<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 +\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} $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 @subsection $B$5$^$6$^$J<0(B +\E +\BEG +@node various expressions,,, Writing user defined functions +@subsection various expressions +\E @noindent -$Bh=|(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. $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. +\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 x+1 A^2*B*afo X/3 @end example @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.(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 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 -$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{!}) $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 -$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 $BFC$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 @item -$BH!?t8F$S=P$7(B - -$BH!?t8F$S=P$7$b<0$N0l$l$l(b)?(a):(b)) @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, $Bl9g$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$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%?%$%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$rH(B +\EG @item References +@fref{module_list}, @fref{module_definedp}, @fref{remove_module}. +@end table