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

Annotation of OpenXM/src/asir-doc/parts/appendix.texi, Revision 1.8

1.8     ! noro        1: @comment $OpenXM: OpenXM/src/asir-doc/parts/appendix.texi,v 1.7 2001/03/16 05:18:04 noro Exp $
1.3       noro        2: \BJP
1.1       noro        3: @node $BIUO?(B,,, Top
                      4: @appendix $BIUO?(B
1.3       noro        5: \E
                      6: \BEG
                      7: @node Appendix,,, Top
                      8: @appendix Appendix
                      9: \E
1.1       noro       10:
                     11: @menu
1.3       noro       12: \BJP
1.1       noro       13: * $BJ8K!$N>\:Y(B::
                     14: * $BE:IU$N%f!<%6Dj5AH!?t%U%!%$%k(B::
                     15: * $BF~NO%$%s%?%U%'!<%9(B::
1.6       noro       16: * $B%i%$%V%i%j%$%s%?%U%'!<%9(B::
1.1       noro       17: * $BJQ99E@(B::
                     18: * $BJ88%(B::
1.3       noro       19: \E
                     20: \BEG
                     21: * Details of syntax::
                     22: * Files of user defined functions::
                     23: * Input interfaces::
1.6       noro       24: * Library interfaces::
1.3       noro       25: * Changes::
                     26: * References::
                     27: \E
1.1       noro       28: @end menu
                     29:
1.3       noro       30: \BJP
1.1       noro       31: @node $BJ8K!$N>\:Y(B,,, $BIUO?(B
                     32: @section $BJ8K!$N>\:Y(B
1.3       noro       33: \E
                     34: \BEG
                     35: @node Details of syntax,,, Appendix
                     36: @section Details of syntax
                     37: \E
1.1       noro       38:
                     39: @example
1.3       noro       40: \BJP
                     41: <$B<0(B>:
1.1       noro       42:     @samp{(}<$B<0(B>@samp{)}
                     43:     <$B<0(B> <$BFs9`1i;;;R(B> <$B<0(B>
                     44:     @samp{+} <$B<0(B>
                     45:     @samp{-} <$B<0(B>
                     46:     <$B:8JUCM(B>
                     47:     <$B:8JUCM(B> <$BBeF~1i;;;R(B> <$B<0(B>
                     48:     <$B:8JUCM(B> @samp{++}
                     49:     <$B:8JUCM(B> @samp{--}
                     50:     @samp{++} <$B:8JUCM(B>
                     51:     @samp{--} <$B:8JUCM(B>
                     52:     @samp{!} <$B<0(B>
                     53:     <$B<0(B> @samp{?} <$B<0(B> @samp{:} <$B<0(B>
                     54:     <$BH!?t(B> @samp{(} <$B<0JB$S(B> @samp{)}
1.2       noro       55:     <$BH!?t(B> @samp{(} <$B<0JB$S(B> @samp{|} <$B%*%W%7%g%sJB$S(B> @samp{)}
1.1       noro       56:     <$BJ8;zNs(B>
                     57:     <$B;X?t%Y%/%H%k(B>
                     58:     <$B%"%H%`(B>
                     59:     <$B%j%9%H(B>
1.3       noro       60: \E
                     61: \BEG
                     62: <expression>:
                     63:     @samp{(}<expression>@samp{)}
                     64:     <expression> <binary operator> <expression>
                     65:     @samp{+} <expression>
                     66:     @samp{-} <expression>
                     67:     <left value>
                     68:     <left value> <assignment operator> <expression>
                     69:     <left value> @samp{++}
                     70:     <left value> @samp{--}
                     71:     @samp{++} <left value>
                     72:     @samp{--} <left value>
                     73:     @samp{!} <expression>
                     74:     <expression> @samp{?} <expression> @samp{:} <expression>
                     75:     <function> @samp{(} <expr list> @samp{)}
                     76:     <function> @samp{(} <expr list> @samp{|} <option list> @samp{)}
                     77:     <string>
                     78:     <exponent vector>
                     79:     <atom>
                     80:     <list>
                     81: \E
1.1       noro       82: @end example
1.3       noro       83: \JP (@xref{$B$5$^$6$^$J<0(B})
                     84: \EG (@xref{various expressions})
1.1       noro       85:
                     86: @example
1.3       noro       87: \BJP
1.1       noro       88: <$B:8JUCM(B>:
                     89:     <$BJQ?t(B> [@samp{[}<$B<0(B>@samp{]}]*
1.3       noro       90: \E
                     91: \BEG
                     92: <left value>:
                     93:     <program variable> [@samp{[}<expression>@samp{]}]*
                     94: \E
1.1       noro       95: @end example
                     96:
                     97: @example
1.3       noro       98: \BJP
1.1       noro       99: <$BFs9`1i;;;R(B>:
                    100:     @samp{+} @samp{-} @samp{*} @samp{/} @samp{%} @samp{^}($BQQ(B)
1.3       noro      101: \E
                    102: \BEG
                    103: <binary operator>:
                    104:     @samp{+} @samp{-} @samp{*} @samp{/} @samp{%} @samp{^}(exponentiation)
                    105:     @samp{==} @samp{!=} @samp{<} @samp{>} @samp{<=} @samp{>=} @samp{&&} @samp{||}
                    106: \E
1.1       noro      107:     @samp{==} @samp{!=} @samp{<} @samp{>} @samp{<=} @samp{>=} @samp{&&} @samp{||}
                    108: @end example
                    109:
                    110: @example
1.3       noro      111: \JP <$BBeF~1i;;;R(B>:
                    112: \EG <assignment operator>:
1.1       noro      113:     @samp{=} @samp{+=} @samp{-=} @samp{*=} @samp{/=} @samp{%=} @samp{^=}
                    114: @end example
                    115:
                    116: @example
1.3       noro      117: \BJP
1.1       noro      118: <$B<0JB$S(B>:
                    119:     <$B6u(B>
                    120:     <$B<0(B> [@samp{,} <$B<0(B>]*
1.3       noro      121: \E
                    122: \BEG
                    123: <expr list>:
                    124:     <empty>
                    125:     <expression> [@samp{,} <expression>]*
                    126: \E
1.1       noro      127: @end example
1.2       noro      128:
                    129: @example
1.3       noro      130: \BJP
1.2       noro      131: <$B%*%W%7%g%s(B>:
1.3       noro      132:     alphabet $B$G;O$^$kJ8;zNs(B @samp{=} <$B<0(B>
                    133: \E
                    134: \BEG
                    135: <option>:
                    136:     Character sequence beginning with an alphabetical letter @samp{=} <expression>
                    137: \E
1.2       noro      138: @end example
                    139:
                    140: @example
1.3       noro      141: \BJP
1.2       noro      142: <$B%*%W%7%g%sJB$S(B>:
                    143:     <$B%*%W%7%g%s(B>
                    144:     <$B%*%W%7%g%s(B> [@samp{,} <$B%*%W%7%g%s(B>]*
1.3       noro      145: \E
                    146: \BEG
                    147: <option list>:
                    148:     <option>
                    149:     <option> [@samp{,} <option>]*
                    150: \E
1.2       noro      151: @end example
                    152:
1.1       noro      153:
                    154: @example
1.3       noro      155: \BJP
1.1       noro      156: <$B%j%9%H(B>:
                    157:     @samp{[} <$B<0JB$S(B> @samp{]}
1.3       noro      158: \E
                    159: \BEG
                    160: <list>:
                    161:     @samp{[} <expr list> @samp{]}
                    162: \E
1.1       noro      163: @end example
                    164:
                    165: @example
1.3       noro      166: \BJP
                    167: <$BJQ?t(B>:
1.1       noro      168:     $BBgJ8;z$G;O$^$kJ8;zNs(B (X,Y,Japan $B$J$I(B)
1.3       noro      169: \E
                    170: \BEG
                    171: <program variable>:
                    172:    Sequence of alphabetical letters or numeric digits or @code{_}
                    173:    that begins with a capital alphabetical letter
                    174:    (X,Y,Japan etc.)
                    175: \E
1.1       noro      176: @end example
1.3       noro      177: \JP (@xref{$BJQ?t$*$h$SITDj85(B})
                    178: \EG (@xref{variables and indeterminates})
1.1       noro      179:
                    180: @example
1.3       noro      181: \BJP
1.1       noro      182: <$BH!?t(B>:
                    183:    $B>.J8;z$G;O$^$kJ8;zNs(B (fctr,gcd $B$J$I(B)
1.3       noro      184: \E
                    185: \BEG
                    186: <function>:
                    187:    Sequence of alphabetical letters or numeric digits or @code{_}
                    188:    that begins with a small alphabetical letter
                    189:    (fctr,gcd etc.)
                    190: \E
1.1       noro      191: @end example
                    192:
                    193: @example
1.3       noro      194: \BJP
1.1       noro      195: <$B%"%H%`(B>:
                    196:    <$BITDj85(B>
                    197:    <$B?t(B>
1.3       noro      198: \E
                    199: \BEG
                    200: <atom>:
                    201:    <indeterminate>
                    202:    <number>
                    203: \E
1.1       noro      204: @end example
                    205:
                    206: @example
1.3       noro      207: \BJP
                    208: <$BITDj85(B>:
1.1       noro      209:    $B>.J8;z$G;O$^$kJ8;zNs(B (a,bCD,c1_2 $B$J$I(B)
1.3       noro      210: \E
                    211: \BEG
                    212: <indeterminate>:
                    213:    Sequence of alphabetical letters or numeric digits or @code{_}
                    214:    that begin with a small alphabetical letter
                    215:    (a,bCD,c1_2 etc.)
                    216: \E
1.1       noro      217: @end example
1.3       noro      218: \JP (@xref{$BJQ?t$*$h$SITDj85(B})
                    219: \EG (@xref{variables and indeterminates})
1.1       noro      220:
                    221: @example
1.3       noro      222: \BJP
                    223: <$B?t(B>:
1.1       noro      224:    <$BM-M}?t(B>
                    225:    <$BIbF0>.?t(B>
                    226:    <$BBe?tE*?t(B>
                    227:    <$BJ#AG?t(B>
1.3       noro      228: \E
                    229: \BEG
                    230: <number>:
                    231:    <rational number>
                    232:    <floating point number>
                    233:    <algebraic number>
                    234:    <complex number>
                    235: \E
1.1       noro      236: @end example
1.3       noro      237: \JP (@xref{$B?t$N7?(B})
                    238: \EG (@xref{Types of numbers})
1.1       noro      239:
                    240: @example
1.3       noro      241: \JP <$BM-M}?t(B>:
                    242: \EG <rational number>:
1.1       noro      243:    0, 1, -2, 3/4
                    244: @end example
                    245:
                    246: @example
1.3       noro      247: \JP <$BIbF0>.?t(B>:
                    248: \EG <floating point number>:
1.1       noro      249:    0.0, 1.2e10
                    250: @end example
                    251:
                    252: @example
1.3       noro      253: \JP <$BBe?tE*?t(B>:
                    254: \EG <algebraic number>:
1.1       noro      255:    newalg(x^2+1), alg(0)^2+1
                    256: @end example
1.3       noro      257: \JP (@xref{$BBe?tE*?t$K4X$9$k1i;;(B})
                    258: \EG (@xref{Algebraic numbers})
1.1       noro      259:
                    260: @example
1.3       noro      261: \JP <$BJ#AG?t(B>:
                    262: \EG <complex number>:
1.1       noro      263:    1+@code{@@i}, 2.3*@code{@@i}
                    264: @end example
                    265:
                    266: @example
1.3       noro      267: \BJP
1.1       noro      268: <$BJ8;zNs(B>:
                    269:    @samp{"} $B$G0O$^$l$?J8;zNs(B
1.3       noro      270: \E
                    271: \BEG
                    272: <string>:
                    273:    character sequence enclosed by two @samp{"}'s.
                    274: \E
1.1       noro      275: @end example
                    276:
                    277: @example
1.3       noro      278: \BJP
                    279: <$B;X?t%Y%/%H%k(B>:
1.1       noro      280:    @samp{<<} <$B<0JB$S(B> @samp{>>}
1.3       noro      281: \E
                    282: \BEG
                    283: <exponent vector>:
                    284:    @samp{<<} <expr list> @samp{>>}
                    285: \E
1.1       noro      286: @end example
1.3       noro      287: \JP (@xref{$B%0%l%V%J4pDl$N7W;;(B})
                    288: \EG (@xref{Groebner basis computation})
1.1       noro      289:
                    290: @example
1.3       noro      291: \BJP
                    292: <$BJ8(B>:
1.1       noro      293:     <$B<0(B> <$B=*C<(B>
                    294:     <$BJ#J8(B>
                    295:     @samp{break} <$B=*C<(B>
                    296:     @samp{continue} <$B=*C<(B>
                    297:     @samp{return} <$B=*C<(B>
                    298:     @samp{return} <$B<0(B> <$B=*C<(B>
                    299:     @samp{if} @samp{(} <$B<0JB$S(B> @samp{)} <$BJ8(B>
                    300:     @samp{if} @samp{(} <$B<0JB$S(B> @samp{)} <$BJ8(B> @samp{else} <$BJ8(B>
                    301:     @samp{for} @samp{(} <$B<0JB$S(B> @samp{;} <$B<0JB$S(B> @samp{;} <$B<0JB$S(B> @samp{)} <$BJ8(B>
                    302:     @samp{do} <$BJ8(B> @samp{while} @samp{(} <$B<0JB$S(B> @samp{)} <$B=*C<(B>
                    303:     @samp{while} @samp{(} <$B<0JB$S(B> @samp{)} <$BJ8(B>
                    304:     @samp{def} <$BH!?t(B> @samp{(} <$B<0JB$S(B> @samp{)} @samp{@{} <$BJQ?t@k8@(B> <$BJ8JB$S(B> @samp{@}}
                    305:     @samp{end(quit)} <$B=*C<(B>
1.3       noro      306: \E
                    307: \BEG
                    308: <statement>:
                    309:     <expression> <terminator>
                    310:     <compound statement>
                    311:     @samp{break} <terminator>
                    312:     @samp{continue} <terminator>
                    313:     @samp{return} <terminator>
                    314:     @samp{return} <expression> <terminator>
                    315:     @samp{if} @samp{(} <expr list> @samp{)} <statement>
                    316:     @samp{if} @samp{(} <expr list> @samp{)} <statement> @samp{else} <statement>
                    317:     @samp{for} @samp{(} <expr list> @samp{;} <expr list> @samp{;} <expr list> @samp{)} <statement>
                    318:     @samp{do} <statement> @samp{while} @samp{(} <expr list> @samp{)} <terminator>
                    319:     @samp{while} @samp{(} <expr list> @samp{)} <statement>
                    320:     @samp{def} <function> @samp{(} <expr list> @samp{)} @samp{@{} <variable declaration> <stat list> @samp{@}}
                    321:     @samp{end(quit)} <terminator>
                    322: \E
1.1       noro      323: @end example
1.3       noro      324: \JP (@xref{$BJ8(B})
                    325: \EG (@xref{statements})
1.1       noro      326:
                    327: @example
1.3       noro      328: \JP <$B=*C<(B>:
                    329: \EG <terminator>:
1.1       noro      330:     @samp{;} @samp{$}
                    331: @end example
                    332:
                    333: @example
1.3       noro      334: \BJP
1.1       noro      335: <$BJQ?t@k8@(B>:
                    336:     [@samp{extern} <$BJQ?t(B> [@samp{,} <$BJQ?t(B>]* <$B=*C<(B>]*
1.3       noro      337: \E
                    338: \BEG
                    339: <variable declaration>:
                    340:     [@samp{extern} <program variable> [@samp{,} <program variable>]* <terminator>]*
                    341: \E
1.1       noro      342: @end example
                    343:
                    344: @example
1.3       noro      345: \BJP
1.1       noro      346: <$BJ#J8(B>:
                    347:     @samp{@{} <$BJ8JB$S(B> @samp{@}}
1.3       noro      348: \E
                    349: \BEG
                    350: <compound statement>:
                    351:     @samp{@{} <stat list> @samp{@}}
                    352: \E
1.1       noro      353: @end example
                    354:
                    355: @example
1.3       noro      356: \BJP
1.1       noro      357: <$BJ8JB$S(B>:
                    358:     [<$BJ8(B>]*
1.3       noro      359: \E
                    360: \BEG
                    361: <stat list>:
                    362:     [<statement>]*
                    363: \E
1.1       noro      364: @end example
                    365:
1.3       noro      366: \BJP
1.1       noro      367: @node $BE:IU$N%f!<%6Dj5AH!?t%U%!%$%k(B,,, $BIUO?(B
                    368: @section $BE:IU$N%f!<%6Dj5AH!?t%U%!%$%k(B
1.3       noro      369: \E
                    370: \BEG
                    371: @node Files of user defined functions,,, Appendix
                    372: @section Files of user defined functions
                    373: \E
1.1       noro      374:
                    375: @noindent
1.3       noro      376: \BJP
1.1       noro      377: $BI8=`%i%$%V%i%j%G%#%l%/%H%j(B ($B%G%U%)%k%H$G$O(B @samp{/usr/local/lib/asir}) $B$K$O(B
                    378: $B$$$/$D$+$N%f!<%6Dj5AH!?t%U%!%$%k$,$*$+$l$F$$$k(B. $B$3$l$i$N$&$A$N<g$J$b$N$K$D$$$F(B
                    379: $B@bL@$9$k(B.
1.3       noro      380: \E
                    381: \BEG
                    382: There are several files of user defined functions under the standard
                    383: library directory. (@samp{/usr/local/lib/asir} by default.)
                    384: Here, we explain some of them.
                    385: \E
1.1       noro      386:
                    387: @table @samp
                    388: @item fff
1.3       noro      389: \JP $BBgI8?tAGBN$*$h$SI8?t(B 2 $B$NM-8BBN>e$N0lJQ?tB?9`<00x?tJ,2r(B (@xref{$BM-8BBN$K4X$9$k1i;;(B})
                    390: \EG Univariate factorizer over large finite fields (@xref{Finite fields})
1.1       noro      391: @item gr
1.3       noro      392: \JP $B%0%l%V%J4pDl7W;;%Q%C%1!<%8(B.  (@xref{$B%0%l%V%J4pDl$N7W;;(B})
                    393: \EG Groebner basis package.  (@xref{Groebner basis computation})
1.1       noro      394: @item sp
1.3       noro      395: \JP $BBe?tE*?t$N1i;;$*$h$S0x?tJ,2r(B, $B:G>.J,2rBN(B. (@xref{$BBe?tE*?t$K4X$9$k1i;;(B})
                    396: \EG Operations over algebraic numbers and factorization, Splitting fields. (@xref{Algebraic numbers})
1.1       noro      397: @item alpi
                    398: @itemx bgk
                    399: @itemx cyclic
                    400: @itemx katsura
                    401: @itemx kimura
1.3       noro      402: \JP $B%0%l%V%J4pDl7W;;$K$*$$$F(B, $B%Y%s%A%^!<%/$=$NB>$GMQ$$$i$l$kNc(B.
                    403: \EG Example polynomial sets for benchmarks of Groebner basis computation.
1.1       noro      404: (@xref{katsura hkatsura cyclic hcyclic})
                    405: @item defs.h
1.3       noro      406: \JP $B$$$/$D$+$N%^%/%mDj5A(B. (@xref{$B%W%j%W%m%;%C%5(B})
                    407: \EG Macro definitions. (@xref{preprocessor})
1.1       noro      408: @item fctrtest
1.3       noro      409: \BJP
1.1       noro      410: $B@0?t>e$NB?9`<0$N0x?tJ,2r$N%F%9%H(B. REDUCE $B$N(B @samp{factor.tst} $B$*$h$S(B
                    411: $B=EJ#EY$NBg$-$$$$$/$D$+$NNc$r4^$`(B. $B$3$l$O(B, @code{load()} $B$9$k$H(B
                    412: $BD>$A$K7W;;$,;O$^$k(B. $BF~<j$7$?(B @b{Asir} $B$,@5$7$/F0:n$7$F$$$k$+$N(B
                    413: $B%F%9%H$K$b;H$&$3$H$,$G$-$k(B.
1.3       noro      414: \E
                    415: \BEG
                    416: Test program of factorization of integral polynomials.
                    417: It includes  @samp{factor.tst} of REDUCE and several examples
                    418: for large multiplicity factors.  If this file is @code{load()}'ed,
                    419: computation will begin immediately.
                    420: You may use it as a first test whether @b{Asir} at you hand runs
                    421: correctly.
                    422: \E
1.1       noro      423: @item fctrdata
1.3       noro      424: \BJP
1.1       noro      425: @samp{fctrtest} $B$G;H$o$l$F$$$kNc$r4^$`(B, $B0x?tJ,2r%F%9%HMQ$NNc(B.
1.5       noro      426: @code{Alg[]} $B$K<}$a$i$l$F$$$kNc$O(B, @code{af()} (@xref{asq af af_noalg}) $BMQ$NNc$G$"$k(B.
1.3       noro      427: \E
                    428: \BEG
                    429: This contains example polynomials for factorization.  It includes
                    430: polynomials used in @samp{fctrtest}.
                    431: Polynomials contained in vector @code{Alg[]} is for the algebraic
1.5       noro      432: factorization @code{af()} (@xref{asq af af_noalg}).
1.3       noro      433: \E
1.1       noro      434: @example
                    435: [45] load("sp")$
                    436: [84] load("fctrdata")$
                    437: [175] cputime(1)$
                    438: 0msec
                    439: [176] Alg[5];
                    440: x^9-15*x^6-87*x^3-125
                    441: 0msec
                    442: [177] af(Alg[5],[newalg(Alg[5])]);
                    443: [[1,1],[75*x^2+(10*#0^7-175*#0^4-470*#0)*x+(3*#0^8-45*#0^5-261*#0^2),1],
                    444: [75*x^2+(-10*#0^7+175*#0^4+395*#0)*x+(3*#0^8-45*#0^5-261*#0^2),1],
                    445: [25*x^2+(25*#0)*x+(#0^8-15*#0^5-87*#0^2),1],[x^2+(#0)*x+(#0^2),1],
                    446: [x+(-#0),1]]
                    447: 3.600sec + gc : 1.040sec
                    448: @end example
                    449: @item ifplot
1.3       noro      450: \BJP
1.1       noro      451: $BIA2h(B (@xref{ifplot conplot plot plotover}) $B$N$?$a$NNc(B. @code{IS[]} $B$K$OM-L>$J(B
                    452: $B6J@~$NNc(B, $BJQ?t(B @code{H, D, C, S} $B$K$O%H%i%s%W$N%O!<%H(B, $B%@%$%d(B, $B%/%i%V(B,
                    453: $B%9%Z!<%I(B ($B$i$7$-(B) $B6J@~$NNc$,F~$C$F$$$k(B.
1.3       noro      454: \E
                    455: \BEG
                    456: Examples for plotting (@xref{ifplot conplot plot plotover}).
                    457: Vector @code{IS[]} contains several famous algebraic curves.
                    458: Variables @code{H, D, C, S} contains something like the suits
                    459: (Heart, Diamond, Club, and Spade) of cards.
                    460: \E
1.1       noro      461: @item num
1.3       noro      462: \JP $B?t$K4X$9$k4JC1$J1i;;H!?t$NNc(B.
                    463: \EG Examples of simple operations on numbers.
1.1       noro      464: @item mat
1.3       noro      465: \JP $B9TNs$K4X$9$k4JC1$J1i;;H!?t$NNc(B.
                    466: \EG Examples of simple operations on matrices.
1.1       noro      467: @item ratint
1.3       noro      468: \BJP
1.1       noro      469: $BM-M}H!?t$NITDj@QJ,(B. @samp{sp}, @samp{gr} $B$,I,MW(B. @code{ratint()} $B$H$$$&(B
                    470: $BH!?t$,Dj5A$5$l$F$$$k$,(B, $B$=$NJV$97k2L$O$d$dJ#;($G$"$k(B. $BNc$G@bL@$9$k(B.
1.3       noro      471: \E
                    472: \BEG
                    473: Indefinite integration of rational functions.  For this,
                    474: files @samp{sp} and @samp{gr} is necessary.  A function @code{ratint()}
                    475: is defined.  Its returns a rather complex result.
                    476: \E
1.1       noro      477: @example
                    478: [0] load("gr")$
                    479: [45] load("sp")$
                    480: [84] load("ratint")$
                    481: [102] ratint(x^6/(x^5+x+1),x);
                    482: [1/2*x^2,
                    483: [[(#2)*log(-140*x+(-2737*#2^2+552*#2-131)),161*t#2^3-23*t#2^2+15*t#2-1],
                    484: [(#1)*log(-5*x+(-21*#1-4)),21*t#1^2+3*t#1+1]]]
                    485: @end example
1.3       noro      486: \BJP
1.1       noro      487: $B$3$NNc$G$O(B, @code{x^6/(x^5+x+1)} $B$NITDj@QJ,$N7W;;$r9T$C$F$$$k(B.
                    488: $B7k2L$O(B 2 $B$D$NMWAG$+$i$J$k%j%9%H$G(B, $BBh(B 1 $BMWAG$OITDj@QJ,$NM-M}ItJ,(B,
                    489: $BBh(B 2 $BMWAG$OBP?tItJ,$rI=$9(B. $BBP?tItJ,$O99$K%j%9%H$H$J$C$F$$$F(B, $B3FMWAG$O(B,
                    490: @code{[root*log(poly),defpoly]} $B$H$$$&7A$r$7$F$$$k(B. $B$3$l$O(B, $BITDj@QJ,$K(B
                    491: $B$*$$$F$O(B, @code{defpoly} $B$NA4$F$N:,(B @code{root} $B$KBP$7$F(B @code{root*log(poly)}
                    492: $B$r:n$j$=$l$i$rB-$79g$o$;$k$H$$$&0UL#$G$"$k(B. $B$3$3$G(B @code{poly} $B$O(B
                    493: @code{root} $B$r4^$s$G$$$F(B, @code{root} $B$rF~$lBX$($k>l9g$K$O(B @code{poly}
                    494: $B$KBP$7$F$bF1$8A`:n$r9T$&$b$N$H$9$k(B. $B$3$NA`:n$r(B, $B7k2L$NBh(B 2 $BMWAG$N(B
                    495: $B3F@.J,$KBP$7$F9T$C$F(B, $BA4$F$rB-$79g$o$;$?$b$N$,BP?tItJ,$H$J$k(B.
1.3       noro      496: \E
                    497: \BEG
                    498: In this example, indefinite integral of the rational function
                    499:  @code{x^6/(x^5+x+1)} is computed.
                    500: The result is a list which comprises two elements:
                    501: The first element is the rational part of the integral;
                    502: The second part is the logarithmic part of the integral.
                    503: The logarithmic part is again a list which comprises finite number of
                    504: elements, each of which is of form @code{[root*log(poly),defpoly]}.
                    505: This pair should be interpreted to sum up
                    506: the expression @code{root*log(poly)}
                    507: through all @b{root}'s @code{root}'s of the @code{defpoly}.
                    508: Here, @code{poly} contains @code{root}, and substitution for @code{root}
                    509: is equally applied to @code{poly}.
                    510: The logarithmic part in total is obtained by applying such
                    511: interpretation to all element pairs in the second element of the
                    512: result and then summing them up all.
                    513: \E
1.1       noro      514: @item primdec
1.3       noro      515: \BJP
1.1       noro      516: $BB?9`<0%$%G%"%k$N=`AG%$%G%"%kJ,2r$H$=$N:,4p$NAG%$%G%"%kJ,2r(B
1.4       noro      517: (@pxref{primadec primedec}).
1.3       noro      518: \E
                    519: \BEG
                    520: Primary ideal decomposition of polynomial ideals and prime compotision
1.4       noro      521: of radicals (@pxref{primadec primedec}).
                    522: \E
1.1       noro      523: @end table
                    524:
1.3       noro      525: \BJP
1.1       noro      526: @node $BF~NO%$%s%?%U%'!<%9(B,,, $BIUO?(B
                    527: @section $BF~NO%$%s%?%U%'!<%9(B
1.3       noro      528: \E
                    529: \BEG
                    530: @node Input interfaces,,, Appendix
                    531: @section Input interfaces
                    532: \E
1.1       noro      533:
1.3       noro      534: \BJP
1.7       noro      535: DOS $BHG(B, Windows $BHG$G$OF~NO%$%s%?%U%'!<%9$H(B
1.1       noro      536: $B$7$F%3%^%s%I%i%$%sJT=8$*$h$S%R%9%H%jCV$-49$($,AH$_9~$^$l$F$$$k(B. UNIX $BHG$G$O(B
                    537: $B$3$N$h$&$J5!G=$OAH$_9~$^$l$F$$$J$$$,(B, $B0J2<$G=R$Y$k$h$&$JF~NO%$%s%?%U%'!<%9(B
                    538: $B$,MQ0U$5$l$F$$$k(B. $B$3$l$i$O(B @b{Asir} $B%P%$%J%j$H$H$b$K(B ftp $B2DG=$G$"$k(B.
                    539: ftp server $B$K4X$7$F$O(B @xref{$BF~<jJ}K!(B}.
1.7       noro      540:
                    541: Windows $BHG(B @samp{asirgui.exe} $B$O(B, $BDL>o$N(B Windows $B$K$*$1$k47=,$H$O0[$J$k(B
                    542: $B7A$N%3%T!<%Z!<%9%H5!G=$rDs6!$7$F$$$k(B. Window $B>e$KI=<($5$l$F$$$kJ8;zNs(B
                    543: $B$KBP$7%^%&%9:8%\%?%s$r2!$7$J$,$i%I%i%C%0$9$k$HJ8;zNs$,A*Br$5$l$k(B.
                    544: $B%\%?%s$rN%$9$HH?E>I=<($,85$KLa$k$,(B, $B$=$NJ8;zNs$O%3%T!<%P%C%U%!$K(B
                    545: $B<h$j9~$^$l$F$$$k(B. $B%^%&%91&%\%?%s$r2!$9$H(B, $B%3%T!<%P%C%U%!Fb$NJ8;zNs$,(B
                    546: $B8=:_$N%+!<%=%k0LCV$KA^F~$5$l$k(B. $B4{$KI=<($5$l$?ItJ,$O(B readonly
                    547: $B$G$"$j(B, $B$=$NItJ,$r2~JQ$G$-$J$$$3$H$KCm0U$7$FM_$7$$(B.
1.3       noro      548: \E
                    549: \BEG
1.7       noro      550: A command line editing facility and a history
                    551: substitution facility are built-in for DOS, Windows version
1.3       noro      552: of @b{Asir}. UNIX versions of @b{Asir} do not have such built-in facilites.
                    553: Instead, the following input interfaces are prepared. This are also available
                    554: from our ftp server. As for our ftp server @xref{How to get Risa/Asir}.
1.7       noro      555:
                    556: On Windows, @samp{asirgui.exe} has a copy and paste functionality
                    557: different from Windows convention. Press the left button of the mouse
                    558: and drag the mouse cursor on a text, then the text is selected and is
                    559: highlighted.  When the button is released, highlighted text returns to
                    560: the normal state and it is saved in the copy buffer.  If the right
                    561: button is pressed, the text in the copy buffer is inserted at the
                    562: current text cursor position. Note that the existing text is read-only and
                    563: one cannot modify it.
1.3       noro      564: \E
1.1       noro      565:
                    566: @menu
                    567: * fep::
                    568: * asir.el::
                    569: @end menu
                    570:
1.3       noro      571: \JP @node fep,,, $BF~NO%$%s%?%U%'!<%9(B
                    572: \EG @node fep,,, Input interfaces
1.1       noro      573: @subsection fep
                    574:
                    575: @noindent
1.3       noro      576: \BJP
1.1       noro      577: fep $B$H$O(B, SRA $B$N2NBe;a$K$h$j3+H/$5$l$?%3%^%s%I%i%$%sJT=8(B, $B%R%9%H%jCV$-49$((B
                    578: $BMQ$NF~NO%U%m%s%H%(%s%I$G$"$k(B. $B$3$N%W%m%0%i%`$N85$G(B @samp{asir} $B$r5/F0$9$k(B
                    579: $B$3$H$K$h$j(B vi $B$"$k$$$O(B emacs $BIw$N%3%^%s%I%i%$%sJT=8$*$h$S(B csh $BIw$N%R%9%H%j(B
                    580: $BCV$-49$($,2DG=$K$J$k(B.
1.3       noro      581: \E
                    582: \BEG
                    583: Fep is a general purpose front end processor. The author is
                    584: K. Utashiro (SRA Inc.).
                    585:
                    586: Under fep,
                    587: emacs- or vi-like command line editing and csh-like history substitution are
                    588: available for UNIX commands, including @samp{asir}.
                    589: \E
1.1       noro      590: @example
                    591: % fep asir
                    592: ...
                    593: [0] fctr(x^5-1);
                    594: [[1,1],[x-1,1],[x^4+x^3+x^2+x+1,1]]
                    595: [1] !!                              /* !!+Return                      */
1.3       noro      596: \BJP
1.1       noro      597: fctr(x^5-1);                        /* $BD>A0$NF~NO$,8=$l$k$FJT=8$G$-$k(B */
                    598: ...                                 /* $BJT=8(B+Return                    */
1.3       noro      599: \E
                    600: \BEG
                    601: fctr(x^5-1);                        /* The last input appears.        */
                    602: ...                                 /* Edit+Return                    */
                    603: \E
1.1       noro      604: fctr(x^5+1);
                    605: [[1,1],[x+1,1],[x^4-x^3+x^2-x+1,1]]
                    606: @end example
                    607:
                    608: @noindent
1.3       noro      609: \BJP
1.1       noro      610: fep $B$O%U%j!<%=%U%H$G%=!<%9$,F~<j2DG=$G$"$k$,(B, $B%*%j%8%J%k$N$b$N$O(B make $B$G$-$k(B
                    611: $B5!<o(B (OS) $B$,8B$i$l$F$$$k(B. $B$$$/$D$+$N5!<o>e$GF0:n$9$k$h$&$K2f!9$,2~B$$7$?$b$N(B
                    612: $B$,(B, ftp $B$GF~<j2DG=$G$"$k(B.
1.3       noro      613: \E
                    614: \BEG
                    615: Fep is a free software and the source is available. However
                    616: machines or operating systems on which the original one can run are limited.
                    617: The modified version by us running on several unsupported environments
                    618: is available from our ftp server.
                    619: \E
1.1       noro      620:
1.3       noro      621: \JP @node asir.el,,, $BF~NO%$%s%?%U%'!<%9(B
                    622: \EG @node asir.el,,, Input interfaces
1.1       noro      623: @subsection asir.el
                    624:
                    625: @noindent
1.3       noro      626: \BJP
1.1       noro      627: @samp{asir.el} $B$O(B, @b{Asir} $B$N(B GNU Emacs $B%$%s%?%U%'!<%9$G$"$k(B ($BCx<T$O(B
                    628: $B5\Eh8w<#;a(B (@code{YVE25250@@pcvan.or.jp}).  @samp{asir.el} $B$K$*$$$F$O(B,
                    629: $BDL>o$N(B emacs $B$G2DG=$JJT=85!G=$NB>$K(B, $B%U%!%$%kL>(B, $B%3%^%s%IL>$N(B completion
                    630: $B$,<B8=$5$l$F$$$k(B.
1.3       noro      631: \E
                    632: \BEG
                    633: @samp{asir.el} is a GNU Emacs interface for @b{Asir}.
                    634: The author is Koji Miyajima (@code{YVE25250@@pcvan.or.jp}).
                    635: In @samp{asir.el}, completion of file names and command names is
                    636: realized other than the ordinary editing functions
                    637: which are available on Emacs.
                    638: \E
1.1       noro      639:
                    640: @noindent
1.3       noro      641: \BJP
1.1       noro      642: @samp{asir.el} $B$O(B PC-VAN $B$G(B
                    643: $B4{$K8x3+$5$l$F$$$k$,(B, $B:#2s$N2~D{$KH<$&JQ99$r9T$C$?$b$N$,(B, $B$d$O$j(B ftp $B$G(B
                    644: $BF~<j2DG=$G$"$k(B.
1.3       noro      645: \E
                    646: \BEG
                    647: @samp{asir.el} is distributed on PC-VAN. The version where several
                    648: changes have been made according to the current version of @b{Asir}
                    649: is available via ftp.
                    650: \E
1.1       noro      651:
                    652: @noindent
1.3       noro      653: \JP $B%;%C%H%"%C%W(B, $B;HMQJ}K!$O(B, @samp{asir.el} $B$N@hF,$K5-=R$5$l$F$$$k(B.
                    654: \BEG
                    655: The way of setting up and the usage can be found at the top of
                    656: @samp{asir.el}.
                    657: \E
1.6       noro      658:
                    659: \BJP
                    660: @node $B%i%$%V%i%j%$%s%?%U%'!<%9(B,,, $BIUO?(B
                    661: @section $B%i%$%V%i%j%$%s%?%U%'!<%9(B
                    662: \E
                    663: \BEG
                    664: @node Library interfaces,,, Appendix
                    665: @section Library interfaces
                    666: \E
                    667:
                    668: \BJP
                    669: @b{Asir} $B$NDs6!$9$k5!G=$rB>$N%W%m%0%i%`$+$i;HMQ$9$kJ}K!$H$7$F(B, @b{OpenXM} $B$K$h$k(B
                    670: $BB>$K(B, $B%i%$%V%i%j$ND>@\%j%s%/$K$h$kJ}K!$,2DG=$G$"$k(B. $B%i%$%V%i%j$O(B,
                    671: GC $B%i%$%V%i%j$G$"$k(B @samp{libasir-gc.a} $B$H$H$b$K(B @b{OpenXM}
                    672: distribution (@code{http://www.math.kobe-u.ac.jp/OpenXM}) $B$K4^$^$l$k(B.
                    673: $B8=>u$G$O(B@b{OpenXM} $B%$%s%?%U%'!<%9$N$_$,8x3+$5$l$F$$$k$?$a(B, $B0J2<$G$O(B
                    674: @b{OpenXM} $B$,%$%s%9%H!<%k$5$l$F$$$k$H2>Dj$9$k(B. @b{OpenXM} root $B%G%#%l%/%H%j$r(B
                    675: @code{$OpenXM_HOME}$B$H=q$/(B. $B%i%$%V%i%j%U%!%$%k$OA4$F(B @samp{$OpenXM_HOME/lib}
                    676: $B$K$*$+$l$F$$$k(B. $B%i%$%V%i%j$K$O0J2<$N(B 3 $B<oN`$,$"$k(B.
                    677: \E
                    678: \BEG
                    679: It is possible to link an @b{Asir} library to use the functionalities of
                    680: @b{Asir} from other programs.
                    681: The necessary libraries are included in the @b{OpenXM} distribution
1.8     ! noro      682: @ifhtml
        !           683: (<A HREF="http://www.math.kobe-u.ac.jp/OpenXM">OpenXM </A>)
        !           684: @end ifhtml
1.6       noro      685: (@code{http://www.math.kobe-u.ac.jp/OpenXM}).
                    686: At present only the @b{OpenXM} interfaces are available. Here we assume
                    687: that @b{OpenXM} is already installed. In the following
                    688: @code{$OpenXM_HOME} denotes the @b{OpenXM} root directory.
                    689: All the library files are placed in @samp{$OpenXM_HOME/lib}.
                    690: There are three kinds of libraries as follows.
                    691: \E
                    692: @itemize @bullet
                    693: @item @samp{libasir.a}
                    694: @*
                    695: \BJP
                    696: @b{PARI}, @b{X11} $B4XO"$N5!G=$r4^$^$J$$(B.
                    697: $B%j%s%/$K$O(B @samp{libasir-gc.a} $B$N$_$,I,MW(B.
                    698: \E
                    699: \BEG
                    700: It does not contain the functionalities related to @b{PARI} and @b{X11}.
                    701: Only @samp{libasir-gc.a} is necessary for linking.
                    702: \E
                    703:
                    704: @item @samp{libasir_pari.a}
                    705: @*
                    706: \BJP
                    707: @b{X11} $B4XO"$N5!G=$r4^$^$J$$(B. $B%j%s%/$K$O(B @samp{libasir-gc.a},
                    708: @samp{libpari.a} $B$,I,MW(B.
                    709: \E
                    710: \BEG
                    711: It does not contain the functionalities related to @b{X11}.
                    712: @samp{libasir-gc.a}, @samp{libpari.a} are necessary for linking.
                    713: \E
                    714:
                    715: @item @samp{libasir_pari_X.a}
                    716: @*
                    717: \BJP
                    718: $BA4$F$N5!G=$r4^$`(B. $B%j%s%/$K$O(B @samp{libasir-gc.a}, @samp{libpari.a}
                    719: $B$*$h$S(B @b{X11} $B4XO"$N%i%$%V%i%j;XDj$,I,MW(B.
                    720: \E
                    721: \BEG
                    722: All the functionalities are included. @samp{libasir-gc.a}, @samp{libpari.a}
                    723: and libraries related to @b{X11} are necessary for linking.
                    724: \E
                    725: @end itemize
                    726: \BJP
                    727: $BDs6!$5$l$F$$$k4X?t$O0J2<$NDL$j$G$"$k(B.
                    728: \E
                    729: @itemize @bullet
                    730: @item @code{int asir_ox_init(int @var{byteorder})}
                    731: @*
                    732: \BJP
                    733: $B%i%$%V%i%j$N=i4|2=(B. @var{byteorder} $B$O%a%b%j>e$X$N%P%$%J%j(B CMO $B%G!<%?(B
                    734: $B$X$NE83+J}K!$r;XDj$9$k(B. @var{byteorder} $B$,(B 0 $B$N$H$-%^%7%s8GM-$N(B byteorder
                    735: $B$rMQ$$$k(B. 1 $B$N$H$-(B network byteorder $B$rMQ$$$k(B. $B=i4|2=$K@.8y$7$?>l9g(B 0,
                    736: $B<:GT$N;~(B -1 $B$rJV$9(B.
                    737: \E
                    738: \BEG
                    739: It initializes the library.
                    740: @var{byteorder} specifies the format of binary CMO data on the memory.
                    741: If @var{byteorder} is 0, the byteorder native to the machine is used.
                    742: If @var{byteorder} is 1, the network byteorder is used. It returns
                    743: 0 if the initialization is successful, -1 otherwise.
                    744: \E
                    745:
                    746: @item @code{void asir_ox_push_cmo(void *@var{cmo})}
                    747: @*
                    748: \BJP
                    749: $B%a%b%j>e$KCV$+$l$?(B CMO $B%G!<%?$r(B @b{Asir} $B$NFbIt7A<0$KJQ49$7$F%9%?%C%/$K(B
                    750: push $B$9$k(B.
                    751: \E
                    752: \BJP
                    753: It converts CMO data pointed by @var{cmo} into an @b{Asir} object and
                    754: it pushes the object onto the stack.
                    755: \E
                    756:
                    757: @item @code{int asir_ox_peek_cmo_size()}
                    758: @*
                    759: \BJP
                    760: $B%9%?%C%/$N:G>e0L$K$"$k(B @b{Asir} $B%G!<%?$r(B CMO $B$KJQ49$7$?$H$-$N%5%$%:$rJV$9(B.
                    761: $BJQ49ITG=$J>l9g$K$O(B -1 $B$rJV$9(B.
                    762: \E
                    763: \BEG
                    764: It returns the size of the object at the top of the stack as CMO object.
                    765: It returns -1 if the object cannot be converted into CMO object.
                    766: \E
                    767:
                    768: @item @code{int asir_ox_pop_cmo(void *@var{cmo}, int @var{limit})}
                    769: @*
                    770: \BJP
                    771: $B%9%?%C%/$N:G>e0L$K$"$k(B @b{Asir} $B%G!<%?$r(B pop $B$7(B, CMO $B$KJQ49$7$F(B @var{cmo}$B$G(B
                    772: $B;X$5$l$kG[Ns$K=q$-(B, CMO $B$N%5%$%:$rJV$9(B. $B$3$N$H$-(B, CMO $B$N%5%$%:$,(B
                    773: @var{limit} $B$h$jBg$-$$>l9g$K$O(B -1 $B$rJV$9(B. @var{cmo} $B$OD9$5$,>/$J$/$H$b(B
                    774: @var{limit}$B%P%$%H$NG[Ns$r;X$9I,MW$,$"$k(B. $BJQ49$5$l$?(B CMO $B$r<}MF$G$-$k(B
                    775: $BG[Ns$ND9$5$rCN$k$?$a$K(B, @code{asir_ox_peek_cmo_size} $B$rMQ$$$k(B.
                    776: \E
                    777: \BEG
                    778: It pops an @b{Asir} object at the top of the stack and it converts
                    779: the object into CMO data. If the size of the CMO data is not greater
                    780: than @var{limit}, then the data is written in @var{cmo} and the size
                    781: is returned. Otherwise -1 is returned. The size of the array pointed
                    782: by @var{cmo} must be at least @var{limit}. In order to know the size
                    783: of converted CMO data in advance @code{asir_ox_peek_cmo_size} is called.
                    784: \E
                    785:
                    786: @item @code{void asir_ox_push_cmd(int @var{cmd})}
                    787: @*
                    788: \BJP
                    789: $B%9%?%C%/%^%7%s%3%^%s%I(B @var{cmd} $B$r<B9T$9$k(B.
                    790: \E
                    791: \BEG
                    792: It executes a stack machine command @var{cmd}.
                    793: \E
                    794:
                    795: @item @code{void asir_ox_execute_string(char *@var{str})}
                    796: @*
                    797: \BJP
                    798: @b{Asir} $B$,<B9T2DG=$JJ8;zNs(B @var{str} $B$r<B9T$7(B, $B$=$N7k2L$r%9%?%C%/$K(B push $B$9$k(B.
                    799: \E
                    800: \BEG
                    801: It evaluates @var{str} as a string written in the @b{Asir} user language.
                    802: The result is pushed onto the stack.
                    803: \E
                    804: @end itemize
                    805:
                    806: \BJP
                    807: include $B$9$Y$-(B header file $B$O(B @samp{$OpenXM_HOME/include/asir/ox.h} $B$G$"$k(B.
                    808: $B$3$N(B header file $B$K$O(B, @b{OpenXM} $B$K4X$9$kA4$F$N(B tag, command $B$NDj5A$,4^$^$l$F(B
                    809: $B$$$k(B.
                    810: $B<!$NNc(B (@samp{$OpenXM_HOME/doc/oxlib/test3.c}) $B$O>e5-4X?t$N;HMQ(B
                    811: $BK!$r<($9(B.
                    812: \E
                    813: \BEG
                    814: A program calling the above functions should include
                    815: @samp{$OpenXM_HOME/include/asir/ox.h}.
                    816: In this file all the definitions of @b{OpenXM} tags and commands.
                    817: The following example
                    818: (@samp{$OpenXM_HOME/doc/oxlib/test3.c}) illustrates the usage of
                    819: the above functions.
                    820: \E
                    821:
                    822: @example
                    823: #include <asir/ox.h>
                    824: #include <signal.h>
                    825:
                    826: main(int argc, char **argv)
                    827: @{
                    828:   char buf[BUFSIZ+1];
                    829:   int c;
                    830:   unsigned char sendbuf[BUFSIZ+10];
                    831:   unsigned char *result;
                    832:   unsigned char h[3];
                    833:   int len,i,j;
                    834:   static int result_len = 0;
                    835:   char *kwd,*bdy;
                    836:   unsigned int cmd;
                    837:
                    838:   signal(SIGINT,SIG_IGN);
                    839:   asir_ox_init(1); /* 1: network byte order; 0: native byte order */
                    840:   result_len = BUFSIZ;
                    841:   result = (void *)malloc(BUFSIZ);
                    842:   while ( 1 ) @{
                    843:     printf("Input>"); fflush(stdout);
                    844:     fgets(buf,BUFSIZ,stdin);
                    845:     for ( i = 0; buf[i] && isspace(buf[i]); i++ );
                    846:     if ( !buf[i] )
                    847:       continue;
                    848:     kwd = buf+i;
                    849:     for ( ; buf[i] && !isspace(buf[i]); i++ );
                    850:     buf[i] = 0;
                    851:     bdy = buf+i+1;
                    852:     if ( !strcmp(kwd,"asir") ) @{
                    853:       sprintf(sendbuf,"%s;",bdy);
                    854:       asir_ox_execute_string(sendbuf);
                    855:     @} else if ( !strcmp(kwd,"push") ) @{
                    856:       h[0] = 0;
                    857:       h[2] = 0;
                    858:       j = 0;
                    859:       while ( 1 ) @{
                    860:         for ( ; (c= *bdy) && isspace(c); bdy++ );
                    861:         if ( !c )
                    862:           break;
                    863:         else if ( h[0] ) @{
                    864:           h[1] = c;
                    865:           sendbuf[j++] = strtoul(h,0,16);
                    866:           h[0] = 0;
                    867:         @} else
                    868:           h[0] = c;
                    869:         bdy++;
                    870:       @}
                    871:       if ( h[0] )
                    872:         fprintf(stderr,"Number of characters is odd.\n");
                    873:       else @{
                    874:         sendbuf[j] = 0;
                    875:         asir_ox_push_cmo(sendbuf);
                    876:       @}
                    877:     @} else if ( !strcmp(kwd,"cmd") ) @{
                    878:       cmd = atoi(bdy);
                    879:       asir_ox_push_cmd(cmd);
                    880:     @} else if ( !strcmp(kwd,"pop") ) @{
                    881:       len = asir_ox_peek_cmo_size();
                    882:       if ( !len )
                    883:         continue;
                    884:       if ( len > result_len ) @{
                    885:         result = (char *)realloc(result,len);
                    886:         result_len = len;
                    887:       @}
                    888:       asir_ox_pop_cmo(result,len);
                    889:       printf("Output>"); fflush(stdout);
                    890:       printf("\n");
                    891:       for ( i = 0; i < len; ) @{
                    892:         printf("%02x ",result[i]);
                    893:         i++;
                    894:         if ( !(i%16) )
                    895:           printf("\n");
                    896:       @}
                    897:       printf("\n");
                    898:     @}
                    899:   @}
                    900: @}
                    901: @end example
                    902: \BJP
                    903: $B$3$N%W%m%0%i%`$O(B, @var{keyword} @var{body} $B$J$k(B 1 $B9T$rF~NO$H$7$F<u$1<h$j(B
                    904: @var{keyword} $B$K1~$8$F<!$N$h$&$JF0:n$r9T$&(B.
                    905: \E
                    906: \BEG
                    907: This program receives a line in the form of @var{keyword} @var{body}
                    908: as an input and it executes the following operations according to
                    909: @var{keyword}.
                    910: \E
                    911: @itemize @bullet
                    912: @item @code{asir} @var{body}
                    913: @*
                    914: \BJP
                    915: @var{body} $B$r(B @b{Asir} $B8@8l$G=q$+$l$?<0$H$_$J$7(B, $B<B9T7k2L$r%9%?%C%/$K(B push $B$9$k(B.
                    916: @code{asir_ox_execute_string()} $B$,MQ$$$i$l$k(B.
                    917: \E
                    918: \BEG
                    919: @var{body} is regarded as an expression written in the @b{Asir} user language.
                    920: The expression is evaluated and the result is pushed onto the stack.
                    921: @code{asir_ox_execute_string()} is called.
                    922: \E
                    923:
                    924: @item @code{push} @var{body}
                    925: @*
                    926: \BJP
                    927: @var{body} $B$r(B 16 $B?J?t$GI=<($5$l$?(B CMO $B%G!<%?$H$_$J$7(B, @b{Asir} $B%*%V%8%'%/%H$KJQ49(B
                    928: $B$7$F%9%?%C%/$K(B push $B$9$k(B. @code{asir_ox_push_cmo()} $B$,MQ$$$i$l$k(B.
                    929: \E
                    930: \BEG
                    931: @var{body} is regarded as a CMO object in the hexadecimal form.
                    932: The CMO object is converted into an @b{Asir} object and is pushed onto the stack.
                    933: @code{asir_ox_push_cmo()} is called.
                    934: \E
                    935:
                    936: @item @code{pop}
                    937: @*
                    938: \BJP
                    939: $B%9%?%C%/:G>e0L$N%*%V%8%'%/%H$r(B CMO $B$KJQ49$7(B, 16 $B?J?t$GI=<($9$k(B.
                    940: @code{asir_ox_peek_cmo_size()} $B$*$h$S(B @code{asir_ox_pop_cmo()} $B$,MQ$$$i$l$k(B.
                    941: \E
                    942: \BEG
                    943: The object at the top of the stack is converted into a CMO object
                    944: and it is displayed in the hexadecimal form.
                    945: @code{asir_ox_peek_cmo_size()} and @code{asir_ox_pop_cmo()} are called.
                    946: \E
                    947:
                    948: @item @code{cmd} @var{body}
                    949: @*
                    950: \BJP
                    951: @var{body} $B$r(B SM $B%3%^%s%I$H$_$J$7(B, $B<B9T$9$k(B.
                    952: @code{asir_ox_push_cmd()} $B$,MQ$$$i$l$k(B.
                    953: \E
                    954: \BEG
                    955: @var{body} is regarded as an SM command and the command is executed.
                    956: @code{asir_ox_push_cmd()} is called.
                    957: \E
                    958: @end itemize
1.1       noro      959:
1.3       noro      960: \BJP
1.1       noro      961: @node $BJQ99E@(B,,, $BIUO?(B
                    962: @section $BJQ99E@(B
1.3       noro      963: \E
                    964: \BEG
                    965: @node Changes,,, Appendix
                    966: @section Appendix
                    967: \E
1.1       noro      968:
                    969: @menu
                    970: * Version 990831::
                    971: * Version 950831::
                    972: * Version 940420::
                    973: @end menu
                    974:
1.3       noro      975: \JP @node Version 990831,,, $BJQ99E@(B
                    976: \EG @node Version 990831,,, Changes
1.1       noro      977: @subsection Version 990831
                    978:
1.3       noro      979: \BJP
1.1       noro      980: 4 $BG/$V$j$NBg2~D{(B. $B@0?t$N(B 32bit $B2=B>(B, $BCf?H$O$:$$$V$sJQ$o$C$F$$$k$b$N$N(B,
                    981: $B8+3]$1$O$=$l$[$IJQ$o$C$F$$$k$h$&$K$O8+$($J$$(B. $B$`$7$m(B, Windows $BHG$J$I$O(B,
                    982: plot $B$,;H$($J$$$?$a(B, $BB`2=$7$F$$$k(B.
                    983:
                    984: $B5lHG$N%f!<%6$,$b$C$H$bCm0U$9$Y$-E@$O(B, $B5lHG$G:n$C$?(B bsave file $B$rFI$_9~$`(B
                    985: $B>l9g$O(B @code{bload27} $B$r;H$&I,MW$,$"$k(B, $B$H$$$&E@$G$"$k(B.
1.3       noro      986: \E
                    987:
                    988: \BEG
                    989: Four years have passed since the last distribution.
                    990: Though the look and feel seem unchanged, internally there are
                    991: several changes such as 32-bit representation of bignums.
                    992: Plotting facilities are not available on Windows.
                    993:
                    994: If you have files created by @code{bsave} on the older version,
                    995: you have to use @code{bload27} to read such files.
                    996: \E
1.1       noro      997:
1.3       noro      998: \JP @node Version 950831,,, $BJQ99E@(B
                    999: \EG @node Version 950831,,, Changes
1.1       noro     1000: @subsection Version 950831
                   1001:
                   1002: @menu
1.3       noro     1003: \BJP
1.1       noro     1004: * $B%G%P%C%,(B($BJQ99(B)::
                   1005: * $BAH$_9~$_H!?t(B($BJQ99(B)::
                   1006: * $B%0%l%V%J4pDl(B($BJQ99(B)::
                   1007: * $B$=$NB>(B($BJQ99(B)::
1.3       noro     1008: \E
                   1009: \BEG
                   1010: * Debugger(Changes)::
                   1011: * Built-in functions(Changes)::
                   1012: * Groebner basis computation(Changes)::
                   1013: * Others(Changes)::
                   1014: \E
1.1       noro     1015: @end menu
                   1016:
1.3       noro     1017: \BJP
1.1       noro     1018: @node $B%G%P%C%,(B($BJQ99(B),,, Version 950831
                   1019: @subsubsection $B%G%P%C%,(B
1.3       noro     1020: \E
                   1021: \BEG
                   1022: @node Debugger(Changes),,, Version 950831
                   1023: @subsubsection Debugger
                   1024: \E
1.1       noro     1025:
                   1026: @itemize @bullet
                   1027: @item
1.3       noro     1028: \JP $BG$0U$N;~E@$K%G%P%C%0%b!<%I$KF~$l$k(B.
                   1029: \EG One can enter the debug mode anytime.
1.1       noro     1030: @item
1.3       noro     1031: \JP @code{finish} $B%3%^%s%I$NDI2C(B.
                   1032: \EG A command @code{finish} has been appended.
1.1       noro     1033: @item
1.3       noro     1034: \BJP
1.1       noro     1035: @code{up}, @code{down}, @code{frame} $B%3%^%s%I$K$h$k(B, $BG$0U$N%9%?%C%/%U%l!<%`(B
1.3       noro     1036: $B$N;2>H(B.
                   1037: \E
                   1038: \EG One can examine any stack frame with @code{up}, @code{down} and @code{frame}.
1.1       noro     1039: @item
1.3       noro     1040: \JP @code{trace} $B%3%^%s%I$NDI2C(B.
                   1041: \EG A command @code{trace} has been appended.
1.1       noro     1042: @end itemize
                   1043:
1.3       noro     1044: \BJP
1.1       noro     1045: @node $BAH$_9~$_H!?t(B($BJQ99(B),,, Version 950831
                   1046: @subsubsection $BAH$_9~$_H!?t(B
1.3       noro     1047: \E
                   1048: \BEG
                   1049: @node Built-in functions(Changes),,, Version 950831
                   1050: @subsubsection Built-in functions
                   1051: \E
1.1       noro     1052:
                   1053: @itemize @bullet
1.3       noro     1054: \BJP
1.1       noro     1055: @item
                   1056: @code{sdiv()} $B$J$I$K$*$1$k(B, $B<gJQ?t$N;XDj$N%5%]!<%H(B.
                   1057: @item
                   1058: @code{sdivm()} $B$J$I(B, $BM-8BBN>e$G$NB?9`<0=|;;$NDI2C(B.
                   1059: @item
                   1060: @code{det()}, @code{res()} $B$J$I$K$*$1$k(B, $BM-8BBN>e$G$N7W;;$N%5%]!<%H(B
                   1061: @item
                   1062: @code{vtol()} ($B%Y%/%H%k$+$i%j%9%H$X$NJQ49(B) $B$NDI2C(B.
                   1063: @item
                   1064: @code{map()} $B$NDI2C(B.
1.3       noro     1065: \E
                   1066: \BEG
                   1067: @item
                   1068: One can specify a main variable for @code{sdiv()} etc.
                   1069: @item
                   1070: Functions for polynomial division over finite fields
                   1071: such as @code{sdivm()} have been appended.
                   1072: @item
                   1073: @code{det()}, @code{res()} can produce results over finite fields.
                   1074: @item
                   1075: @code{vtol()}, conversion from a vector to a list has been appended.
                   1076: @item
                   1077: @code{map()} has been appended.
                   1078: \E
1.1       noro     1079: @end itemize
                   1080:
1.3       noro     1081: \BJP
1.1       noro     1082: @node $B%0%l%V%J4pDl(B($BJQ99(B),,, Version 950831
                   1083: @subsubsection $B%0%l%V%J4pDl(B
1.3       noro     1084: \E
                   1085: \BEG
                   1086: @node Groebner basis computation(Changes),,, Version 950831
                   1087: @subsubsection Groebner basis computation
                   1088: \E
1.1       noro     1089:
                   1090: @itemize @bullet
1.3       noro     1091: \BJP
1.1       noro     1092: @item
                   1093: $B%0%l%V%J4pDl7W;;5!G=$NAH$_9~$_H!?t2=(B.
                   1094: @item
                   1095: @code{grm()}, @code{hgrm()} $B$,(B @code{gr()}, @code{hgr()} $B$KJQ99(B.
                   1096: @item
                   1097: @code{gr()}, @code{hgr()} $B$K$*$$$F(B, $B9`=g=x$N;XDj$,I,MW$K$J$C$?(B.
                   1098: @item
                   1099: $B9`=g=x$N;XDjJ}K!$,3HD%$5$l$?(B.
                   1100: @item
                   1101: $BM-8BBN>e$N%0%l%V%J4pDl7W;;$N%5%]!<%H(B.
                   1102: @item
                   1103: $B4pDlJQ49$K$h$k<-=q<0=g=x%0%l%V%J4pDl7W;;$N%5%]!<%H(B.
                   1104: @item
                   1105: $B$$$/$D$+$N?7$7$$AH$_9~$_H!?t$NDs6!(B.
1.3       noro     1106: \E
                   1107: \BEG
                   1108: @item Functions for Groebner basis computation have been implemented
                   1109: as built-in functions.
                   1110: @item
                   1111: @code{grm()} and @code{hgrm()} have been changed to @code{gr()} and
                   1112: @code{hgr()} respectively.
                   1113: @item
                   1114: @code{gr()} and @code{hgr()} requires explicit specification of
                   1115: an ordering type.
                   1116: @item
                   1117: Extension of specification of a term ordering type.
                   1118: @item
                   1119: Groebner basis computations over finite fields.
                   1120: @item
                   1121: Lex order Groebner basis computation via a modular change of ordering algorithm.
                   1122: @item
                   1123: Several new built-in functions.
                   1124: \E
1.1       noro     1125: @end itemize
                   1126:
1.3       noro     1127: \BJP
1.1       noro     1128: @node $B$=$NB>(B($BJQ99(B),,, Version 950831
                   1129: @subsubsection $B$=$NB>(B
1.3       noro     1130: \E
                   1131: \BEG
                   1132: @node Others(Changes),,, Version 950831
                   1133: @subsubsection Others
                   1134: \E
1.1       noro     1135:
                   1136: @itemize @bullet
1.3       noro     1137: \BJP
1.1       noro     1138: @item
                   1139: $BJ,;67W;;MQ%D!<%k(B, $BH!?t$NDI2C(B.
                   1140: @item
                   1141: $BBe?tBN>e$N(B GCD $B7W;;$K$*$1$k%b%8%e%i7W;;$N1~MQ(B.
                   1142: @item
                   1143: $B%$%G%"%k$N=`AGJ,2r$N%5%]!<%H(B.
                   1144: @item
                   1145: Windows $B$X$N0\?"(B.
1.3       noro     1146: \E
                   1147: \BEG
                   1148: @item
                   1149: Implementation of tools for distributed computation.
                   1150: @item
                   1151: Application of modular computation for GCD computation over algebraic number
                   1152: fields.
                   1153: @item
                   1154: Implementation of primary decompostion of ideals.
                   1155: @item
                   1156: Porting to Windows.
                   1157: \E
1.1       noro     1158: @end itemize
                   1159:
1.3       noro     1160: \JP @node Version 940420,,, $BJQ99E@(B
                   1161: \EG @node Version 940420,,, Changes
1.1       noro     1162: @subsection Version 940420
                   1163:
                   1164: @noindent
1.3       noro     1165: \JP $B:G=i$N8x3+HG(B.
                   1166: \EG The first public verion.
1.1       noro     1167:
1.3       noro     1168: \BJP
1.1       noro     1169: @node $BJ88%(B,,, $BIUO?(B
                   1170: @section $BJ88%(B
1.3       noro     1171: \E
                   1172: \BEG
                   1173: @node References,,, Appendix
                   1174: @section References
                   1175: \E
1.1       noro     1176: @table @code
                   1177: @item [Batut et al.]
                   1178: Batut, C., Bernardi, D., Cohen, H., Olivier, M., "User's Guide to PARI-GP",
                   1179: 1993.
                   1180: @item [Becker,Weispfenning]
                   1181: Becker, T., Weispfenning, V., "Groebner Bases", Graduate Texts in Math. 141,
                   1182: Springer-Verlag, 1993.
                   1183: @item [Boehm,Weiser]
                   1184: Boehm, H., Weiser, M., "Garbage Collection in an Uncooperative
                   1185: Environment", Software Practice & Experience, September 1988, 807-820.
                   1186: @item [Gebauer,Moeller]
                   1187: Gebauer, R., Moeller, H. M., "An installation of Buchberger's algorithm",
                   1188: J. of Symbolic Computation 6, 275-286.
                   1189: @item [Giovini et al.]
                   1190: Giovini, A., Mora, T., Niesi, G., Robbiano, L., Traverso, C.,
                   1191: ""One sugar cube, please" OR Selection strategies in the Buchberger algorithm",
                   1192: Proc. ISSAC'91, 49-54.
                   1193: @item [Noro,Takeshima]
                   1194: Noro, M., Takeshima, T., "Risa/Asir -- A Computer Algebra System",
                   1195: Proc. ISSAC'92, 387-396.
                   1196: @item [Noro,Yokoyama]
1.3       noro     1197: Noro, M., Yokoyama, K., "A Modular Method to Compute the Rational Univariate
                   1198: Representation of Zero-Dimensional Ideals",
                   1199: J. Symb. Comp. 28/1 (1999), 243-263.
1.1       noro     1200: @item [Shimoyama,Yokoyama]
                   1201: Shimoyama, T., Yokoyama, K.,
                   1202: "Localization and primary decomposition of polynomial ideals",
1.3       noro     1203: J. Symb. Comp. 22 (1996), 247-277.
                   1204: @item [Shoup]
                   1205: Shoup, V., "A new polynomial factorization algorithm and its implementation",
                   1206: J. Symb. Comp. 20 (1995), 364-397.
1.1       noro     1207: @item [Traverso]
                   1208: Traverso, C., "Groebner trace algorithms", Proc. ISSAC '88(LNCS 358), 125-138.
1.3       noro     1209: @item [Weber]
                   1210: Weber, K., "The accelerated Integer GCD Algorithm", ACM TOMS, 21, 1(1995), 111-122.
1.1       noro     1211: @end table
                   1212:

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