[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.12 and 1.20

version 1.12, 2003/12/18 10:26:20 version 1.20, 2020/09/08 09:16:57
Line 1 
Line 1 
 @comment $OpenXM: OpenXM/src/asir-doc/parts/asir.texi,v 1.11 2003/12/01 02:13:38 takayama Exp $  @comment $OpenXM: OpenXM/src/asir-doc/parts/asir.texi,v 1.19 2014/03/11 01:46:19 takayama Exp $
 \BJP  \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
Line 227  Use of lists enables to write programs more easily, sh
Line 227  Use of lists enables to write programs more easily, sh
 comprehensible than use of structure like C programs.  comprehensible than use of structure like C programs.
 \E  \E
   
   \BJP
 @item  @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.  \JP $B%f!<%6Dj5AH!?t$K$*$1$k%*%W%7%g%s;XDj(B.
 \EG Options can be specified in calling user defined functions.  \EG Options can be specified in calling user defined functions.
   
Line 236  comprehensible than use of structure like C programs.
Line 242  comprehensible than use of structure like C programs.
 @end itemize  @end itemize
   
 \BJP  \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  \E
Line 376  each element is again a vector which contains
Line 402  each element is again a vector which contains
 ${_I}C_J$  ${_I}C_J$
 @end tex  @end tex
 @end iftex  @end iftex
 @ifinfo  @ifnottex
 ICJ  ICJ
 @end ifinfo  @end ifnottex
 \JP $B$rMWAG$H$9$kG[Ns$G$"$k(B.  \JP $B$rMWAG$H$9$kG[Ns$G$"$k(B.
 \EG as its elements.  \EG as its elements.
   
Line 461  All the program variables are initialized to the value
Line 487  All the program variables are initialized to the value
 \BJP  \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$^$?$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  \E
Line 484  x
Line 509  x
 x^2+x+1  x^2+x+1
 [5] A='Dx'*(x-1)+x*y-y;  [5] A='Dx'*(x-1)+x*y-y;
 (y+Dx)*x-y-Dx  (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
   
Line 1251  through @code{cpp}.  This enables @b{Asir} user to use
Line 1279  through @code{cpp}.  This enables @b{Asir} user to use
 @code{#include}  @code{#include}
 @*  @*
 \BJP  \BJP
 @code{cpp} $B$KFC$K0z?t$rEO$5$J$$$?$a(B, $B%$%s%/%k!<%I%U%!%$%k$O(B,  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
 @code{#include} $B$,=q$+$l$F$$$k%U%!%$%k$HF1$8%G%#%l%/%H%j$G%5!<%A$5$l$k(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  \E
 \BEG  \BEG
 Include files are searched within the same directory as the file  Include files are searched within the same directory as the file
Line 1420  After @samp{|} one can append any number of options se
Line 1451  After @samp{|} one can append any number of options se
 [100] xxx(1,2,x^2-1,[1,2,3]|proc=1,index=5);  [100] xxx(1,2,x^2-1,[1,2,3]|proc=1,index=5);
 @end example  @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  \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  @node $B%b%8%e!<%k(B,,, $B%f!<%6Dj5AH!?t$N=q$-J}(B
 @subsection $B%b%8%e!<%k(B  @subsection $B%b%8%e!<%k(B
 \E  \E
Line 1480  def demo() @{
Line 1556  def demo() @{
 $B%b%8%e!<%k$OF~$l;R$K$O$G$-$J$$(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%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.  $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.  $B%b%8%e!<%k$N30$NBg0hJQ?t$O(B @code{extern} $B$G@k8@$9$k(B.
 \E  \E
 \BEG  \BEG
Line 1490  and
Line 1568  and
 A variable of a module is declared with the key word @code{static}.  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,  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.  but it can be refered and changed in any functions in the module.
 A global variable which can be refered and changed at any place  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}.  is declared with the key word @code{extern}.
 \E  \E
   
Line 1556  The below is an example of demand loading.
Line 1637  The below is an example of demand loading.
 \E  \E
   
 @example  @example
 if (!module_definep("stack")) load("stack.rr") $  if (!module_definedp("stack")) load("stack.rr") $
 @end example  @end example
   
 \BJP  \BJP
Line 1606  def demo() @{
Line 1687  def demo() @{
 module stack;  module stack;
   /* The body of the module stack */    /* The body of the module stack */
 endmodule;  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  @end example
   
 @table @t  @table @t
Legend:
Removed from v.1.12  
changed lines
  Added in v.1.20
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>