[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.15

1.15    ! takayama    1: %% $OpenXM: OpenXM/src/kan96xx/Kan/usage.sm1,v 1.14 2013/09/20 06:02:19 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.)
1.13      takayama  174:    (Example: contiguity of 1F1. Eb b = (b-1) Eb)
                    175:    ( [ [(x) (a,b)] ring_of_differential_difference_operators )
                    176:    (  [[(Dx) 1]] weight_vector 0] define_ring )
                    177:    ( [ ( x Dx (x Dx+b-1) -x (x Dx+a) ). )
                    178:    ( ( (x Dx +b-1) - (b-1) Eb ). ] /ff set )
                    179:    ( ff {dehomogenize homogenize} map /ff2 set )
                    180:    ( [ff2] groebner /gg set )
                    181:    ( gg dehomogenize 0 get /gg set )
                    182:    ( gg [(Dx)] eliminatev /gg2 set )
                    183:    ( gg2 pmat )
                    184:
1.4       takayama  185:  ]
                    186: ] putUsages
1.1       maekawa   187:
                    188: [(define_ring)
                    189:   [( [varlist ring_of_??? order characteristic options] define_ring)
                    190:    ( Pointer to the ring.)
                    191:    (Example: [(x,y,z) ring_of_polynomials [[(x) 100 (y) 10 (z) 1]] weight_vector)
                    192:    (          11] define_qring )
                    193:    (Example: [(x,y) ring_of_polynomials [[(x) 1]] weight_vector 0 ] define_ring)
                    194:    (         /R set)
                    195:    (cf. define_qring, set_up_ring@ <coefficient ring>)
                    196:    (    <<ring_of_???>> ring_of_polynomials, ring_of_differential_operators, )
                    197:    (    ring_of_difference_operators)
                    198:    (    <<order>> elimination_order, weight_vector)
1.8       takayama  199:    (    ring_def,ring , << __ >>)
1.1       maekawa   200:   ]
                    201: ] putUsages
                    202:
                    203:
                    204: [(.)
                    205:  [(string . polynomial)
                    206:   (Parse the string as a polynomial in the current ring and put it on the stack)
                    207:   (Example ( (x+2)^3 ) .)
                    208:  ]
                    209: ] putUsages
                    210:
                    211: [(evenQ)
                    212:  [ (number evenQ bool)
                    213:  ]
                    214: ] putUsages
                    215:
                    216: [(reverse)
                    217:  [ (array reverse reversed_array)
                    218:  ]
                    219: ] putUsages
                    220:
                    221: [(memberQ)
                    222:  [(element array(list) memberQ bool)
                    223:  ]
                    224: ] putUsages
                    225:
                    226: [(transpose)
                    227:  [( matrix transpose transposed_matrix)
                    228:  ]
                    229: ] putUsages
                    230:
                    231: [(timer)
                    232:  [( { codes } timer )
                    233:   (It outputs the execution time to execute << codes >>.)
                    234:   (If you type in ctrl-C while you are executing this macro,)
                    235:   (you need to type in set_timer after you type in ctrl-C to reset)
                    236:   (the timer.)
                    237: ]] putUsages
                    238:
                    239: [(complement)
                    240:  [( set universal_set complement complement_set)
                    241:   (Example: [1 2] [3 4 1 2 5] complement ::)
                    242:  ]
                    243: ] putUsages
                    244:
                    245: [(pushVariables)
                    246:  [ (varlist pushVariables pushed-variables)
                    247:    (The macro is used to define local variables in a macro.)
                    248:    (Example : /foo {                     )
                    249:    (           /arg1 set                 )
                    250:    (          [/abc /cd] pushVariables   )
                    251:    (          [ /abc arg1 def            )
                    252:    (            /cd abc 1 add def )
                    253:    (            /arg1 cd def )
                    254:    (          ] pop                      )
                    255:    (          popVariables)
                    256:    (          arg1  )
                    257:    (          } def )
                    258:    (  10 foo ::    returns 11 )
                    259:    (    In the example, abc and cd are local variables.)
                    260:  ]
                    261: ] putUsages
                    262:
                    263:
                    264:
                    265: /@@@.global.usage1
                    266:  [(@@@. is the prefix for the global control variables and global functions.)
                    267:   (@@@.quiet   :  1 ---> quiet mode,  0 ---> not. cf. sm1 -q)
                    268:   (@@@.esymbol : (e_) is the standard value. It is used to express)
                    269:   (              vectors internally. cf. fromVectors, toVectors)
                    270:   (@@@.Dsymbol :  (D) is the standard value for differential operator.)
                    271:   (                cf. ring_of_differential_operators)
                    272:   (@@@.diffEsymbol :  (E) is the standard value for difference operator.)
                    273:   (                cf. ring_of_difference_operators)
                    274:   (@@@.Qsymbol :  (Q) is the standard value for q-difference operator.)
                    275:   (                cf. ring_of_qdifference_operators)
                    276:  ]
                    277: def
                    278: [(@@@.quiet)  @@@.global.usage1] putUsages
                    279: [(@@@.Dsymbol)  @@@.global.usage1] putUsages
                    280: [(@@@.diffEsymbol)  @@@.global.usage1] putUsages
                    281: [(@@@.Qsymbol)  @@@.global.usage1] putUsages
                    282: [(@@@.esymbol)  @@@.global.usage1] putUsages
                    283:
                    284: [(join)
                    285:  [(list1 list2 join list3)
                    286:   (Ex.  [1 2] [3 [4 (ab)]] join  [1 2 3 [4 (ab)]])
1.9       takayama  287:   (Note: Join should use for arrays. It works for list too,)
                    288:   (      but it does not copy cells. cf. cons)
                    289:   (      So, it might generate looped lists or destroy other lists.)
1.1       maekawa   290:  ]
                    291: ] putUsages
                    292:
                    293: [(not)
                    294:  [(int not int)
                    295:   (1 not 0)
                    296:   (0 not 1)
                    297:  ]
                    298: ] putUsages
                    299:
                    300: [(append)
                    301:  [(list1 obj2 append list3)
                    302:   (Ex.  [1 2]  3 append  [1 2 3])
                    303:  ]
                    304: ] putUsages
                    305:
                    306: [(null)
                    307:  [(<<null>> returns null object)]
                    308: ] putUsages
                    309:
                    310: [(oxasir)
                    311:  [(ox_asir is an asir server which is complient to open xxx protocol.)
                    312:   (This module is necessary for efficient execution factorization )
                    313:   (of b-functions in annfs, deRham.  cf. lib/oxasir.sm1)
                    314:   (ox_asir has not yet been put on the ftp cite. 12/17, 1998.)
                    315:  ]
                    316: ] putUsages
                    317:
                    318: [(toVectors)
                    319:  [(obj toVectors vec)
                    320:   (Convert the internal expression of vector into the array <<vec>>.)
                    321:   (obj can be  [n [g1 ... gm]] where n is the length of the vector.)
1.3       takayama  322:   $cf. [(toe_) array_of_poly] gbext $
1.1       maekawa   323:   $Example 1: [(x) ring_of_polynomials 0] define_ring  $
                    324:   $           (e_ + 2).  toVectors :: $
                    325:   (        --->  [2  , 1] )
                    326:   (Example 2: [3 (e_ +2).] toVectors ::)
                    327:   (        ---> [2 , 1 , 0 ])
                    328:   (Example 3: [(e_+2). (e_^2+1).] toVectors ::)
                    329:   (        ---> [[2 , 1] [1 , 0 , 1]] )
                    330:   (Example 4: [2 [(e x + 1). (x+1).]] toVectors )
                    331:   (           ===> [ [1 , x] [x+1 , 0] ] )
                    332: ]] putUsages
                    333: [(toVectors2)
                    334:  [(Remained for the compatibility. cf. toVectors)
1.12      takayama  335: ]] putUsages
                    336:
                    337: [(extension-examples)
                    338:  [
                    339:    $putAttributeList$
                    340:    $  [(putAttributeList) [[(x+y-1) (x-y-2)] (x,y)]  $
                    341:    $                      [(needSyz) 1 (sugar) 1]] extension /myarg set $
                    342:    $  [(getAttributeList) myarg] extension :: $
                    343:    $  [(getAttribute) myarg (sugar)] extension :: $
1.1       maekawa   344: ]] putUsages
                    345:
1.14      takayama  346: [(note-class)
                    347: [
                    348:   $Example 1: [(object) [ ] [1,2]] [(class) (tree)] dc /ff set $
                    349:   $           ff (array) dc :: $
                    350:   $cf. data_conversion, kan96xx/Kan/kclass.c (KclassDataConversion) $
1.15    ! takayama  351: ]] putUsages
        !           352:
        !           353: [(sm1log)
        !           354: [
        !           355:   $str sm1log outputs the str to the log file /tmp/sm1log.txt$
        !           356: ]] putUsages

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