[BACK]Return to usage.sm1 CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / Kan

Annotation of OpenXM/src/kan96xx/Kan/usage.sm1, Revision 1.12

1.12    ! takayama    1: %% $OpenXM: OpenXM/src/kan96xx/Kan/usage.sm1,v 1.11 2004/09/17 00:47:09 takayama Exp $
1.1       maekawa     2: %% usage.sm1
                      3: %%  [(key word)
                      4: %%    [(   )
                      5: %%     (   )
                      6: %%    ]
                      7: %%   ] putUsages
                      8: [(putUsages)
                      9:  [$[(key word) [(explanation line 1) (explanation line 2) ... ]] putUsages$ ]
                     10: ] putUsages
                     11:
                     12: [(;)
                     13:  [(Output the prompt sm1>)]
                     14: ] putUsages
                     15:
                     16: [(::)
                     17:  [(Pop the top of the stack and print it.)]
                     18: ] putUsages
                     19:
                     20: [(Libraries)
                     21:  [
                     22:   (Doc/appell.sm1   : It generates Appell differential equations.)
                     23:   (Doc/bfunction.sm1: Computing the b-function of a given polynomial)
                     24:   (                   by using Groebner basis. Written by T.Oaku.)
                     25:   (Doc/factor-a.sm1: A sample interface to factor polynomials by risa/asir.)
                     26:   (Doc/gkz.sm1     : It generates GKZ systems for given A and b.)
                     27:   (Doc/hol.sm1     : Basic package for holonomic systems. Holonomic rank,)
                     28:   (                  characteristic ideal, singular locus.)
                     29:   (Doc/resol0.sm1  : Constructing Schreyer resolutions. tower.sm1, tower-sugar.sm1)
                     30:   (Doc/rest0.sm1   : Computing the restriction (inverse image) as a complex.)
                     31:   (                  This package is under developement by T.Oaku.)
                     32:   (                  cf. restall_s.sm1, resol0.sm1)
                     33:  ]
                     34: ] putUsages
                     35: /Loadall {
                     36:    [(parse) (bfunction.sm1) pushfile] extension
                     37:    [(parse) (hol.sm1) pushfile] extension
                     38:    [(parse) (gkz.sm1) pushfile] extension
                     39:    [(parse) (appell.sm1)pushfile] extension
                     40:    [(parse) (resol0.sm1)pushfile] extension
                     41: } def
                     42: [(Loadall)
                     43:  [(Loadall loads the packages  bfunction.sm1, hol.sm1, gkz.sm1, appell.sm1,)
                     44:   (resol0.sm1)
                     45: ]] putUsages
                     46:
                     47: [(Version)
                     48:  [(Packages must be loaded in a proper version of kan/sm1.)
                     49:   (It can be checked as follows.)
                     50:   (Example:  )
                     51:   (   /factor-a.version (2.981101) def)
                     52:   (   factor-a.version [(Version)] system_variable gt )
                     53:   $   { (This package requires the latest version of kan/sm1) message$
                     54:   $     (Please get it from http://www.math.kobe-u.ac.jp/KAN) message$
                     55:   $     error$
                     56:   $   } { } ifelse$
                     57: ]]putUsages
                     58:
                     59:
                     60: [(bugs)
                     61:  [(All known bugs are fixed.)
                     62:  ]
                     63: ] putUsages
                     64:
                     65: [(factor)
                     66:  [(Load Doc/factor-a.sm1, then factorization can be computed by invoking )
                     67:   (asir, of which ftp cite is at http://www.math.kobe-u.ac.jp)
                     68:  ]
                     69: ] putUsages
                     70:
                     71:
                     72: [(message)
                     73:  [ (string message)
                     74:    (Output the string to the screen with the newline.)
                     75:    (cf. messagen.)
                     76:    $Example:  (Hello world) message$
                     77:  ]
                     78: ] putUsages
                     79:
                     80: [(messagen)
                     81:  [ (string messagen)
                     82:    (Output the string to the screen without the newline.)
                     83:    (cf. message.)
                     84:    $Example:  (Hello world) messagen$
                     85:  ]
                     86: ] putUsages
                     87:
                     88: [(ring_of_polynomials)
                     89:  [ (string ring_of_polynomials)
                     90:    (This command is used to define a ring of polynomials with the macros)
                     91:    (define_ring, weight_vector and elimination_order.)
                     92:    (The user cannot use the variable names h, e, H and E.)
                     93:    (cf. show_ring, system_variable --- CurrentRing)
                     94:    (    print_switch_status, switch_function)
                     95:    (Example: [(x,y,z) ring_of_polynomials (x,y) elimination_order 0] define_ring)
                     96:  ]
                     97: ] putUsages
                     98:
                     99: [(ring_of_differential_operators)
                    100:  [ (string ring_of_differential_operators)
                    101:    (This command is used to define a ring of differential operators )
                    102:    (with the macros define_ring, weight_vector and elimination_order.)
                    103:    (The user cannot use the variable names h, e, H and E.)
                    104:    (cf. show_ring, system_variable --- CurrentRing)
                    105:    (    print_switch_status, switch_function)
1.5       takayama  106:    (Example: [(x,y) ring_of_differential_operators [[(Dx) 1 (Dy) 1]])
                    107:    (           weight_vector 0] define_ring)
                    108:    (   Define the ring of differential operators Q<x,y,Dx,Dy> with the order)
                    109:    (   obtained by refining the partial order defined by the weight vector)
                    110:    (   [x,y,Dx,Dy] = [0,0,1,1] )
                    111:    (Example: [(x,y) ring_of_differential_operators 0 [(weightedHomogenization) 1]])
1.6       takayama  112:    (          define_ring )
                    113:    (Example: [(x,y) ring_of_differential_operators [[(x) -1 (Dx) 1]] weight_vector)
1.7       takayama  114:    (          0 [(degreeShift) [[1 0 1]]] ])
1.5       takayama  115:    (          define_ring )
1.1       maekawa   116:    (Example: [(x,y,z) ring_of_differential_operators (Dx,Dy) elimination_order 0] define_ring)
                    117:    (         Dx,Dy, and Dz are corresponding differential operators to the )
                    118:    (         space variables x, y and z.)
                    119:  ]
                    120: ] putUsages
                    121:
                    122: [(ring_of_difference_operators)
                    123:  [ (string ring_of_difference_operators)
1.4       takayama  124:    (!!! OBSOLETE !!!)
1.1       maekawa   125:    (  )
                    126:    (This command has not been maintained since 1996. So, there may be)
                    127:    (troubles if it is used with new features of kan/sm1.)
                    128:    (  )
                    129:    (This command is used to define a ring of difference operators )
                    130:    (with the macros define_ring, weight_vector and elimination_order.)
                    131:    (The user cannot use the variable names h, e, H and E.)
                    132:    (cf. show_ring, system_variable --- CurrentRing)
                    133:    (    print_switch_status, switch_function)
                    134:    (Example: [(x,y,z) ring_of_difference_operators (Ex,Ey) elimination_order 0] define_ring)
                    135:    (         Ex,Ey, and Ez are corresponding difference operators to the )
                    136:    (         space variables x, y and z ( Ex x = (x+1) Ex).)
                    137:  ]
                    138: ] putUsages
                    139:
                    140:
                    141: [(ring_of_q_difference_operators)
                    142:  [ (string ring_of_q_difference_operators)
                    143:    (  )
                    144:    (This command has not been maintained since 1996. So, there may be)
                    145:    (troubles if it is used with new features of kan/sm1.)
                    146:    (  )
                    147:    (This command is used to define a ring of q-difference operators )
                    148:    (with the macros define_qring, weight_vector and elimination_order.)
                    149:    (Note that you should use this macro with define_qring instead of)
                    150:    (define_ring.)
                    151:    (The user cannot use the variable names h, e, q and E.)
                    152:    (cf. show_ring, system_variable --- CurrentRing)
                    153:    (    print_switch_status, switch_function)
                    154:    (Example: [(x,y,z) ring_of_q_difference_operators (Qx,Qy) elimination_order 0] define_qring)
                    155:    (         Qx,Qy, and Qz are corresponding q-difference operators to the )
                    156:    (         space variables x, y and z ( Qx x = (q) x Q).)
                    157:  ]
                    158: ] putUsages
                    159:
1.4       takayama  160: [(ring_of_differential_difference_operators)
                    161:  [ ([string1 string2]  ring_of_differential_difference operators)
                    162:    (This command is used to define a ring of differential-difference operators )
                    163:    (with the macros define_ring, weight_vector and elimination_order.)
                    164:    (string1 is a set of variables for differential operators.)
                    165:    (string2 is a set of variables for difference operators.)
                    166:    (The user cannot use the variable names h, e, H and E.)
                    167:    (cf. show_ring, system_variable --- CurrentRing)
                    168:    (    print_switch_status, switch_function)
                    169:    (Example: [[(x,y) (s)] ring_of_differential_difference_operators )
                    170:    (          [[(Es) 1] [(s) 1]] weight_vector 0] define_ring)
                    171:    (         Dx and Dy are corresponding differential operators to the )
                    172:    (         space variables x and y.  Try show_ring to see the commutation)
                    173:    (         relations.)
                    174:  ]
                    175: ] putUsages
1.1       maekawa   176:
                    177: [(define_ring)
                    178:   [( [varlist ring_of_??? order characteristic options] define_ring)
                    179:    ( Pointer to the ring.)
                    180:    (Example: [(x,y,z) ring_of_polynomials [[(x) 100 (y) 10 (z) 1]] weight_vector)
                    181:    (          11] define_qring )
                    182:    (Example: [(x,y) ring_of_polynomials [[(x) 1]] weight_vector 0 ] define_ring)
                    183:    (         /R set)
                    184:    (cf. define_qring, set_up_ring@ <coefficient ring>)
                    185:    (    <<ring_of_???>> ring_of_polynomials, ring_of_differential_operators, )
                    186:    (    ring_of_difference_operators)
                    187:    (    <<order>> elimination_order, weight_vector)
1.8       takayama  188:    (    ring_def,ring , << __ >>)
1.1       maekawa   189:   ]
                    190: ] putUsages
                    191:
                    192:
                    193: [(.)
                    194:  [(string . polynomial)
                    195:   (Parse the string as a polynomial in the current ring and put it on the stack)
                    196:   (Example ( (x+2)^3 ) .)
                    197:  ]
                    198: ] putUsages
                    199:
                    200: [(evenQ)
                    201:  [ (number evenQ bool)
                    202:  ]
                    203: ] putUsages
                    204:
                    205: [(reverse)
                    206:  [ (array reverse reversed_array)
                    207:  ]
                    208: ] putUsages
                    209:
                    210: [(memberQ)
                    211:  [(element array(list) memberQ bool)
                    212:  ]
                    213: ] putUsages
                    214:
                    215: [(transpose)
                    216:  [( matrix transpose transposed_matrix)
                    217:  ]
                    218: ] putUsages
                    219:
                    220: [(timer)
                    221:  [( { codes } timer )
                    222:   (It outputs the execution time to execute << codes >>.)
                    223:   (If you type in ctrl-C while you are executing this macro,)
                    224:   (you need to type in set_timer after you type in ctrl-C to reset)
                    225:   (the timer.)
                    226: ]] putUsages
                    227:
                    228: [(complement)
                    229:  [( set universal_set complement complement_set)
                    230:   (Example: [1 2] [3 4 1 2 5] complement ::)
                    231:  ]
                    232: ] putUsages
                    233:
                    234: [(pushVariables)
                    235:  [ (varlist pushVariables pushed-variables)
                    236:    (The macro is used to define local variables in a macro.)
                    237:    (Example : /foo {                     )
                    238:    (           /arg1 set                 )
                    239:    (          [/abc /cd] pushVariables   )
                    240:    (          [ /abc arg1 def            )
                    241:    (            /cd abc 1 add def )
                    242:    (            /arg1 cd def )
                    243:    (          ] pop                      )
                    244:    (          popVariables)
                    245:    (          arg1  )
                    246:    (          } def )
                    247:    (  10 foo ::    returns 11 )
                    248:    (    In the example, abc and cd are local variables.)
                    249:  ]
                    250: ] putUsages
                    251:
                    252:
                    253:
                    254: /@@@.global.usage1
                    255:  [(@@@. is the prefix for the global control variables and global functions.)
                    256:   (@@@.quiet   :  1 ---> quiet mode,  0 ---> not. cf. sm1 -q)
                    257:   (@@@.esymbol : (e_) is the standard value. It is used to express)
                    258:   (              vectors internally. cf. fromVectors, toVectors)
                    259:   (@@@.Dsymbol :  (D) is the standard value for differential operator.)
                    260:   (                cf. ring_of_differential_operators)
                    261:   (@@@.diffEsymbol :  (E) is the standard value for difference operator.)
                    262:   (                cf. ring_of_difference_operators)
                    263:   (@@@.Qsymbol :  (Q) is the standard value for q-difference operator.)
                    264:   (                cf. ring_of_qdifference_operators)
                    265:  ]
                    266: def
                    267: [(@@@.quiet)  @@@.global.usage1] putUsages
                    268: [(@@@.Dsymbol)  @@@.global.usage1] putUsages
                    269: [(@@@.diffEsymbol)  @@@.global.usage1] putUsages
                    270: [(@@@.Qsymbol)  @@@.global.usage1] putUsages
                    271: [(@@@.esymbol)  @@@.global.usage1] putUsages
                    272:
                    273: [(join)
                    274:  [(list1 list2 join list3)
                    275:   (Ex.  [1 2] [3 [4 (ab)]] join  [1 2 3 [4 (ab)]])
1.9       takayama  276:   (Note: Join should use for arrays. It works for list too,)
                    277:   (      but it does not copy cells. cf. cons)
                    278:   (      So, it might generate looped lists or destroy other lists.)
1.1       maekawa   279:  ]
                    280: ] putUsages
                    281:
                    282: [(not)
                    283:  [(int not int)
                    284:   (1 not 0)
                    285:   (0 not 1)
                    286:  ]
                    287: ] putUsages
                    288:
                    289: [(append)
                    290:  [(list1 obj2 append list3)
                    291:   (Ex.  [1 2]  3 append  [1 2 3])
                    292:  ]
                    293: ] putUsages
                    294:
                    295: [(null)
                    296:  [(<<null>> returns null object)]
                    297: ] putUsages
                    298:
                    299: [(oxasir)
                    300:  [(ox_asir is an asir server which is complient to open xxx protocol.)
                    301:   (This module is necessary for efficient execution factorization )
                    302:   (of b-functions in annfs, deRham.  cf. lib/oxasir.sm1)
                    303:   (ox_asir has not yet been put on the ftp cite. 12/17, 1998.)
                    304:  ]
                    305: ] putUsages
                    306:
                    307: [(toVectors)
                    308:  [(obj toVectors vec)
                    309:   (Convert the internal expression of vector into the array <<vec>>.)
                    310:   (obj can be  [n [g1 ... gm]] where n is the length of the vector.)
1.3       takayama  311:   $cf. [(toe_) array_of_poly] gbext $
1.1       maekawa   312:   $Example 1: [(x) ring_of_polynomials 0] define_ring  $
                    313:   $           (e_ + 2).  toVectors :: $
                    314:   (        --->  [2  , 1] )
                    315:   (Example 2: [3 (e_ +2).] toVectors ::)
                    316:   (        ---> [2 , 1 , 0 ])
                    317:   (Example 3: [(e_+2). (e_^2+1).] toVectors ::)
                    318:   (        ---> [[2 , 1] [1 , 0 , 1]] )
                    319:   (Example 4: [2 [(e x + 1). (x+1).]] toVectors )
                    320:   (           ===> [ [1 , x] [x+1 , 0] ] )
                    321: ]] putUsages
                    322: [(toVectors2)
                    323:  [(Remained for the compatibility. cf. toVectors)
1.12    ! takayama  324: ]] putUsages
        !           325:
        !           326: [(extension-examples)
        !           327:  [
        !           328:    $putAttributeList$
        !           329:    $  [(putAttributeList) [[(x+y-1) (x-y-2)] (x,y)]  $
        !           330:    $                      [(needSyz) 1 (sugar) 1]] extension /myarg set $
        !           331:    $  [(getAttributeList) myarg] extension :: $
        !           332:    $  [(getAttribute) myarg (sugar)] extension :: $
1.1       maekawa   333: ]] putUsages
                    334:

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