Changeset 77ce4e in git


Ignore:
Timestamp:
Dec 20, 2013, 6:12:59 PM (10 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
46b1f513aa263ced36435ada2b9a3c7fa2cccd26
Parents:
b2cb7b48301812323aeeb1e1bd6dd5fce53626b4ef0582d78e68d3c3ccda208288280a8c701d9ef8
Message:
Merge pull request #455 from surface-smoothers/improve.ASSUME.documentation

fixed typo and extended ASSUME documentation by one sentence
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/ellipticcovers.lib

    ref0582 r77ce4e  
    33category="Commutative Algebra";
    44info="
    5 LIBRARY:  ellipticCovers.lib    Gromov Witten numbers of elliptic curves
     5LIBRARY:  ellipticCovers.lib    Gromov-Witten numbers of elliptic curves
    66
    77AUTHORS:  J. Boehm, boehm @ mathematik.uni-kl.de
     
    3434References:
    3535
    36 [BBM] J. Boehm, A. Buchholz, H. Markwig: Tropical mirror symmetry for elliptic curves, arXiv *** (2013).
     36[BBM] J. Boehm, A. Buchholz, H. Markwig: Tropical mirror symmetry for elliptic curves, arXiv:1309.5893 (2013).
    3737
    3838KEYWORDS:
  • Singular/LIB/orbitparam.lib

    ref0582 r77ce4e  
    33category="Algebraic Geometry";
    44info="
    5 LIBRARY:  orbitparam.lib   Parametrizing unipotent orbits
     5LIBRARY:  orbitparam.lib   Parametrizing orbits of unipotent actions
    66
    77AUTHORS:  J. Boehm, boehm at mathematik.uni-kl.de @*
  • Singular/LIB/schreyer.lib

    ref0582 r77ce4e  
    33category="General purpose";
    44info="
    5 LIBRARY: schreyer.lib     Helpers for working with the Schreyer induced ordering
     5LIBRARY: schreyer.lib     Helpers for computing a Schreyer resolution in @code{derham.lib}
    66AUTHOR:  Oleksandr Motsak <U@D>, where U={motsak}, D={mathematik.uni-kl.de}
     7KEYWORDS: Schreyer ordering; Schreyer resolution; syzygy
     8OVERVIEW:
     9@* The library contains helper procedures for computing a Schreyer resoltion (cf. [SFO]),
     10   originally meant to be used by @code{derham.lib} (which requires resolutions over the homogenized Weyl algebra).
     11   The library works both in the commutative and non-commutative setting (cf. [MO]).
     12   Here, we call a free resolution a Schreyer resolution if each syzygy module is given by a Groebner basis
     13   with respect to the corresponding Schreyer ordering.
     14   A Schreyer resolution can be much bigger than a minimal resolution of the same module, but may be easier to construct.
     15@* The input for the resolution computations is a set of vectors @code{M} in form of a module over some basering @code{R}.
     16   The ring @code{R} may be non-commutative, in which case the ring ordering should be global.
     17@* These procedures produce/work with partial Schreyer resolutions of @code{(R^rank(M))/M} in form of
     18   a ring (endowed with a special ring ordering that will be extended in the course of a resolution computation)
     19   containing a list of modules @code{RES} and a module @code{MRES}:
     20@* The list of modules @code{RES} contains the images of maps (also called syzygy modules) substituting the
     21   computed beginning of a Schreyer resolution, that is, each syzygy module is given by a Groebner basis
     22   with respect to the corresponding Schreyer ordering.
     23@* The list @code{RES} starts with a zero map given by @code{rank(M)} zero generators indicating that the image of
     24   the first differential map is zero. The second map @code{RES[2]} is given by @code{M}, which indicates that
     25   the resolution of @code{(R^rank(M))/M} is being computed.
     26@* The module @code{MRES} is a direct sum of modules from @code{RES} and thus comprises all computed differentials.
     27@* Syzygies are shifted so that @code{gen(i)} is mapped to @code{MRES[i]} under the differential map.
     28@* The Schreyer ordering succesively extends the starting module ordering on @code{M} (defined in Singular by the basering @code{R})
     29   and is extended to higher syzygies using the following definition:
     30@*        a < b if and only if (d(a) < d(b)) OR ( (d(a) = d(b) AND (comp(a) < comp(b)) ),
     31@* where @code{d(a)} is the image of a under the differential (given by @code{MRES}),
     32   and @code{comp(a)} is the module component, for any module terms @code{a} and @code{b} from the same higher syzygy module.
     33REFERENCES:
     34[SFO] Schreyer, F.O.: Die Berechnung von Syzygien mit dem verallgemeinerten Weierstrassschen Divisionssatz,
     35      Master's thesis, Univ. Hamburg, 1980.
     36[MO]  Motsak, O.: Non-commutative Computer Algebra with applications: Graded commutative algebra and related
     37      structures in Singular with applications, Ph.D. thesis, TU Kaiserslautern, 2010
     38
     39NOTE:  requires the dynamic or built-in module @code{syzextra}
    740
    841PROCEDURES:
    9  Sres(M,l)      Schreyer resolution of module M of maximal length l
    10  Ssyz(M)        Schreyer resolution of module M of length 1
    11  Scontinue(l)   continue the resolution computation by most l steps
    12 
    13 KEYWORDS:  syzygy; Schreyer induced ordering; Schreyer free resolution
    14 NOTE:  requires the dynamic module: syzextra
     42  Sres(M,len)     compute Schreyer resolution of module M of maximal length len
     43  Ssyz(M)         compute Schreyer resolution of module M of length 1
     44  Scontinue(len)  extend currently active resolution by (at most) len syszygies
    1545";
    1646
     
    329359
    330360proc Scontinue(int l)
    331 "USAGE:  Scontinue(l)
    332 RETURN:  nothing, instead it changes RES and MRES variables in the current ring
    333 PURPOSE: computes further (at most l) syzygies
    334 NOTE:    must be used within a ring returned by Sres or Ssyz. RES and MRES are
    335          explained in Sres
     361"USAGE:  Scontinue(int len)
     362RETURN:  nothing, instead it changes the currently active resolution
     363PURPOSE: extends the currently active resolution by at most len syzygies
     364ASSUME:  must be used within a ring returned by Sres or Ssyz
    336365EXAMPLE: example Scontinue; shows an example
    337366"
     
    361390
    362391proc Ssyz(module M)
    363 "USAGE:  Ssyz(M)
    364 RETURN:  ring, containing a list of modules RES and a module MRES
    365 PURPOSE: computes the first syzygy module of M (wrt some Schreyer ordering)
    366 NOTE:    The output is explained in Sres
     392"USAGE:  Ssyz(module M)
     393RETURN:  ring, containing a Schreyer resolution
     394PURPOSE: computes a Schreyer resolution of M of length 1 (see the library overview)
     395SEE ALSO: Sres
    367396EXAMPLE: example Ssyz; shows an example
    368397"
     
    393422
    394423proc Sres(module M, int l)
    395 "USAGE:  Sres(M, l)
    396 RETURN:  ring, containing a list of modules RES and a module MRES
    397 PURPOSE: computes (at most l) syzygy modules of M wrt the classical Schreyer
    398          induced ordering with gen(i) > gen(j) if i > j, provided both gens
    399          are from the same syzygy level.
    400 NOTE:    RES contains the images of maps subsituting the beginning of the
    401          Schreyer free resolution of baseRing^r/M, while MRES is a sum of
    402          these images in a big free sum, containing all the syzygy modules.
    403          The syzygy modules are shifted so that gen(i) correspons to MRES[i].
    404          The leading zero module RES[0] indicates the fact that coker of the
    405          first map is zero. The number of zeroes inducates the rank of input.
    406 NOTE:    If l == 0 then l is set to be nvars(basering) + 1
     424"USAGE:  Sres(module M, int len)
     425RETURN:  ring, containing a Schreyer resolution
     426PURPOSE: computes a Schreyer resolution of M of length at most len (see the library overview)
     427NOTE:    If given len is zero then nvars(basering) + 1 is used instead.
     428SEE ALSO: Ssyz
    407429EXAMPLE: example Sres; shows an example
    408430"
  • Singular/grammar.cc

    ref0582 r77ce4e  
    805805     727,   731,   735,   739,   743,   747,   751,   755,   759,   763,
    806806     780,   787,   786,   804,   812,   820,   829,   833,   837,   841,
    807      845,   849,   853,   857,   861,   865,   869,   873,   877,   884,
    808      891,   892,   911,   912,   924,   929,   934,   938,   942,   982,
    809     1008,  1029,  1037,  1041,  1042,  1056,  1064,  1073,  1118,  1119,
    810     1128,  1129,  1135,  1142,  1144,  1146,  1156,  1155,  1163,  1168,
    811     1175,  1183,  1195,  1211,  1230,  1234,  1238,  1243,  1247,  1251,
    812     1255,  1259,  1264,  1270,  1276,  1282,  1288,  1294,  1300,  1312,
    813     1319,  1323,  1360,  1370,  1376,  1376,  1379,  1451,  1455,  1484,
    814     1497,  1514,  1523,  1528,  1536,  1548,  1567,  1577,  1596,  1619,
    815     1625,  1637,  1643
     807     845,   849,   853,   857,   861,   865,   869,   873,   877,   889,
     808     896,   897,   916,   917,   929,   934,   939,   943,   947,   987,
     809    1013,  1034,  1042,  1046,  1047,  1061,  1069,  1078,  1123,  1124,
     810    1133,  1134,  1140,  1147,  1149,  1151,  1161,  1160,  1168,  1173,
     811    1180,  1188,  1200,  1216,  1235,  1239,  1243,  1248,  1252,  1256,
     812    1260,  1264,  1269,  1275,  1281,  1287,  1293,  1299,  1305,  1317,
     813    1324,  1328,  1365,  1375,  1381,  1381,  1384,  1456,  1460,  1489,
     814    1502,  1519,  1528,  1533,  1541,  1553,  1572,  1582,  1601,  1624,
     815    1630,  1642,  1648
    816816};
    817817#endif
     
    32893289#line 878 "grammar.y"
    32903290    {
    3291             memset(&(yyval.lv),0,sizeof((yyval.lv)));
    3292             int i; TESTSETINT((yyvsp[(2) - (2)].lv),i);
    3293             (yyval.lv).rtyp  = INT_CMD;
    3294             (yyval.lv).data = (void *)(long)(i == 0 ? 1 : 0);
     3291            if (siq>0)
     3292            { if (iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),NOT)) YYERROR; }
     3293            else
     3294            {
     3295              memset(&(yyval.lv),0,sizeof((yyval.lv)));
     3296              int i; TESTSETINT((yyvsp[(2) - (2)].lv),i);
     3297              (yyval.lv).rtyp  = INT_CMD;
     3298              (yyval.lv).data = (void *)(long)(i == 0 ? 1 : 0);
     3299            }
    32953300          ;}
    32963301    break;
     
    32993304
    33003305/* Line 1464 of yacc.c  */
    3301 #line 885 "grammar.y"
     3306#line 890 "grammar.y"
    33023307    {
    33033308            if(iiExprArith1(&(yyval.lv),&(yyvsp[(2) - (2)].lv),'-')) YYERROR;
     
    33083313
    33093314/* Line 1464 of yacc.c  */
    3310 #line 891 "grammar.y"
     3315#line 896 "grammar.y"
    33113316    { (yyval.lv) = (yyvsp[(1) - (2)].lv); ;}
    33123317    break;
     
    33153320
    33163321/* Line 1464 of yacc.c  */
    3317 #line 893 "grammar.y"
     3322#line 898 "grammar.y"
    33183323    {
    33193324            if ((yyvsp[(1) - (2)].lv).rtyp==0)
     
    33353340
    33363341/* Line 1464 of yacc.c  */
    3337 #line 913 "grammar.y"
     3342#line 918 "grammar.y"
    33383343    {
    33393344            if ((yyvsp[(2) - (3)].lv).Typ()!=STRING_CMD)
     
    33493354
    33503355/* Line 1464 of yacc.c  */
    3351 #line 925 "grammar.y"
     3356#line 930 "grammar.y"
    33523357    {
    33533358            if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
     
    33593364
    33603365/* Line 1464 of yacc.c  */
    3361 #line 930 "grammar.y"
     3366#line 935 "grammar.y"
    33623367    {
    33633368            if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
     
    33693374
    33703375/* Line 1464 of yacc.c  */
    3371 #line 935 "grammar.y"
     3376#line 940 "grammar.y"
    33723377    {
    33733378            if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
     
    33783383
    33793384/* Line 1464 of yacc.c  */
    3380 #line 939 "grammar.y"
     3385#line 944 "grammar.y"
    33813386    {
    33823387            if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&(currRing->idroot), TRUE)) YYERROR;
     
    33873392
    33883393/* Line 1464 of yacc.c  */
    3389 #line 943 "grammar.y"
     3394#line 948 "grammar.y"
    33903395    {
    33913396            int r; TESTSETINT((yyvsp[(4) - (8)].lv),r);
     
    34323437
    34333438/* Line 1464 of yacc.c  */
    3434 #line 983 "grammar.y"
     3439#line 988 "grammar.y"
    34353440    {
    34363441            if ((yyvsp[(1) - (2)].i) == MATRIX_CMD)
     
    34633468
    34643469/* Line 1464 of yacc.c  */
    3465 #line 1009 "grammar.y"
     3470#line 1014 "grammar.y"
    34663471    {
    34673472            int t=(yyvsp[(1) - (3)].lv).Typ();
     
    34893494
    34903495/* Line 1464 of yacc.c  */
    3491 #line 1030 "grammar.y"
     3496#line 1035 "grammar.y"
    34923497    {
    34933498            if (iiDeclCommand(&(yyval.lv),&(yyvsp[(2) - (2)].lv),myynest,(yyvsp[(1) - (2)].i),&((yyvsp[(2) - (2)].lv).req_packhdl->idroot)))
     
    34993504
    35003505/* Line 1464 of yacc.c  */
    3501 #line 1043 "grammar.y"
     3506#line 1048 "grammar.y"
    35023507    {
    35033508            leftv v = &(yyvsp[(2) - (5)].lv);
     
    35153520
    35163521/* Line 1464 of yacc.c  */
    3517 #line 1057 "grammar.y"
     3522#line 1062 "grammar.y"
    35183523    {
    35193524          // let rInit take care of any errors
     
    35253530
    35263531/* Line 1464 of yacc.c  */
    3527 #line 1065 "grammar.y"
     3532#line 1070 "grammar.y"
    35283533    {
    35293534            memset(&(yyval.lv),0,sizeof((yyval.lv)));
     
    35393544
    35403545/* Line 1464 of yacc.c  */
    3541 #line 1074 "grammar.y"
     3546#line 1079 "grammar.y"
    35423547    {
    35433548            memset(&(yyval.lv),0,sizeof((yyval.lv)));
     
    35863591
    35873592/* Line 1464 of yacc.c  */
    3588 #line 1120 "grammar.y"
     3593#line 1125 "grammar.y"
    35893594    {
    35903595            (yyval.lv) = (yyvsp[(1) - (3)].lv);
     
    35973602
    35983603/* Line 1464 of yacc.c  */
    3599 #line 1130 "grammar.y"
     3604#line 1135 "grammar.y"
    36003605    {
    36013606            (yyval.lv) = (yyvsp[(2) - (3)].lv);
     
    36063611
    36073612/* Line 1464 of yacc.c  */
    3608 #line 1136 "grammar.y"
     3613#line 1141 "grammar.y"
    36093614    {
    36103615            expected_parms = TRUE;
     
    36153620
    36163621/* Line 1464 of yacc.c  */
    3617 #line 1143 "grammar.y"
     3622#line 1148 "grammar.y"
    36183623    { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
    36193624    break;
     
    36223627
    36233628/* Line 1464 of yacc.c  */
    3624 #line 1145 "grammar.y"
     3629#line 1150 "grammar.y"
    36253630    { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
    36263631    break;
     
    36293634
    36303635/* Line 1464 of yacc.c  */
    3631 #line 1147 "grammar.y"
     3636#line 1152 "grammar.y"
    36323637    { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
    36333638    break;
     
    36363641
    36373642/* Line 1464 of yacc.c  */
    3638 #line 1156 "grammar.y"
     3643#line 1161 "grammar.y"
    36393644    { if ((yyvsp[(1) - (2)].i) != '<') YYERROR;
    36403645            if((feFilePending=feFopen((yyvsp[(2) - (2)].name),"r",NULL,TRUE))==NULL) YYERROR; ;}
     
    36443649
    36453650/* Line 1464 of yacc.c  */
    3646 #line 1159 "grammar.y"
     3651#line 1164 "grammar.y"
    36473652    { newFile((yyvsp[(2) - (4)].name),feFilePending); ;}
    36483653    break;
     
    36513656
    36523657/* Line 1464 of yacc.c  */
    3653 #line 1164 "grammar.y"
     3658#line 1169 "grammar.y"
    36543659    {
    36553660            feHelp((yyvsp[(2) - (3)].name));
     
    36613666
    36623667/* Line 1464 of yacc.c  */
    3663 #line 1169 "grammar.y"
     3668#line 1174 "grammar.y"
    36643669    {
    36653670            feHelp(NULL);
     
    36703675
    36713676/* Line 1464 of yacc.c  */
    3672 #line 1176 "grammar.y"
     3677#line 1181 "grammar.y"
    36733678    {
    36743679            singular_example((yyvsp[(2) - (3)].name));
     
    36803685
    36813686/* Line 1464 of yacc.c  */
    3682 #line 1184 "grammar.y"
     3687#line 1189 "grammar.y"
    36833688    {
    36843689          if (basePack!=(yyvsp[(2) - (2)].lv).req_packhdl)
     
    36943699
    36953700/* Line 1464 of yacc.c  */
    3696 #line 1196 "grammar.y"
     3701#line 1201 "grammar.y"
    36973702    {
    36983703          leftv v=&(yyvsp[(2) - (2)].lv);
     
    37153720
    37163721/* Line 1464 of yacc.c  */
    3717 #line 1212 "grammar.y"
     3722#line 1217 "grammar.y"
    37183723    {
    37193724          leftv v=&(yyvsp[(3) - (3)].lv);
     
    37363741
    37373742/* Line 1464 of yacc.c  */
    3738 #line 1231 "grammar.y"
     3743#line 1236 "grammar.y"
    37393744    {
    37403745            list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
     
    37453750
    37463751/* Line 1464 of yacc.c  */
    3747 #line 1235 "grammar.y"
     3752#line 1240 "grammar.y"
    37483753    {
    37493754            list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
     
    37543759
    37553760/* Line 1464 of yacc.c  */
    3756 #line 1239 "grammar.y"
     3761#line 1244 "grammar.y"
    37573762    {
    37583763            if ((yyvsp[(3) - (4)].i)==QRING_CMD) (yyvsp[(3) - (4)].i)=RING_CMD;
     
    37643769
    37653770/* Line 1464 of yacc.c  */
    3766 #line 1244 "grammar.y"
     3771#line 1249 "grammar.y"
    37673772    {
    37683773            list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
     
    37733778
    37743779/* Line 1464 of yacc.c  */
    3775 #line 1248 "grammar.y"
     3780#line 1253 "grammar.y"
    37763781    {
    37773782            list_cmd(RING_CMD,NULL,"// ",TRUE);
     
    37823787
    37833788/* Line 1464 of yacc.c  */
    3784 #line 1252 "grammar.y"
     3789#line 1257 "grammar.y"
    37853790    {
    37863791            list_cmd((yyvsp[(3) - (4)].i),NULL,"// ",TRUE);
     
    37913796
    37923797/* Line 1464 of yacc.c  */
    3793 #line 1256 "grammar.y"
     3798#line 1261 "grammar.y"
    37943799    {
    37953800            list_cmd(PROC_CMD,NULL,"// ",TRUE);
     
    38003805
    38013806/* Line 1464 of yacc.c  */
    3802 #line 1260 "grammar.y"
     3807#line 1265 "grammar.y"
    38033808    {
    38043809            list_cmd(0,(yyvsp[(3) - (4)].lv).Fullname(),"// ",TRUE);
     
    38103815
    38113816/* Line 1464 of yacc.c  */
    3812 #line 1265 "grammar.y"
     3817#line 1270 "grammar.y"
    38133818    {
    38143819            if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
     
    38213826
    38223827/* Line 1464 of yacc.c  */
    3823 #line 1271 "grammar.y"
     3828#line 1276 "grammar.y"
    38243829    {
    38253830            if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
     
    38323837
    38333838/* Line 1464 of yacc.c  */
    3834 #line 1277 "grammar.y"
     3839#line 1282 "grammar.y"
    38353840    {
    38363841            if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
     
    38433848
    38443849/* Line 1464 of yacc.c  */
    3845 #line 1283 "grammar.y"
     3850#line 1288 "grammar.y"
    38463851    {
    38473852            if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
     
    38543859
    38553860/* Line 1464 of yacc.c  */
    3856 #line 1289 "grammar.y"
     3861#line 1294 "grammar.y"
    38573862    {
    38583863            if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
     
    38653870
    38663871/* Line 1464 of yacc.c  */
    3867 #line 1295 "grammar.y"
     3872#line 1300 "grammar.y"
    38683873    {
    38693874            if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
     
    38763881
    38773882/* Line 1464 of yacc.c  */
    3878 #line 1301 "grammar.y"
     3883#line 1306 "grammar.y"
    38793884    {
    38803885            if((yyvsp[(3) - (6)].lv).Typ() == PACKAGE_CMD)
     
    38873892
    38883893/* Line 1464 of yacc.c  */
    3889 #line 1313 "grammar.y"
     3894#line 1318 "grammar.y"
    38903895    {
    38913896            list_cmd(-1,NULL,"// ",TRUE);
     
    38963901
    38973902/* Line 1464 of yacc.c  */
    3898 #line 1319 "grammar.y"
     3903#line 1324 "grammar.y"
    38993904    { yyInRingConstruction = TRUE; ;}
    39003905    break;
     
    39033908
    39043909/* Line 1464 of yacc.c  */
    3905 #line 1328 "grammar.y"
     3910#line 1333 "grammar.y"
    39063911    {
    39073912            const char *ring_name = (yyvsp[(2) - (8)].lv).name;
     
    39413946
    39423947/* Line 1464 of yacc.c  */
    3943 #line 1361 "grammar.y"
     3948#line 1366 "grammar.y"
    39443949    {
    39453950            const char *ring_name = (yyvsp[(2) - (2)].lv).name;
     
    39533958
    39543959/* Line 1464 of yacc.c  */
    3955 #line 1371 "grammar.y"
     3960#line 1376 "grammar.y"
    39563961    {
    39573962            if (((yyvsp[(1) - (2)].i)!=LIB_CMD)||(jjLOAD((yyvsp[(2) - (2)].name),TRUE))) YYERROR;
     
    39623967
    39633968/* Line 1464 of yacc.c  */
    3964 #line 1380 "grammar.y"
     3969#line 1385 "grammar.y"
    39653970    {
    39663971            if (((yyvsp[(1) - (2)].i)==KEEPRING_CMD) && (myynest==0))
     
    40364041
    40374042/* Line 1464 of yacc.c  */
    4038 #line 1452 "grammar.y"
     4043#line 1457 "grammar.y"
    40394044    {
    40404045            type_cmd(&((yyvsp[(2) - (2)].lv)));
     
    40454050
    40464051/* Line 1464 of yacc.c  */
    4047 #line 1456 "grammar.y"
     4052#line 1461 "grammar.y"
    40484053    {
    40494054            //Print("typ is %d, rtyp:%d\n",$1.Typ(),$1.rtyp);
     
    40734078
    40744079/* Line 1464 of yacc.c  */
    4075 #line 1485 "grammar.y"
     4080#line 1490 "grammar.y"
    40764081    {
    40774082            int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
     
    40914096
    40924097/* Line 1464 of yacc.c  */
    4093 #line 1498 "grammar.y"
     4098#line 1503 "grammar.y"
    40944099    {
    40954100            if (currentVoice->ifsw==1)
     
    41134118
    41144119/* Line 1464 of yacc.c  */
    4115 #line 1515 "grammar.y"
     4120#line 1520 "grammar.y"
    41164121    {
    41174122            int i; TESTSETINT((yyvsp[(3) - (5)].lv),i);
     
    41274132
    41284133/* Line 1464 of yacc.c  */
    4129 #line 1524 "grammar.y"
     4134#line 1529 "grammar.y"
    41304135    {
    41314136            if (exitBuffer(BT_break)) YYERROR;
     
    41374142
    41384143/* Line 1464 of yacc.c  */
    4139 #line 1529 "grammar.y"
     4144#line 1534 "grammar.y"
    41404145    {
    41414146            if (contBuffer(BT_break)) YYERROR;
     
    41474152
    41484153/* Line 1464 of yacc.c  */
    4149 #line 1537 "grammar.y"
     4154#line 1542 "grammar.y"
    41504155    {
    41514156            /* -> if(!$2) break; $3; continue;*/
     
    41614166
    41624167/* Line 1464 of yacc.c  */
    4163 #line 1549 "grammar.y"
     4168#line 1554 "grammar.y"
    41644169    {
    41654170            /* $2 */
     
    41824187
    41834188/* Line 1464 of yacc.c  */
    4184 #line 1568 "grammar.y"
     4189#line 1573 "grammar.y"
    41854190    {
    41864191            idhdl h = enterid((yyvsp[(2) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
     
    41974202
    41984203/* Line 1464 of yacc.c  */
    4199 #line 1578 "grammar.y"
     4204#line 1583 "grammar.y"
    42004205    {
    42014206            idhdl h = enterid((yyvsp[(1) - (3)].name),myynest,PROC_CMD,&IDROOT,TRUE);
     
    42214226
    42224227/* Line 1464 of yacc.c  */
    4223 #line 1597 "grammar.y"
     4228#line 1602 "grammar.y"
    42244229    {
    42254230            omFree((ADDRESS)(yyvsp[(3) - (4)].name));
     
    42464251
    42474252/* Line 1464 of yacc.c  */
    4248 #line 1620 "grammar.y"
     4253#line 1625 "grammar.y"
    42494254    {
    42504255            // decl. of type proc p(int i)
     
    42574262
    42584263/* Line 1464 of yacc.c  */
    4259 #line 1626 "grammar.y"
     4264#line 1631 "grammar.y"
    42604265    {
    42614266            // decl. of type proc p(i)
     
    42714276
    42724277/* Line 1464 of yacc.c  */
    4273 #line 1638 "grammar.y"
     4278#line 1643 "grammar.y"
    42744279    {
    42754280            iiRETURNEXPR.Copy(&(yyvsp[(3) - (4)].lv));
     
    42824287
    42834288/* Line 1464 of yacc.c  */
    4284 #line 1644 "grammar.y"
     4289#line 1649 "grammar.y"
    42854290    {
    42864291            if ((yyvsp[(1) - (3)].i)==RETURN)
     
    42964301
    42974302/* Line 1464 of yacc.c  */
    4298 #line 4297 "grammar.cc"
     4303#line 4302 "grammar.cc"
    42994304      default: break;
    43004305    }
  • Singular/grammar.y

    ref0582 r77ce4e  
    877877        | NOT expr
    878878          {
    879             memset(&$$,0,sizeof($$));
    880             int i; TESTSETINT($2,i);
    881             $$.rtyp  = INT_CMD;
    882             $$.data = (void *)(long)(i == 0 ? 1 : 0);
     879            if (siq>0)
     880            { if (iiExprArith1(&$$,&$2,NOT)) YYERROR; }
     881            else
     882            {
     883              memset(&$$,0,sizeof($$));
     884              int i; TESTSETINT($2,i);
     885              $$.rtyp  = INT_CMD;
     886              $$.data = (void *)(long)(i == 0 ? 1 : 0);
     887            }
    883888          }
    884889        | '-' expr %prec UMINUS
  • Singular/iparith.cc

    ref0582 r77ce4e  
    46024602{
    46034603  res->data=ipNameListLev((IDROOT),(int)(long)v->Data());
     4604  return FALSE;
     4605}
     4606static BOOLEAN jjNOT(leftv res, leftv v)
     4607{
     4608  res->data=(char*)(long)((long)v->Data()==0 ? 1 : 0);
    46044609  return FALSE;
    46054610}
     
    54615466static BOOLEAN jjnInt(leftv res, leftv u)
    54625467{
    5463   number n=(number)u->Data();
     5468  number n=(number)u->CopyD(); // n_Int may call n_Normalize
    54645469  res->data=(char *)(long)n_Int(n,currRing->cf);
     5470  n_Delete(&n,currRing->cf);
    54655471  return FALSE;
    54665472}
  • Singular/ipshell.cc

    ref0582 r77ce4e  
    57895789  res->data=(void*)r;
    57905790  return FALSE;
    5791   WerrorS("not implemented");
    5792   return TRUE;
    57935791}
    57945792BOOLEAN iiApply(leftv res, leftv a, int op, leftv proc)
  • Singular/table.h

    ref0582 r77ce4e  
    176176,{D(jjNAMES),      NAMES_CMD,       LIST_CMD,       RING_CMD      , ALLOW_PLURAL |ALLOW_RING}
    177177,{D(jjNAMES),      NAMES_CMD,       LIST_CMD,       QRING_CMD     , ALLOW_PLURAL |ALLOW_RING}
     178,{D(jjNOT),        NOT,             INT_CMD,        INT_CMD       , ALLOW_PLURAL |ALLOW_RING}
    178179,{D(jjDUMMY),      NUMBER_CMD,      NUMBER_CMD,     NUMBER_CMD    , ALLOW_PLURAL |ALLOW_RING}
    179180,{D(jjP2N),        NUMBER_CMD,      NUMBER_CMD,     POLY_CMD      , ALLOW_PLURAL |ALLOW_RING}
  • doc/NEWS.texi

    ref0582 r77ce4e  
    2323
    2424Version 4-0-0 is a milestone relase of Singular.
    25 The new release series 4 aims for an entirely modularized system
     25The new release series 4 aims for an entirely modularized architecture
    2626simplifying connectivity with other systems and paving the way
    2727for parallel computations.
    28 As one step in this direction, in Singular 4-0-0,
    29 the representation of coefficient rings has been separated from the representation
    30 of polynomials which allows for easy integration of new types of coefficient fields.
     28As  a first step in modularization, the new  release features an internal
     29structural separation of coefficient rings and polynomial rings.
     30This allows for a flexible integration of new coefficient rings.
    3131
    32 @sc{Singular} 4-0-0's list of improvements and new
    33 functionality further extends that of
    34 the 3-1-6/7 pre-release series.
    35 One highlight is the implementation
    36 of Walther's algorithm for computing deRham cohomology.
     32@sc{Singular} 4-0-0's list of new functionality and significant
     33improvements further extends that of the 3-1-6/7 prerelease series.
    3734
    38 New commands
     35New functionality
     36
    3937@itemize
    40 @item @nref{sba}: an F5 like Groebner basis algorithm
    41 @item @nref{ASSUME}: support for debugging libraries
     38@item de Rham cohomology of complements of algebraic varieties (@nref{derham_lib})
     39@item Gromov-Witten numbers of elliptic curves (@nref{ellipticcovers_lib})
     40@item classification of isolated complete intersection singularities in characteristic 0 (@nref{classifyci_lib})
     41@item parametrization of orbits of unipotent actions (@nref{orbitparam_lib})
     42@item F5-like Groebner basis algorithm (@nref{sba})
     43@item element-wise application of functions to data structures (@nref{apply})
     44@item support for debugging libraries (@nref{ASSUME})
    4245@end itemize
    4346
    44 New libraries
    45 @itemize
    46 @item @nref{classifyci_lib}: Isolated complete intersection singularities in characteristic  0
    47 @item @nref{derham_lib}: Computation of deRham cohomology
    48 @item @nref{ellipticcovers_lib}: Gromov Witten numbers of elliptic curves
    49 @item @nref{orbitparam_lib}: Parametrizing unipotent orbits
    50 @end itemize
     47Improved functionality
    5148
    52 Improved libraries
    53 @itemize @bullet
    54 @item
    55 Compute GIT-fans: (@nref{gitfan_lib})
    56 @item
    57 Groebner Cover for parametric ideals (@nref{grobcov_lib})
    58 @item
    59 Normalization of Affine Rings (@nref{normal_lib})
    60 @item
    61 An abstraction layer for parallel skeletons (@nref{parallel_lib})
    62 @item
    63 Classification of real singularities (@nref{realclassify_lib})
    64 @item
    65 and many more with small fixes
    66 @end itemize
    67 
    68 Kernel improvements
    6949@itemize
    7050@item
    71 @nref{Dynamic modules}
     51Groebner cover for parametric ideals (@nref{grobcov_lib})
     52@item
     53normalization of affine rings (@nref{normal_lib})
     54@item
     55classification of real singularities (@nref{realclassify_lib})
     56@item
     57GIT-fans (@nref{gitfan_lib})
     58@item
     59algebraic/transcendental field extensions
    7260@item
    7361@nref{Non-commutative subsystem}
    7462@item
    75 name spaces (@nref{package})
     63an abstraction layer for parallel computations (@nref{parallel_lib})
    7664@item
    77 algebraic/transcendental field extensions
     65run-time loading of supplementary kernel code (@nref{Dynamic modules})
     66@item
     67interpreter language support for name spaces (@nref{package})
    7868@end itemize
    7969
    8070Availability
    8171
    82 @sc{Singular} is available for ix86-Linux,
    83 SunOS-5, ix86-Win (runs on Windows),
    84 FreeBSD, Mac OS X, x86_64-Linux (AMD64/Opteron/EM64T),
    85 IA64-Linux
     72@sc{Singular} is available as source code and for Linux, Mac OS X, Windows, FreeBSD and
     73SunOS-5.
    8674
  • doc/changes_in_singular4.texi

    ref0582 r77ce4e  
    5151@itemize @bullet
    5252@item @code{intStrategy}
    53 @item @code{degBound}
    54 @item @code{multBound}
    55 ????
     53@item @code{redTail}
     54@item @code{redThrough}
    5655@end itemize
    5756@c @end table
     57
     58Also the following settings now belong to individual (currently active) polynomial rings:
     59
     60@c @item @code{degBound}
     61@c @item @code{multBound}
     62
     63@c table @asis
     64@itemize @bullet
     65@item @code{short}
     66@item @code{minpoly}
     67@item @code{noether}
     68@end itemize
     69@c @end table
     70
    5871
    5972Hence setting these options only affects the current ring. Be aware of this
     
    8194@c table @asis
    8295@itemize @bullet
    83 @item The tree structure of the binary Singular distribution has been changed. The typical tree now looks as follows:
    84       *** add tree ***
     96@item The tree structure of the binary Singular distribution has been changed.
     97The typical tree now looks as show at @uref{https://github.com/Singular/Sources/wiki/Sw-tree}
    8598
    8699@item Accordingly Singular search paths (where Singular searches for libraries, dynamic modules, etc.) have been changed. You can display them by calling Singular by @code{Singular -v}.
     
    148161
    149162In particular we have separated everything related to coeffcient rings into a separate library @code{libcoeffs}.
     163Dependency tree between restructured packages is show at @uref{http://www.mathematik.uni-kl.de/~motsak/dox/singular.png}
    150164
    151165@end itemize
     
    154168
    155169
    156 @subsubheading Changes to build system
    157 @cindex Changes to build system
     170@c @subsubheading Changes to build system
     171@c @cindex Changes to build system
     172
    158173
    159174@c ---------------------------------------------------------------------------
Note: See TracChangeset for help on using the changeset viewer.