Changeset 4bde6b in git


Ignore:
Timestamp:
May 15, 2020, 3:20:00 PM (3 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '2234726c50d679d6664181a5c72f75a6fd64a787')
Children:
a1b40ab8675488c2a4f8e225d9d748ba70340727
Parents:
538e06d0809adf9f75fea000cf70d354bb674ab5
Message:
spelling p1
Files:
78 edited

Legend:

Unmodified
Added
Removed
  • Singular/HOWTO.addKernelCmds

    r538e06 r4bde6b  
    5959  NO_ZERODIVISOR: coefficients/cring elements must be a domain
    6060
    61   if a requirement from a group is ommited,
     61  if a requirement from a group is omited,
    6262  the defaults are:  NO_PLURAL | NO_RING | ALLOW_ZERODIVISOR
    6363
  • Singular/LIB/grobcov.lib

    r538e06 r4bde6b  
    14891489        ideals with P included in Q, representing the set
    14901490        V(P) \ V(Q) = V(N) \ V(M)
    1491 KEYWORDS: locally closed set; canoncial form
     1491KEYWORDS: locally closed set; canonical form
    14921492EXAMPLE:  Crep; shows an example"
    14931493{
     
    15891589       Output: [Comp_1, .. , Comp_s ] where
    15901590       Comp_i=[p_i,[p_i1,..,p_is_i]]
    1591 KEYWORDS: locally closed set; canoncial form
     1591KEYWORDS: locally closed set; canonical form
    15921592EXAMPLE:  Prep; shows an example"
    15931593{
     
    16861686       P included in Q, representing the
    16871687       set V(P) \ V(Q)
    1688 KEYWORDS: locally closed set; canoncial form
     1688KEYWORDS: locally closed set; canonical form
    16891689EXAMPLE:  PtoCrep; shows an example"
    16901690{
  • Singular/LIB/realizationMatroids.lib

    r538e06 r4bde6b  
    542542    list lweight;
    543543    int i_rdim = -1;
    544     //substitute the vectors by a primitve one and store the multiplicities
     544    //substitute the vectors by a primitive one and store the multiplicities
    545545    for(i=1;i<=size(lInput);i++)
    546546    {
  • Singular/LIB/realrad.lib

    r538e06 r4bde6b  
    88OVERVIEW:
    99   Algorithms about the computation of the real
    10    radical of an arbitary ideal over the rational numbers
     10   radical of an arbitrary ideal over the rational numbers
    1111   and transcendetal extensions thereof
    1212
     
    1414 realpoly(f);     Computes the real part of the univariate polynomial f
    1515 realzero(j);     Computes the real radical of the zerodimensional ideal j
    16  realrad(j);      Computes the real radical of an arbitary ideal over
     16 realrad(j);      Computes the real radical of an arbitrary ideal over
    1717                  transcendental extension of the rational numbers
    1818";
     
    3535//////////////////////////////////////////////////////////////////////////////
    3636proc realrad(ideal id)
    37 "USAGE: realrad(id), id an ideal of arbitary dimension
     37"USAGE: realrad(id), id an ideal of arbitrary dimension
    3838RETURN: the real radical of id
    3939EXAMPE: example realrad; shows an example"
     
    126126
    127127/*static*/ proc zeroreduct(ideal i)
    128 "USAGE:zeroreduct(i), i an arbitary ideal
     128"USAGE:zeroreduct(i), i an arbitrary ideal
    129129RETURN: an ideal j of dimension <=0 s.th. i is contained in
    130130        j and j is contained in i_{Iso} which is the zariski closure
     
    312312
    313313   //this will act via a coordinate chance into general position
    314    //denote that this random chance doesn't work allways
     314   //denote that this random chance doesn't work always
    315315   //the ideas for the transformation into general position are
    316316   //used from the primdec.lib
     
    490490///////////////////////////////////////////////////////////////////////////////
    491491proc decision(poly f)
    492 " USAGE: decission(f); a multivariate polynomial f in Q[x_1,..,x_n] and lc f=0
     492"USAGE: decision(f); a multivariate polynomial f in Q[x_1,..,x_n] and lc f=0
    493493 RETURN: assume that the basering has a lexicographical ordering,
    494494         1 if f is positive semidefinite  0 if f is indefinite
     
    873873   (a*b!=1)
    874874   //polynomials are contineous so the image is an interval
    875    //referres to analysis
     875   //referes to analysis
    876876   {
    877877      return(1);
     
    898898RETURN: a list erg=(id,j); where id is the real radical of m if j=1 (i.e. m
    899899        satisfies the shape lemma in one variable x_i) else id=m and j=0;
    900 EXAMPLE: is_in_shape shows an exmaple;
     900EXAMPLE: is_in_shape shows an example;
    901901"
    902902
     
    974974static proc length(poly f)
    975975"USAGE:    length(f); poly f;
    976 RETURN:    sum of the absolute Value of all coeffients of an irreducible
    977            poly nomial f
     976RETURN:    sum of the absolute Value of all coefficients of an irreducible
     977           polynomial f
    978978EXAMPLE:   example length; shows an example"
    979979
     
    11791179    setring r;
    11801180
    1181     //id only consits of non units in F(pari)
     1181    //id only consists of non units in F(pari)
    11821182    if (tester==1)
    11831183    {
  • Singular/LIB/recover.lib

    r538e06 r4bde6b  
    837837               C[k,1]=Co[2,j];
    838838               break;//we dont need to check any other elements of M
    839                //since theyre all different
     839               //since they are all different
    840840            }
    841841         }
     
    859859   //returns the concatenated coef matrices
    860860   //more precisely: let m be the degree of the elements of L[size(L)], then we want
    861    //to know, which homogenous polynomials of degree m can be written as a combination
     861   //to know, which homogeneous polynomials of degree m can be written as a combination
    862862   //of polynomials in the ideals contained in L. In particular, we want to know which
    863863   //of the elements of L[size(L)] can be written as a combination of other polys
     
    15521552   //bound to the basering, so it will exist in the ring r, as well. But, as we change
    15531553   //the entries of p from type string to type number/poly, it gets bound to the ring r,
    1554    //so it doesnt exist in br anymore. Hence, we have do define list p=fetch.
     1554   //so it doesn't exist in br anymore. Hence, we have do define list p=fetch.
    15551555
    15561556
     
    24382438   //to be eliminated. -> The number of variables and the number of components in
    24392439   //the projected point are the same. Then we can apply our procedure and imap the
    2440    //results to our original ring, since we didnt change the names of the variables.
     2440   //results to our original ring, since we didn't change the names of the variables.
    24412441   def br=basering;
    24422442   list l=ringlist(br);
     
    25672567   {
    25682568      //check whether there is an i sth eucl(Bs[i,i]) <= 4/3*euclid(Bs[i+1,i])
    2569       //if so, thats fine
     2569      //if so, that's fine
    25702570      //if not, b_i and b_i+1 are swapped + we do the necessary changes in Bs and U
    25712571      if(inner_product(B[i],B[i]) <= (301/300)*inner_product(B[i+1],B[i+1]))
  • Singular/LIB/redcgs.lib

    r538e06 r4bde6b  
    224224}
    225225
    226 //*************Auxilliary routines**************
     226//*************Auxiliary routines**************
    227227
    228228// cld : clears denominators of an ideal and normalizes to content 1
     
    399399}
    400400
    401 //*************Auxilliary routines**************
     401//*************Auxiliary routines**************
    402402
    403403
     
    418418// simpqcoeffs : simplifies a quotient of two polynomials of @R
    419419//               for ring @R
    420 // input: two coeficients (or terms) of @R (that are considered as quotients)
    421 // output: the two coeficients reduced without common factors
     420// input: two coefficients (or terms) of @R (that are considered as quotients)
     421// output: the two coefficients reduced without common factors
    422422proc simpqcoeffs(poly n,poly m)
    423423{
     
    12981298            [8] condition that was taken to reach the vertex
    12991299                (poly 1, for the root).
    1300           The remaning elements of the list represent vertices of the tree:
     1300          The remaining elements of the list represent vertices of the tree:
    13011301          with the same structure:
    13021302            [1] label: intvec (1,0,0,1,...) gives its position in the tree:
     
    13231323          The content of buildtree can be written in a file that is readable
    13241324          by Maple in order to plot its content using buildtreetoMaple;
    1325           The file written by buildtreetoMaple when readed in a Maple
     1325          The file written by buildtreetoMaple when read in a Maple
    13261326          worksheet can be plotted using the dbgb routine tplot;
    13271327
     
    13951395}
    13961396
    1397 // recbuildtree: auxilliary recursive routine called by buildtree
     1397// recbuildtree: auxiiary recursive routine called by buildtree
    13981398proc recbuildtree(list v, list P)
    13991399{
     
    15341534
    15351535// writes the list L=buildtree(F) to a file "writefile" that
    1536 // is readable by Maple whith name T
     1536// is readable by Maple with name T
    15371537// input:
    15381538//   L: the list output by buildtree
     
    15401540//   writefile: the name of the datafile where the output is to be stored
    15411541// output:
    1542 //   the result is written on the datafile "writefile" containig
    1543 //   the assignement to the table with name "T"
     1542//   the result is written on the datafile "writefile" containing
     1543//   the assignment to the table with name "T"
    15441544proc buildtreetoMaple(list L, string T, string writefile)
    15451545"USAGE:   buildtreetoMaple(T, TM, writefile);
     
    18431843// two polynomials (the first one contains all the terms of f
    18441844// and the second only those of f
    1845 // it returns the list with the comon monomials and the list of coefficients
     1845// it returns the list with the common monomials and the list of coefficients
    18461846// of the polynomial f with zeroes if necessary.
    18471847proc adaptcoef(matrix m, matrix m1)
     
    18641864}
    18651865
    1866 // given teh ideal of non-null conditions and an intvec lambda
     1866// given the ideal of non-null conditions and an intvec lambda
    18671867// with the exponents of each w in W
    18681868// it returns the polynomial prod (w_i)^(lambda_i).
     
    24662466             // first element of the output of selectcases
    24672467  list T1=T; // the initial list; it is only actualized (split)
    2468              // when a segment is completly revised (all split are
     2468             // when a segment is completely revised (all split are
    24692469             // already be considered);
    24702470             // ( (lpp, ((lab,B,N,W,L),.. ()) ), .. (..) )
     
    29192919
    29202920// addcase
    2921 // recursive routine that adds to the list @L, (an alredy GCS)
     2921// recursive routine that adds to the list @L, (an already GCS)
    29222922// a new redspec rs=(N,W,L);
    29232923// and returns the test t whose value is
     
    30753075// given the label labfu of the vertex fu it returns the last
    30763076// int of the label of the last existing children.
    3077 // if no child exists, then it ouputs 0.
     3077// if no child exists, then it outputs 0.
    30783078proc lastchildrenindex(intvec labfu)
    30793079{
     
    31013101
    31023102// given the vertex u it provides the next brother of u.
    3103 // if it does not exist, then it ouputs v=list(list(intvec(0)),0)
     3103// if it does not exist, then it outputs v=list(list(intvec(0)),0)
    31043104proc nextbrother(intvec labu)
    31053105{
     
    32873287          integers in the label are to be considered as additive and those
    32883288          with an odd number of integers in the label are to be considered as
    3289           substraction. As an example consider the following vertices:
     3289          subtraction. As an example consider the following vertices:
    32903290          v1=((i),2,lpp,B),
    32913291          v2=((i,1),2,P_{(i,1)}),
     
    36303630          integers in the label are to be considered as additive and those
    36313631          with an odd number of integers in the label are to be considered as
    3632           substraction. As an example consider the following vertices:
     3632          subtraction. As an example consider the following vertices:
    36333633          v1=((i),2,lpp,B),
    36343634          v2=((i,1),2,P_{(i,1)}),
     
    38123812          integers in the label are to be considered as additive and those
    38133813          with an odd number of integers in the label are to be considered as
    3814           substraction. As an example consider the following vertices:
     3814          subtraction. As an example consider the following vertices:
    38153815          v1=((i),2,lpp,B),
    38163816          v2=((i,1),2,P_{(i,1)}),
  • Singular/LIB/resbinomial.lib

    r538e06 r4bde6b  
    2323 maxEord(Coef,Exp,k,n,flag);        computes de maximum E-order of an ideal given by Coef and Exp
    2424 ECoef(Coef,expP,sP,V,auxc,n,flag); Computes a simplified version of the E-Coeff ideal. The E-orders are correct,
    25                                     but tranformations of coefficients of the generators and powers of binomials
     25                                    but transformations of coefficients of the generators and powers of binomials
    2626                                    cannot be computed easily in terms of lists.
    2727 elimrep(L);                        removes repeated terms from a list
     
    132132proc identifyvar()
    133133"USAGE: identifyvar();
    134 COMPUTE: Asign 0 to variables x and 1 to variables y, only necessary at the beginning
     134COMPUTE: Assign 0 to variables x and 1 to variables y, only necessary at the beginning
    135135RETURN: list, say l, of size the dimension of the basering
    136136        l[i] is: 0 if the i-th variable is x(i),
     
    158158proc data(ideal K,int k,int n)
    159159"USAGE: data(K,k,n); K any ideal, k integer (!=0), n integer (!=0)
    160 COMPUTE: Construcs a list with the coefficients and exponents of one ideal
     160COMPUTE: Constructs a list with the coefficients and exponents of one ideal
    161161RETURN: lists of coefficients and exponents of K
    162162EXAMPLE: example data; shows an example
     
    719719        }
    720720
    721 // NOTE: coeficients of I = coeficients of J, because I and J differ in a monomial
     721// NOTE: coefficients of I = coefficients of J, because I and J differ in a monomial
    722722
    723723// Detecting errors, negative exponents in expI
     
    10021002  LL[6];  // list of D_4,D_3,D_2,D_1
    10031003  LL[7];  // list of H_4,H_3,H_2,H_1 (exceptional divisors)
    1004   LL[8];  // list of all exceptional divisors acumulated
     1004  LL[8];  // list of all exceptional divisors accumulated
    10051005  LL[9];  // auxiliary invariant
    10061006  LL[10]; // intvec pointing out the last step where the function t has dropped
     
    16531653
    16541654              idchart=idchart+1;}
    1655 else{     // OTHERWISE, CONTINUE CHEKING IF newI=0 or not
     1655else{     // OTHERWISE, CONTINUE CHECKING IF newI=0 or not
    16561656
    16571657Coef=extraL[1];
     
    18421842// else{def r=basering;}   // CHECK THAT IS NECESSARY !!!
    18431843
    1844 // IF WE ARE IN POSTIVE CHAR
     1844// IF WE ARE IN POSITIVE CHAR
    18451845
    18461846if (p>0){list Lring=ringlist(basering);
     
    26252625"USAGE: tradtoideal(a,J2,flag);
    26262626        a intvec, J2 ideal, flag list
    2627 COMPUTE: traslate to an ideal the intvec defining the center
     2627COMPUTE: translate to an ideal the intvec defining the center
    26282628RETURN: the ideal of the center, given by the intvec a, or J2 if a=0
    26292629EXAMPLE: example tradtoideal; shows an example
  • Singular/LIB/resjung.lib

    r538e06 r4bde6b  
    129129  setring A;
    130130  list fibreP = buildFP(embresolvee,NoetherN,phi);
    131   //a list of lists, where fibreP[i] contains the information conserning
     131  //a list of lists, where fibreP[i] contains the information concerning
    132132  //the i-th chart of the fibrepoduct
    133133  //fibreP[i] is the ring; QIdeal the quotientideal; BMap is the map from A
     
    330330  poly product=1;
    331331  kill l;
    332   for(int i=1; i < n-1; i++){ //elimination of all variables exept var(i),var(n-1),var(n)
     332  for(int i=1; i < n-1; i++){ //elimination of all variables except var(i),var(n-1),var(n)
    333333    intvec v;
    334334    for(int j=1; j < n-1; j++){
     
    361361    if(attrib(J,"isPrincipal")==0){
    362362      setring R;
    363       for(int j = 1;j<=size(J);j++){//determines the monic polynomial in var(i) with coefficents in C2
     363      for(int j = 1;j<=size(J);j++){//determines the monic polynomial in var(i) with coefficients in C2
    364364        intvec w = leadexp(J[j]);
    365365        attrib(w,"isMonic",1);
     
    389389  ideal I = preimage(A,LastTwo,lowdim);
    390390  clocus= radical(intersect(clocus,I));
    391   //radical is necessary since the resultant is in gerneral not reduced
     391  //radical is necessary since the resultant is in general not reduced
    392392  export(clocus);
    393393  return(C2);
     
    543543              list blowup = blowUpBO(BO,primdecSL[index][2],3);
    544544              //if it has a rational singularity blow it up else choose
    545               //some arbitary singular point
     545              //some arbitrary singular point
    546546              if(attrib(primdecSL[1],"isRational")==0){
    547               //if we blow up a non rational singularity the exeptional divisors
     547              //if we blow up a non rational singularity the exceptional divisors
    548548              //are reduzible so we need to separate them
    549549                for(int k=1;k<=size(blowup);k++){
  • Singular/LIB/resolve.lib

    r538e06 r4bde6b  
    536536@*       J  = ideal containing W,
    537537@*       C  = ideal containing J
    538 COMPUTE: the blowing up of BO[1] in C, the exeptional locus, the strict
     538COMPUTE: the blowing up of BO[1] in C, the exceptional locus, the strict
    539539         transform of BO[2]
    540540NOTE:    blowUpBO may be applied to basic objects in the sense of
     
    587587   if(e==2){noDel=1;}
    588588//---this is only for curves and surfaces
    589 //---keeps all charts with relevant informations on the exceptional divisors
     589//---keeps all charts with relevant information on the exceptional divisors
    590590   if(e==3){keepDiv=1;}
    591591   if( typeof(attrib(BO[2],"isEqui"))=="int" )
     
    863863     {
    864864        delCharts[i+1]=1;
    865 //--- the i-th chart will be marked for deleting because all informations
     865//--- the i-th chart will be marked for deleting because all information
    866866//--- are already contained in the union of the remaining charts
    867867     }
     
    909909           if(m)
    910910           {
    911 //--- the i-th chart will be marked for deleting because all informations
     911//--- the i-th chart will be marked for deleting because all information
    912912//--- are already contained in the union of the remaining charts
    913913              delCharts[i+1]=1;
     
    960960              if(m==1)
    961961              {
    962 //--- the i-th chart will be marked for deleting because all informations
     962//--- the i-th chart will be marked for deleting because all information
    963963//--- are already contained in the union of the remaining charts
    964964                 delCharts[i+1]=1;
     
    971971                 {
    972972//--- in case of the option extra
    973 //--- the i-th chart will be marked for deleting because all informations
     973//--- the i-th chart will be marked for deleting because all information
    974974//--- are already contained in the union of the remaining charts
    975975
     
    21792179static proc invGreater(intmat M1, intmat M2, intvec iv1, intvec iv2)
    21802180{
    2181 // Auxilliary procedure, BM-algorithm
     2181// Auxiliary procedure, BM-algorithm
    21822182   int i;
    21832183   for(i=1;i<=min(ncols(M1),ncols(M2));i++)
     
    22082208proc CenterTail(list BM, ideal C)
    22092209{
    2210 //!!! Auxilliary procedure, BM-algorithm
     2210//!!! Auxiliary procedure, BM-algorithm
    22112211//!!!!!!!!Rueckgabe im Zentrumsformat
    22122212  int i,j,bmin;
     
    30503050           {
    30513051//--- intersections with E do not meet conditions ==> reset
    3052               ERROR("reset in Coeff, please send the example to the autors");
     3052              ERROR("reset in Coeff, please send the example to the authors");
    30533053           }
    30543054         }
     
    39233923@*       j4: value 0 or 8; turn off or on debugCoeff
    39243924@*       j5: value 0 or 16:turn off or on debugging of Intersection with E^-
    3925 @*       j6: value 0 or 32:turn off or on stop after pass throught the loop
     3925@*       j6: value 0 or 32:turn off or on stop after pass through the loop
    39263926@*       i=j1+j2+j3+j4+j5+j6
    39273927RETURN:  a list l of 2 lists of rings
  • Singular/LIB/reszeta.lib

    r538e06 r4bde6b  
    13681368//--- compute the Euler characteristic of the Ei,Eij,Eijk and the
    13691369//--- corresponding Ei^*,Eij^*,Eijk^* by preparing the input to the
    1370 //--- specialized auxilliary procedures and then recombining the results
     1370//--- specialized auxiliary procedures and then recombining the results
    13711371
    13721372//----------------------------------------------------------------------------
     
    15341534//--- compute the Euler characteristic of the Ei,Eij,Eijk and the
    15351535//--- corresponding Ei^*,Eij^*,Eijk^* by preparing the input to the
    1536 //--- specialized auxilliary procedures and then recombining the results
     1536//--- specialized auxiliary procedures and then recombining the results
    15371537
    15381538//----------------------------------------------------------------------------
     
    17161716@*        L    = list of rings
    17171717ASSUME:   L is the output of resolution of singularities
    1718 RETRUN:   discrepancies of the given resolution"
     1718RETURN:   discrepancies of the given resolution"
    17191719{
    17201720//----------------------------------------------------------------------------
     
    17801780                     ast[2]=chi(Eij^*)
    17811781                     ast[3]=chi(Eijk^*)
    1782           l[3]: intvec nu of multiplicites as needed in computation of zeta
     1782          l[3]: intvec nu of multiplicities as needed in computation of zeta
    17831783                function
    1784           l[4]: intvec N of multiplicities as needed in compuation of zeta
     1784          l[4]: intvec N of multiplicities as needed in computation of zeta
    17851785                function
    17861786          l[5]: string specifying characteristic polynomial of monodromy,
     
    40304030"
    40314031{
    4032 //--- auxilliary procedure for collectDiv,
     4032//--- auxiliary procedure for collectDiv,
    40334033//--- inserting an entry at the correct place
    40344034   int i=1;
     
    48024802      algext=attrib(idname,"algext");
    48034803   }
    4804 //--- check wheter comPa is in the history of m1
     4804//--- check whether comPa is in the history of m1
    48054805//--- same test for o1 can be done later on (on the fly)
    48064806   if(m1==comPa)
     
    54235423"
    54245424{
    5425 //--- auxilliary procedure for addSelfInter
     5425//--- auxiliary procedure for addSelfInter
    54265426//--- compute multiplicity, suitable for the special situation there
    54275427  int d=1;
  • Singular/LIB/ring.lib

    r538e06 r4bde6b  
    1717 imapall(R[,str]);        imap all objects of ring R to basering
    1818 mapall(R,i[,str]);       map all objects of ring R via ideal i to basering
    19  ord_test(R);             test wether ordering of R is global, local or mixed
     19 ord_test(R);             test whether ordering of R is global, local or mixed
    2020 ringtensor(s,t,..);      create ring, tensor product of rings s,t,...
    2121 ringweights(r);          intvec of weights of ring variables of ring r
     
    3030 hasQQCoefficient         check if the coefficient ring is QQ
    3131 hasNumericCoeffs(rng)    check for use of floating point numbers
    32  hasCommutativeVars(rng)  non-commutive or commnuative polynomial ring
     32 hasCommutativeVars(rng)  non-commutative or commutative polynomial ring
    3333 hasGlobalOrdering(rng)   global versus mixed/local monomial ordering
    3434 hasMixedOrdering()       mixed versus global/local ordering
     
    10281028proc hasAlgExtensionCoefficient(def rng )
    10291029"USAGE: hasAlgExtensionCoefficient ( rng );
    1030 RETURN:  1 if the coeffcients are an algebraic extension, 0 otherwise.
     1030RETURN:  1 if the coefficients are an algebraic extension, 0 otherwise.
    10311031KEYWORDS: ring coefficients
    10321032EXAMPLE: example hasAlgExtensionCoefficient; shows an example
     
    10481048proc hasTransExtensionCoefficient(def rng )
    10491049"USAGE: hasTransExtensionCoefficient ( rng );
    1050 RETURN:  1 if the coeffcients are rational functions, 0 otherwise.
     1050RETURN:  1 if the coefficients are rational functions, 0 otherwise.
    10511051KEYWORDS: ring coefficients
    10521052EXAMPLE: example hasTransExtensionCoefficient; shows an example
     
    10681068proc hasGFCoefficient(def rng )
    10691069"USAGE: hasGFCoefficient ( rng );
    1070 RETURN:  1 if the coeffcients are of the form GF(p,k), 0 otherwise.
     1070RETURN:  1 if the coefficients are of the form GF(p,k), 0 otherwise.
    10711071KEYWORDS: ring coefficients
    10721072EXAMPLE: example hasGFCoefficient; shows an example
     
    10891089proc hasZp_aCoefficient(def rng )
    10901090"USAGE: hasZp_aCoefficient ( rng );
    1091 RETURN:  1 if the coeffcients are of the form Zp_a(p,k), 0 otherwise.
     1091RETURN:  1 if the coefficients are of the form Zp_a(p,k), 0 otherwise.
    10921092KEYWORDS: ring coefficients
    10931093EXAMPLE: example hasZp_aCoefficient; shows an example
     
    11101110proc hasZpCoefficient(def rng )
    11111111"USAGE: hasZpCoefficient ( rng );
    1112 RETURN:  1 if the coeffcients are of the form ZZ/p, 0 otherwise.
     1112RETURN:  1 if the coefficcients are of the form ZZ/p, 0 otherwise.
    11131113KEYWORDS: ring coefficients
    11141114EXAMPLE: example hasZpCoefficient; shows an example
     
    11281128proc hasQQCoefficient(def rng )
    11291129"USAGE: hasQQCoefficient ( rng );
    1130 RETURN:  1 if the coeffcients are QQ, 0 otherwise.
     1130RETURN:  1 if the coefficcients are QQ, 0 otherwise.
    11311131KEYWORDS: ring coefficients
    11321132EXAMPLE: example hasQQCoefficient; shows an example
     
    11791179proc hasNumericCoeffs(def rng)
    11801180"USAGE: hasNumericCoeffs ( rng );
    1181 RETURN:  1 if rng has inexact coeffcients, 0 otherwise.
     1181RETURN:  1 if rng has inexact coefficcients, 0 otherwise.
    11821182KEYWORDS: floating point
    11831183EXAMPLE: example hasNumericCoeffs; shows an example
     
    12731273                     1:ordering dp,dp
    12741274                     2:oring.ordering,dp
    1275 RETURN:  a ring with the addtional variables
     1275RETURN:  a ring with the additional variables
    12761276EXAMPLE: example addvarsTo(); shows an example
    12771277"
     
    13141314                   1:ordering dp,dp
    13151315                   2:oring.ordering,dp
    1316 RETURN:  a ring with N addtional variables
     1316RETURN:  a ring with N additional variables
    13171317EXAMPLE: example addNvarsTo(); shows an example
    13181318"
  • Singular/LIB/rinvar.lib

    r538e06 r4bde6b  
    147147  // create a new basering which might contain more variables
    148148  // s(1..newVars) as the original basering and map the ideal
    149   // Gn (contians only z(1..newVars)) to this ring
     149  // Gn (contains only z(1..newVars)) to this ring
    150150
    151151  list l1; 
     
    858858         'action' is a linear group action of G on K^n (n = ncols(action))
    859859RETURN:  ideal of the nullcone of G.
    860 NOTE:    the generators of the nullcone are homogenous, but in general not invariant
     860NOTE:    the generators of the nullcone are homogeneous, but in general not invariant
    861861EXAMPLE: example NullCone; shows an example
    862862"
     
    10531053    if(defined(auxM)) { kill auxM;}
    10541054    matrix auxM[2][size(columnList)];      // built new matrix and omit
    1055     for(j = 1; j <= size(columnList); j++) {    // the linear dependent colums
     1055    for(j = 1; j <= size(columnList); j++)    // the linear dependent columns
     1056    {
    10561057      auxM[1, j] = decompMx[1, columnList[j]];    // found above
    10571058      auxM[2, j] = decompMx[2, columnList[j]];
  • Singular/LIB/rootisolation.lib

    r538e06 r4bde6b  
    598598proc evalPolyAtBox()
    599599"USAGE: @code{evalPolyAtBox(f, B)}; @code{f poly, B box}
    600 RETURN: interval, evalutaion of @code{f} at @code{B} using interval arithmetic
     600RETURN: interval, evaluation of @code{f} at @code{B} using interval arithmetic
    601601PURPOSE: computes an interval extension of the polynomial
    602602EXAMPLE: example evalPolyAtBox; shows an example"
     
    975975          // numbers and pass to the subring where these variables have been
    976976          // removed.
    977           // As rootIsolation now accpets ideals with arbitrary generators we
    978           // compute the zeros of the substituion ideal and reassemble the
     977          // As rootIsolation now accepts ideals with arbitrary generators we
     978          // compute the zeros of the substitution ideal and reassemble the
    979979          // boxes afterwards.
    980980          //
     
    14461446      for (k = 0; k < sizes[i]; k++)
    14471447      {
    1448         // repetions
     1448        // repetitions
    14491449        for (l = 1; l <= repCount[i]; l++)
    14501450        {
  • Singular/LIB/rootsmr.lib

    r538e06 r4bde6b  
    116116{
    117117  //Note on complexity: Let n = no of complex roots of I (= vdim(std(I)).
    118   //Then the algotithm needs:
     118  //Then the algorithm needs:
    119119  //1 std(I) and (1/2)n*(n+1)^2 ~ 1/2n^3 NF computations (of monomials w.r.t. I)
    120120
     
    399399  // We first compute the normal form of f w.r.t. I
    400400  g = reduce(f,I);
    401   int n = size(g);    //allways n <= N
     401  int n = size(g);    //always n <= N
    402402
    403403  while (k <= N) {
  • Singular/LIB/rstandard.lib

    r538e06 r4bde6b  
    1414   [1] A. Kehrein, M. Kreuzer, L. Robbiano: An algebrists view on border bases, in:
    1515       A. Dickenstein and I. Emiris (eds.), Solving Polynomial Equations:
    16        Foundations, Algorithms and Aplications, Springer, Heidelberg 2005, 169-202.
     16       Foundations, Algorithms and Applications, Springer, Heidelberg 2005, 169-202.
    1717
    1818   [2] V.P. Gerdt: Involute Algorithms for Computing Groebner Bases, In
  • Singular/LIB/sagbi.lib

    r538e06 r4bde6b  
    175175  ideal kern=stdKernPhi(kernNew,kernOld,leadTermsAlgebra,method);
    176176  dbprint(ppl-2,"//Spoly-2-1- ideal kern",kern);
    177   //-------------------------- calulate algebraic relations -----------------------
     177  //-------------------------- calculate algebraic relations -----------------------
    178178  dbprint(ppl,"//Spoly-3- computing new algebraic relations");
    179179  ideal algebraicRelations=nselect(kern,1..nvars(br));
     
    450450  ideal P=1;
    451451  //note: P is initialized this way, so that the while loop is entered.
    452   //P gets overriden there, anyhow.
     452  //P gets overridden there, anyhow.
    453453  ideal varsBasering=maxideal(1);
    454454  map phi;
     
    457457  while (size(P)>0)
    458458  {
    459     dbprint(ppl,"// -"+string(i)+"- interation of SAGBI construction algorithm");
     459    dbprint(ppl,"// -"+string(i)+"- interaction of SAGBI construction algorithm");
    460460    dbprint(ppl-1,"// -"+string(i)+"-1- Computing algebraic relations");
    461461    def rNew=spolynomialsGB(algebra,r,method); /* canonicalizing inside! */
     
    548548@*          - If meth=0 (default), the procedure std is used.
    549549@*          - If meth=1, the procedure slimgb is used.
    550 @*          - If meth=2, the prodecure uses toric_ideal.
     550@*          - If meth=2, the procedure uses toric_ideal.
    551551EXAMPLE:  example sagbiSPoly; shows an example"
    552552{
     
    889889
    890890        //Create two polynomial rings, which both are extensions of the current basering.
    891   //The first ring will contain the additional paramteres @c(1),...,@c(m), the second one
     891  //The first ring will contain the additional parameters @c(1),...,@c(m), the second one
    892892  //will contain the additional variables @c(1),...,@c(m), where m=ncols(I).
    893893  string parameterName=uniqueVariableName("@c");
     
    968968  //If K[x_1,...,x_n] was the basering, then algebra is in K(@c(1),...,@c(m))[x_1,...x_n]. We intersect
    969969  //elements in algebra with K(@c(1),..,@c(n)) to get algDep. Note that @c(i) can only appear in the numerator,
    970   //as the SAGBI construction algorithms just multiplies and substracts polynomials. So actually we have
     970  //as the SAGBI construction algorithms just multiplies and subtracts polynomials. So actually we have
    971971  //algDep=algebra intersect K[@c(1),...,@c(m)]
    972972  ideal algDep;
     
    10431043@format
    10441044    Three algorithm variants are used to perform subalgebra reduction.
    1045     The positive interger n determines which variant should be used.
     1045    The positive integer n determines which variant should be used.
    10461046    n may take the values 0 (default), 1 or 2.
    10471047@end format
     
    11361136    }
    11371137
    1138     //---------  test wether @(0)-h(@(1),...,@(z)) is in ker ---------------
     1138    //---------  test whether @(0)-h(@(1),...,@(z)) is in ker ---------------
    11391139    // for some poly h and divide by maximal power of q=#[1]
    11401140    poly h;
     
    11801180
    11811181proc sagbiNF(id,ideal dom,int k,list#)
    1182 "USAGE: sagbiNF(id,dom,k[,n]); id either poly or ideal,dom ideal, k and n positive intergers.
     1182"USAGE: sagbiNF(id,dom,k[,n]); id either poly or ideal,dom ideal, k and n positive integers.
    11831183RETURN: same as type of id; ideal or polynomial.
    11841184PURPOSE:
  • Singular/LIB/schreyer.lib

    r538e06 r4bde6b  
    88OVERVIEW:
    99The library contains several procedures for computing a/part of Schreyer
    10 resoltion (cf. [SFO]), and some helpers for derham.lib (which requires
     10resolution (cf. [SFO]), and some helpers for derham.lib (which requires
    1111resolutions over the homogenized Weyl algebra) for that purpose.
    1212The input for any resolution computation is a set of vectors M in form of a
  • Singular/LIB/schubert.lib

    r538e06 r4bde6b  
    681681OUTPUT:     a number corresponding to the normal bundle on a moduli space of
    682682            stable maps at a graph
    683 KEYWORDS:   normal bundle, graph, rational curves, mutiple covers, lines on
     683KEYWORDS:   normal bundle, graph, rational curves, multiple covers, lines on
    684684            hypersurfaces
    685685SEE ALSO:   contributionBundle
  • Singular/LIB/sets.lib

    r538e06 r4bde6b  
    2020(Set, list, int, bigint, string, intmat, bigintmat, intvec, ring, map, poly, matrix,
    2121ideal, module, vector, resolution) and also works for comparing of int, bigint and
    22 number with each other, similarily for matrix, bigintmat and intmat.
     22number with each other, similarly for matrix, bigintmat and intmat.
    2323
    2424The function size can be used to determine the number of elements.
     
    165165proc isEqualSet(def a, def b)
    166166{
    167   if(size(a)!=size(b)){                //check if the two sets have the same size
     167  if(size(a)!=size(b))             //check if the two sets have the same size
     168  {
    168169   return(0);
    169170  }
    170171  list L = a.elements;
    171   for(int i=1;i<=size(a);i++){                //chek if every element of the first set occurs in
    172     if(!(isElement(L[i],b))){        //the second set
     172  for(int i=1;i<=size(a);i++)      //check if every element of the first set occurs in
     173  {
     174    if(!(isElement(L[i],b)))       //the second set
     175    {
    173176      return(0);
    174177    }
  • Singular/LIB/sheafcoh.lib

    r538e06 r4bde6b  
    197197NOTE:    Output is a presentation matrix for the truncation of coker(M)
    198198         at d.
    199          Fast + experimental version. M shoud be a SB!
     199         Fast + experimental version. M should be a SB!
    200200DISPLAY: If @code{printlevel}>=1, step-by step timings will be printed.
    201201         If @code{printlevel}>=2 we add progress debug messages
  • Singular/LIB/sing.lib

    r538e06 r4bde6b  
    472472   if( vdim(k) == -1 )
    473473   {
    474        "// f is no isolated singuarity!";
     474       "// f is no isolated singularity!";
    475475       return();
    476476    }
  • Singular/LIB/solve.lib

    r538e06 r4bde6b  
    108108  }
    109109
    110   if(prot!=0)// more informations
     110  if(prot!=0)// more information
    111111  {
    112112    pout="//control: complex ring with precision "+string(numberprec);
     
    115115    if(solutionprec<numberprec){pout=pout+nl+
    116116        "//         with precision "+string(solutionprec);}}
    117     if(splitcontrol<0){pout=pout+nl+ "//       no spliting";}
     117    if(splitcontrol<0){pout=pout+nl+ "//       no splitting";}
    118118    if(splitcontrol==0){pout=pout+nl+"//       output without multiple roots";}
    119119    if(rootcheck){pout=pout+nl+
     
    448448    n=leadcoef(reduce(p,li));n=n/m;
    449449    if(n!=0)
    450     {if(nerr(n,pr)!=0){ERROR("Unsufficient accuracy!");}}
     450    {if(nerr(n,pr)!=0){ERROR("Insufficient accuracy!");}}
    451451  }
    452452}
     
    604604  }
    605605  if (outprec>prec){prec = outprec;}
    606   // if interaktive version is chosen -- choice of basering (Top::`outR`)
     606  // if interactive version is chosen -- choice of basering (Top::`outR`)
    607607  // and name for list of solutions (outL):
    608608  if (oldr==1)
     
    16271627        else
    16281628        {
    1629             dbprint( printlevel-voice+1,"// 30 ps == 0, thats not cool...");
     1629            dbprint( printlevel-voice+1,"// 30 ps == 0, that's not cool...");
    16301630            lsr=list(number(0));
    16311631        }
  • Singular/LIB/spcurve.lib

    r538e06 r4bde6b  
    528528  def r=basering;
    529529//---------------------------------------------------------------------------
    530 // Comparision entry by entry
     530// Comparison entry by entry
    531531//---------------------------------------------------------------------------
    532532  for(i=1; i<=nrows(N); i++)
  • Singular/LIB/standard.lib

    r538e06 r4bde6b  
    1010 groebner(ideal,...)    standard basis using a heuristically chosen method
    1111 res(ideal/module,[i])  free resolution of ideal or module
    12  sprintf(fmt,...)       returns fomatted string
     12 sprintf(fmt,...)       returns formatted string
    1313 fprintf(link,fmt,..)   writes formatted string to link
    1414 printf(fmt,...)        displays formatted string
    15  weightKB(stc,dd,vl)    degree dd part of a kbase w.r.t. some weigths
     15 weightKB(stc,dd,vl)    degree dd part of a kbase w.r.t. some weights
    1616 qslimgb(i)             computes a standard basis with slimgb in a qring
    1717 par2varRing([i])       create a ring making pars to vars, together with i
     
    359359
    360360//-------------------- go back to original ring ---------------------------
    361 //The main computation is done. Do not forget to simplfy before maping.
     361//The main computation is done. Do not forget to simplfy before mapping.
    362362
    363363  // subst 1 for homogenizing var
     
    413413         order in RL[3]. Then QL will be obtained from RL just by replacing
    414414         RL[4] by a standard of it with respect to this order. RL itself
    415          will be returnd if size(RL[4]) <= 1 (in which case it is known to be
     415         will be returned if size(RL[4]) <= 1 (in which case it is known to be
    416416         a standard basis w.r.t. any ordering) or if a second argument
    417417         \"isSB\" of type string is given.
     
    566566"USAGE:   hilbRing([w,l]); w = intvec, l = list of ideals/modules
    567567RETURN:  list, say L: L[1] is a ring and L[2] an intvec
    568          L[1] is a ring whith an extra homogenizing variable with name @,
     568         L[1] is a ring with an extra homogenizing variable with name @,
    569569         resp. @(i) if @ and @(1), ..., @(i-1) are defined.
    570570         The monomial ordering of L[1] is consists of 1 block: dp if the
     
    856856//   - Komplizierte Ordnungen (lp oder > 1 Block): hilb
    857857//V1 - Parameter werden grundsaetzlich nicht in Variable umgewandelt
    858 //V2 - Mehr als ein Parmeter wird zu Variable konvertiert
     858//V2 - Mehr als ein Parameter wird zu Variable konvertiert
    859859//   - fglm is keine Heuristik, da sonst vorher dim==0 peprueft werden muss
    860860
     
    10431043  //(Note:Singular counts always least 2 blocks, one is for module component):
    10441044  //Call a method "direct" if conversion=="no" && partovar="no" which means
    1045   //that we apply std or slimgb dircet in the basering (exception
     1045  //that we apply std or slimgb direct in the basering (exception
    10461046  //as long as slimgb does not know qrings: in a qring of a ring P
    10471047  //the ideal Qideal is added to the ideal and slimgb is applied in P).
     
    10761076//direct=="no" (i.e. "hilb" or "fglm" or "par2var" is given)
    10771077//or no method is given and we have a complicated monomial ordering
    1078 //V1: "par2var" is not a default strategy, it must be explicitely
     1078//V1: "par2var" is not a default strategy, it must be explicitly
    10791079//given in order to be performed.
    10801080//V2: "par2var" is a default strategy if there are more than 1 parameters
     
    19131913"SYNTAX: @code{datetime ()}
    19141914RETURN:  string
    1915 PURPOSE: return the curent date and time as a string
     1915PURPOSE: return the current date and time as a string
    19161916EXAMPLE: example datetime; shows an example
    19171917"
  • Singular/LIB/surf.lib

    r538e06 r4bde6b  
    2222PROCEDURES:
    2323 plot(I);    plots plane curves and surfaces
    24  surfer(I);  plots surfaces interactivly
     24 surfer(I);  plots surfaces interactively
    2525";
    2626
     
    3131RETURN: an intvec containing one entry for each ring variable.
    3232each contains the sums of all degrees in this variable of all monomials
    33 occuring in the ideal.
     33occurring in the ideal.
    3434An entry is zero if and only if the corresponding variable does not occur in the ideal.
    3535"
  • Singular/LIB/surf_jupyter.lib

    r538e06 r4bde6b  
    3232RETURN: an intvec containing one entry for each ring variable.
    3333each contains the sums of all degrees in this variable of all monomials
    34 occuring in the ideal.
     34occurring in the ideal.
    3535An entry is zero if and only if the corresponding variable does not occur in the ideal.
    3636"
  • Singular/LIB/surfacesignature.lib

    r538e06 r4bde6b  
    185185
    186186///////////////////////////////////////////////////////////////////////////////
    187 //------- sigma(z^N + f) in terms of the imbedded resolution graph of f -------
     187//------- sigma(z^N + f) in terms of the embedded resolution graph of f -------
    188188
    189189static proc dedekindSum(number b, number c, int a)
     
    275275static proc etaRes(list L, int K)
    276276//=== L total multiplicities
    277 //=== eta-invariant in terms of the imbedded resolution graph of f
     277//=== eta-invariant in terms of the embedded resolution graph of f
    278278{
    279279   int i,j,d;
     
    320320static proc signatureRes(int N, poly f)
    321321//=== computes signature of surface singularity defined by z^N + f(x,y) = 0
    322 //=== in terms of the imbedded resolution graph of f
     322//=== in terms of the embedded resolution graph of f
    323323{
    324324   list L = totalmultiplicities(f);
  • Singular/LIB/surfex.lib

    r538e06 r4bde6b  
    11961196If an additional argument # is given then l[1] changes:
    11971197l[1]: a standard basis of the primary ideal
    1198 Morever, there are some more entries:
     1198Moreover, there are some more entries:
    11991199l[5]: dim() of this primary ideal
    12001200l[6]: mult() of this primary ideal
  • Singular/LIB/symodstd.lib

    r538e06 r4bde6b  
    2020   version of the standard basis algorithm (improving the calculations in
    2121   positive characteristic). Therefore we only allow primes p such that p-1 is
    22    divisible by k. This guarantees the existance of a k-th primitive root of
     22   divisible by k. This guarantees the existence of a k-th primitive root of
    2323   unity in Z/pZ.
    2424
     
    650650// the intvec of n greatest primes p <= 2147483647 (resp. n greatest primes
    651651// < L[size(L)] union with L) such that each (p-1) is divisible by k, and none
    652 // of these primes divides any coefficient occuring in I
     652// of these primes divides any coefficient occurring in I
    653653// --> similar to procedure primeList in modstd.lib
    654654
  • Singular/LIB/tasks.lib

    r538e06 r4bde6b  
    260260          the latter command, t1 points to the same object as t2; any changes
    261261          to t2 will also effect t1. In contrast to this, copyTask() creates a
    262           new independend task.
     262          new independent task.
    263263       @* A task whose state is 'started' cannot be copied.
    264264SEE ALSO: getCommand, getArguments, getResult, getState, createTask, killTask,
     
    984984    }
    985985
    986     /* send the reqests */
     986    /* send the requests */
    987987    for (j = size(requests); j > 0; j--) {
    988988        write(requests[j][3], 1);
  • Singular/LIB/teachstd.lib

    r538e06 r4bde6b  
    2424 prodcrit(f,g[,o]);     test for product criterion
    2525 chaincrit(f,g,h);      test for chain criterion
    26  pairset(G);            pairs form G neither satifying prodcrit nor chaincrit
     26 pairset(G);            pairs form G neither satisfying prodcrit nor chaincrit
    2727 updatePairs(P,S,h);    pairset P enlarded by not useless pairs (h,f), f in S
    2828 standard(id);          standard basis of ideal/module
  • Singular/LIB/triang.lib

    r538e06 r4bde6b  
    5454
    5555    // Noetige Optionen setzen.
    56     // obachman: save options so that tey can be reset on exit
     56    // obachman: save options so that they can be reset on exit
    5757    intvec ovec = option(get);
    5858    option(redSB);
     
    222222
    223223    // Noetige Optionen setzen.
    224     // obachman: save options so that tey can be reset on exit
     224    // obachman: save options so that they can be reset on exit
    225225    intvec ovec = option(get);
    226226    option(redSB);
     
    832832
    833833    // Noetige Optionen setzen.
    834     // obachman: save options so that tey can be reset on exit
     834    // obachman: save options so that they can be reset on exit
    835835    intvec ovec = option(get);
    836836    option(redSB);
  • Singular/LIB/tropical.lib

    r538e06 r4bde6b  
    6161  cause any restriction.
    6262  If, however, for some reason you prefer to work with general vi, then you
    63   have to pass right away to the tropicalisation of the equations, whereever
     63  have to pass right away to the tropicalisation of the equations, wherever
    6464  this is allowed -- these are linear polynomials where the constant coefficient
    6565  corresponds to the valuation of the original coefficient and where
     
    125125  texDrawTriangulation()       computes texdraw commands for a triangulation
    126126
    127 AUXILARY PROCEDURES:
     127AUXILIARY PROCEDURES:
    128128  radicalMemberShip()     checks radical membership
    129129  tInitialFormPar()       computes the t-initial form of poly in Q(t)[x_1,...,x_n]
     
    152152
    153153///////////////////////////////////////////////////////////////////////////////
    154 /// Auxilary Static Procedures in this Library
     154/// Auxiliary Static Procedures in this Library
    155155///////////////////////////////////////////////////////////////////////////////
    156156/// - phiOmega
     
    266266@*             l[4] = list
    267267@*             l[5] = string
    268 @*       IF THE OPITON 'findAll' WAS SET, THEN:
     268@*       IF THE OPTION 'findAll' WAS SET, THEN:
    269269@*       list, containing ALL liftings of the given point ((w_1/w_0,...,w_n/w_0)
    270270               in the tropical variety of i to a point in V(i) over Puiseux
     
    335335    ERROR("The procedure is not implemented for rings with parameters. See: help tropicalLifting; for more information");
    336336  }
    337   // in order to avoid unpleasent surprises with the names of the variables
     337  // in order to avoid unpleasant surprises with the names of the variables
    338338  // we change to a ring where the variables have names t and x(1),...,x(n)
    339339  def ALTERRING=basering;
     
    631631        // note: it may happen, that when resubstituting PARA into
    632632        //       the replacement rules
    633         //       there occured some unexpected cancellation;
     633        //       there occurred some unexpected cancellation;
    634634        //       we only know that for SOME
    635635        //       solution of the zero-dimensional reduction NO
     
    695695          mp=phi(mp);
    696696          LIFT=phi(LIFT);
    697           // pass now to a ring whithout @a and with a as parameter
     697          // pass now to a ring without @a and with a as parameter
    698698          ring LIFTRING=(char(INTERRING),a),t,ls;
    699699          minpoly=number(imap(INTERRING,mp));
     
    10191019           and LIFT[2] describes how the old parameter can be computed from the new one
    10201020@*       - if a field extension with minimal polynomial of degree k was necessary,
    1021            then to the one extension produced acutally k extensions correspond by replacing
     1021           then to the one extension produced actually k extensions correspond by replacing
    10221022           the parameter a successively by all zeros of the minimal polynomial
    10231023@*       - if the option subst was set l[i][3] contains the polynomial where
     
    13461346                                         vectors defining an interior
    13471347                                         edge of the Newton subdivision
    1348                    l[size(l)][3] = intvec, the monmials occuring in l[i][5]
     1348                   l[size(l)][3] = intvec, the monomials occuring in l[i][5]
    13491349                                           have to be shifted by this vector
    13501350                                           in order to represent marked
     
    14011401  //    This does not change the tropical curve.
    14021402  //    however, we have to save (a,b), since the Newton
    1403   //    polygone has to be shifted by (-a,-b).
     1403  //    polygon has to be shifted by (-a,-b).
    14041404  poly aa,bb; // koeffizienten
    14051405  for (i=1;i<=size(tp);i++)
     
    14241424  //    defined by tp and the Newton subdivision
    14251425  list vtp=verticesTropicalCurve(tp,#);
    1426   //    if vtp is empty, then the Newton polygone is just
     1426  //    if vtp is empty, then the Newton polygon is just
    14271427  //    a line segment and constitutes a bunch of lines
    14281428  //    which can be computed by bunchOfLines
     
    14631463                    // and the entries of the second row will denote
    14641464                    //with which multiplicity
    1465     kill newton; // we kill the superflous list
     1465    kill newton; // we kill the superfluous list
    14661466  }
    14671467  // 3) Next we build for each part of the Newton
     
    14821482    kill ipairs;
    14831483  }
    1484   // 4) Check for all pairs of verticies in the Newton diagram if they
     1484  // 4) Check for all pairs of vertices in the Newton diagram if they
    14851485  //    occur in two different parts of the Newton subdivision
    14861486  int deleted; // if a pair occurs in two NSD, it can be removed
     
    19901990                     otherwise the result will be -1
    19911991NOTE:        - if the tropical curve is elliptic and its embedded graph has
    1992                precisely one loop, then the weigthed lattice length of
     1992               precisely one loop, then the weighted lattice length of
    19931993               the loop is its tropical j-invariant
    19941994@*           - the procedure checks if the embedded graph of the tropical
     
    21662166// tropcialJInvariant computes the tropical j-invariant of an elliptic curve
    21672167   tropicalJInvariant(t*(x3+y3+1)+1/t*(x2+y2+x+y+x2y+xy2)+1/t2*xy);
    2168 // the Newton polygone need not be the standard simplex
     2168// the Newton polygon need not be the standard simplex
    21692169   tropicalJInvariant(x+y+x2y+xy2+1/t*xy);
    21702170// the curve can have arbitrary degree
     
    25472547  if (npars(basering)==0)
    25482548  {
    2549     ERROR("The basering has no paramter t.");
     2549    ERROR("The basering has no parameter t.");
    25502550  }
    25512551  int order,j;
     
    34523452   ";
    34533453  int i,j; // indices
    3454   list pairs,markings; // stores edges of the triangulation, respecively
     3454  list pairs,markings; // stores edges of the triangulation, respectively
    34553455  // the marked points for each triangle store the edges and marked
    34563456  // points of the triangle
     
    35303530
    35313531///////////////////////////////////////////////////////////////////////////////
    3532 /// Auxilary Procedures
     3532/// Auxiliary Procedures
    35333533///////////////////////////////////////////////////////////////////////////////
    35343534
     
    35683568
    35693569///////////////////////////////////////////////////////////////////////////////
    3570 /// Auxilary Procedures concerned with initialforms
     3570/// Auxiliary Procedures concerned with initialforms
    35713571///////////////////////////////////////////////////////////////////////////////
    35723572
     
    37913791
    37923792///////////////////////////////////////////////////////////////////////////////
    3793 /// Auxilary Procedures concerned with conics
     3793/// Auxiliary Procedures concerned with conics
    37943794///////////////////////////////////////////////////////////////////////////////
    37953795
     
    39123912EXAMPLE:     example randomPolyInT;   shows an example"
    39133913{
    3914   if (defined(t)!=-1) { ERROR("basering has no paramter t");}
     3914  if (defined(t)!=-1) { ERROR("basering has no parameter t");}
    39153915  int i,j,k;
    39163916  def BASERING=basering;
     
    39653965//////////////////////////////////////////////////////////////////////////////
    39663966//////////////////////////////////////////////////////////////////////////////
    3967 /// AUXILARY PROCEDURES, WHICH ARE DECLARED STATIC
     3967/// AUXILIARY PROCEDURES, WHICH ARE DECLARED STATIC
    39683968//////////////////////////////////////////////////////////////////////////////
    39693969//////////////////////////////////////////////////////////////////////////////
     
    43044304  // In the second form, we can replace that variable,
    43054305  // and divide by t as much as possible.
    4306   // Then there is again one term wihtout t -
     4306  // Then there is again one term without t -
    43074307  // the term of the variable with second least w.
    43084308  // So we can solve for this one again and also replace it in the first form.
     
    44084408        }
    44094409    }
    4410     ergl[A[2,j1]]=randomp;// else we put there the random oly g_i(t,x')
     4410    ergl[A[2,j1]]=randomp;// else we put there the random only g_i(t,x')
    44114411    erglini[A[2,j1]]=randomp1;
    44124412    randomp=0;
     
    44964496          }
    44974497      }
    4498       ergl[A[2,j1]]=randomp;// else we put there the random oly g_i(t,x')
     4498      ergl[A[2,j1]]=randomp;// else we put there the random only g_i(t,x')
    44994499      erglini[A[2,j1]]=randomp1;
    45004500      randomp=0;
     
    46344634  // new variables had to be added to the old base ring; if so, change to the new
    46354635  // ring in which the transformed i and m and the zero a of V(m) live; otherwise
    4636   // retreive i, a and m from btr
     4636  // retrieve i, a and m from btr
    46374637  if (size(btr)==1)
    46384638  {
     
    46564656  // then check if the (remaining) ideal has as solution
    46574657  // where the n-1st component is zero,
    4658   // and procede as before; do the same for the remaining variables;
     4658  // and proceed as before; do the same for the remaining variables;
    46594659  // this way we make sure that the remaining ideal has
    46604660  // a solution which has no component zero;
     
    47264726      // homogenise the ideal i with the first not yet
    47274727      // used variable in our ring, since gfan
    4728       // only handles homogenous ideals; in principle
     4728      // only handles homogeneous ideals; in principle
    47294729      // for this one has first to compute a
    47304730      // standard basis of i and homogenise that,
     
    49764976  }
    49774977  // move to a polynomial ring with global monomial ordering
    4978   // - the variable t is superflous
     4978  // - the variable t is superfluous
    49794979  ideal variablen;
    49804980  for (int j=1;j<=nvars(basering)-1;j++)
     
    49864986  // compute the associated primes of the initialideal
    49874987  // ordering the maximal ideals shall help to avoid
    4988   // unneccessary field extensions
     4988  // unnecessary field extensions
    49894989  list maximalideals=ordermaximalidealsNoabs(minAssGTZ(std(ini)),anzahlvariablen);
    49904990  ideal m=maximalideals[1][1];              // the first associated maximal ideal
     
    49944994  list a=maximalideals[1][4];               // a_k is the kth component of a
    49954995                                            // zero of m, if it is not zero
    4996   // eliminate from m the superflous variables, that is those ones,
     4996  // eliminate from m the superfluous variables, that is those ones,
    49974997  // which do not lead to a new variable
    49984998  poly elimvars=1;
     
    57955795          // homogenise the ideal II with the first not yet
    57965796          // used variable in our ring, since gfan
    5797           // only handles homogenous ideals; in principle for this
     5797          // only handles homogeneous ideals; in principle for this
    57985798          // one has first to compute a
    57995799          // standard basis of II and homogenise that,
     
    61886188      intvec newdeletedvariables=deletedvariables;
    61896189      newdeletedvariables[lastvar]=1;
    6190       // pass to a new ring whith one variable less
     6190      // pass to a new ring with one variable less
    61916191      if (anzahlvariablen>2)
    61926192      {
     
    62066206      // if not yet all variables have been checked,
    62076207      // then go on with the next smaller variable,
    6208       // else prepare the elimination ring and the neccessary
     6208      // else prepare the elimination ring and the necessary
    62096209      // information for return
    62106210      if (lastvar>1)
     
    62636263        // if not yet all variables have been tested, go on with the
    62646264        // next smaller variable
    6265         // else prepare the neccessary information for return
     6265        // else prepare the necessary information for return
    62666266        if (lastvar>1)
    62676267        {
     
    64146414  }
    64156415  // move to a polynomial ring with global monomial ordering
    6416   // - the variable t is superflous,
     6416  // - the variable t is superfluous,
    64176417  // the variable @a is not if it was already present
    64186418  RL[2]=VARIABLEN;
     
    64236423  // initialideal over the algebraic closure;
    64246424  // ordering the maximal ideals shall help to
    6425   // avoid unneccessary field extensions
     6425  // avoid unnecessary field extensions
    64266426  list absminass=absPrimdecGTZ(ini);
    64276427  def ABSRING=absminass[1]; // the ring in which the minimal
     
    67886788    }
    67896789  }
    6790   // if a vertex appears several times, only its first occurence will be kept
     6790  // if a vertex appears several times, only its first occurrence will be kept
    67916791  for (i=size(eckpunkte);i>=2;i--)
    67926792  {
     
    68106810             polynomial (in the form of the output of the procedure tropicalise)
    68116811             defining a bunch of ordinary lines in the plane,
    6812              i.e. the Newton polygone is a line segment
     6812             i.e. the Newton polygon is a line segment
    68136813RETURN:      list, see the procedure tropicalCurve for an explanation of
    68146814                   the syntax of this list
     
    68936893    }
    68946894  }
    6895   // if a vertex appears several times, only its first occurence will be kept
     6895  // if a vertex appears several times, only its first occurrence will be kept
    68966896  for (i=size(bunchoflines);i>=2;i--)
    68976897  {
     
    69076907  // sort the lines in an descending way according to the leading
    69086908  // exponent of the polynomial
    6909   // defining the Newton polygone
     6909  // defining the Newton polygon
    69106910  list nbol;
    69116911  list maximum;
     
    69706970                     entries in the second row have been added and only one
    69716971                     row has been kept;
    6972                      colums with a zero in the first row have been removed
     6972                     columns with a zero in the first row have been removed
    69736973                     unless vv has only one column
    69746974NOTE:        called by tropicalCurve"
     
    82348234// tropcial_j_invariant computes the tropical j-invariant of the elliptic curve f
    82358235tropicalJInvariant(t*(x3+y3+1)+1/t*(x2+y2+x+y+x2y+xy2)+1/t2*xy);
    8236 // the Newton polygone need not be the standard simplex
     8236// the Newton polygon need not be the standard simplex
    82378237tropicalJInvariant(x+y+x2y+xy2+1/t*xy);
    82388238// the curve can have arbitrary degree
  • Singular/LIB/tropicalNewton.lib

    r538e06 r4bde6b  
    242242      else
    243243      {
    244         ERROR("listDot: unkown or invalid relevant entry");
     244        ERROR("listDot: unknown or invalid relevant entry");
    245245      }
    246246    }
  • Singular/LIB/tst.lib

    r538e06 r4bde6b  
    578578RETURN:    1, if ok; 0 on error
    579579PURPOSE:   Tests sres, lres, hres, mres with betti commands and conversions
    580            If optinal third argument is given, test only lres and hres
     580           If optional third argument is given, test only lres and hres
    581581EXAMPLE:  example tst_test_res shows an example"
    582582{
     
    585585  if (! homog(i))
    586586  {
    587     ERROR("ERROR: input ideal needs to be homogenous ");
     587    ERROR("ERROR: input ideal needs to be homogeneous ");
    588588  }
    589589
  • Singular/LIB/zeroset.lib

    r538e06 r4bde6b  
    4646// note : return a ring : ring need not be exported !!!
    4747
    48 // Artihmetic in Q(a)[x] without built-in procedures
     48// Arithmetic in Q(a)[x] without built-in procedures
    4949// assume basering = Q[x,a] and minpoly is represented by mpoly(a).
    5050// the algorithms are taken from "Polynomial Algorithms in Computer Algebra",
     
    6767// 'mpoly' (attribute "isSB"). The arithmetic in the extension field is
    6868// implemented in the procedures in the procedures 'MultPolys' (multiplication)
    69 // and 'InvertNumber' (inversion). After addition and substraction one should
     69// and 'InvertNumber' (inversion). After addition and subtraction one should
    7070// apply 'SimplifyPoly' to the result to reduce the result w.r.t. 'mpoly'.
    71 // This is done by reducing each coefficient seperately, which is more
     71// This is done by reducing each coefficient separately, which is more
    7272// efficient for polynomials with many terms.
    7373
     
    817817{
    818818  // main work is done in zeroSetMainWork, here the zero-set of each ideal from the
    819   // primary decompostion is coputed by menas of zeroSetMainWork, and then the
     819  // primary decomposition is coputed by means of zeroSetMainWork, and then the
    820820  // minpoly and the parameter representing the algebraic extension are
    821   // transformed according to 'newA', i.e., only bookeeping is done.
     821  // transformed according to 'newA', i.e., only bookkeeping is done.
    822822
    823823  def altring=basering;
  • Singular/RULES

    r538e06 r4bde6b  
    1414- should compile with gcc/g++ version 2.9.3 to 4.x
    1515- should create correct code with gcc/g++ version 2.9.3 to 4.x : with
    16   well known exeptions
     16  well known exceptions
    1717  ( IA64: gcc 4.0.x, 4.1.x produce wrong code,
    1818    OsX: ..., etc.)
     
    3838Error messages:
    3939--------------
    40 - allways test for wrong input from the user,
     40- always test for wrong input from the user,
    4141  report errors via Werror/WerrorS, warnings via Warn/WarnS
    4242- trust other parts of Singular:
  • Singular/dyn_modules/python/README

    r538e06 r4bde6b  
    104104-raw operations (+,-,* creation of res...) should map directly to the Singular kernel (prefereable nice C++ wrapper classes in the kernel)
    105105- Wrapper classes in C++ should behave like canonical C++-Classes, no additional res.-management (with the exception of new, delete) should be required
    106 - never use currRing implicitely, always write out the currRing argument, if this isn't done consequently in my code, it would be nice of you to fix it
     106- never use currRing implicitly, always write out the currRing argument, if this isn't done consequently in my code, it would be nice of you to fix it
    107107- regularly check in, check out from CVS
    108108
  • Singular/dyn_modules/systhreads/README.md

    r538e06 r4bde6b  
    7474written to or existing elements retrieved from the channel.
    7575
    76 # Syncronization Variables
     76# Synchronization Variables
    7777
    7878Synchronization Variables are created via `makeSyncVar(uri)`. You can
  • Singular/dyn_modules/systhreads/doc/primitives.md

    r538e06 r4bde6b  
    7474written to or existing elements retrieved from the channel.
    7575
    76 # Syncronization Variables
     76# Synchronization Variables
    7777
    7878Synchronization Variables are created via `makeSyncVar(uri)`. You can
  • Singular/dyn_modules/systhreads/doc/threadpools.md

    r538e06 r4bde6b  
    8888`add2and2` job does not require any more arguments.
    8989
    90 Jobs can also be created from other jobs by pasing in a job argument
     90Jobs can also be created from other jobs by passing in a job argument
    9191instead of a function name as the first argument:
    9292
  • Tst/Old/README

    r538e06 r4bde6b  
    1515  (i.e. there are differences between the output and
    1616  the corresponding .res file),
    17   the name of unsuccessfull test file go to stderr
     17  the name of unsuccessful test file go to stderr
    1818
    1919To compare two versions of Singular do:
  • Tst/README

    r538e06 r4bde6b  
    1818Run
    1919  perl ./regress.cmd -h
    20 for a summary of the comand-line options of regress.cmd.
     20for a summary of the command-line options of regress.cmd.
    2121
    2222To test(s) correctness of Singular:
    2323-----------------------------------
    24241.) Put the Singular binary in this directory
    25     (prefered solution: ln -s <path_to_Singular_binary> Singular)
     25    (preferred solution: ln -s <path_to_Singular_binary> Singular)
    26262.) Run
    2727     perl ./regress.cmd [*.tst] [*.lst]
    2828    with the desired tst (i.e., Singular test scripts) or lst (list
    2929    of tst files -- see Old/universal.lst for an example) file(s).
    30     (prefered test scenario:
     30    (preferred test scenario:
    3131    perl ./regress.cmd Old/universal.lst Short/ok_s.lst Long/ok_l.lst
    3232    )
     
    3737    previously obtained results are found, regress.cmd exits with
    3838    status != 0, and, for each file xx.tst which lead to a
    39     difference, the coresponding files xx.new.res, xx.res, and xx.diff
     39    difference, the corresponding files xx.new.res, xx.res, and xx.diff
    4040    are kept, and differences are written to stdout.
    41415.) The Singular executable which is used for testing can
     
    6161    status != 0 if timing/memory performance is above specified
    6262    per-cent.
    63 6.) The timing/memory performance differenes which trigger an error
     636.) The timing/memory performance differences which trigger an error
    6464    (or, report) can be also be set: Either use
    6565      ./regress.cmd -[e,r] all%<val>
     
    7575of tst files).
    7676NOTE: Running regress.cmd with the -g option re-generates the result
    77 and stat files, i.e., all previous results and statisitics are
     77and stat files, i.e., all previous results and statistics are
    7878overwritten and lost!
    7979
  • doc/C-STYLEGUIDE.md

    r538e06 r4bde6b  
    8181    prefer inline functions:
    8282    - macros are not type safe
    83     + macros are allways inlined
     83    + macros are always inlined
    8484    - arguments to macros can be multiply computed
    8585
     
    121121  - use const wherever possible/suitable (especially in declarations of input
    122122    parameters to functions/methods provided as pointers or references or for
    123     methods that do not change the state of an object, consider delaring
     123    methods that do not change the state of an object, consider declaring
    124124    variables "mutable" whenever suitable)
    125125
  • doc/HOWTO-libsingular

    r538e06 r4bde6b  
    3535  poly p1=p_ISet(1,R);
    3636
    37   // create tthe polynomial 2*x^3*z^2
     37  // creat the polynomial 2*x^3*z^2
    3838  poly p2=p_ISet(2,R);
    3939  pSetExp(p2,1,3);
  • doc/NEWS.texi

    r538e06 r4bde6b  
    154154@item new data type @code{cring} to describe the coeffient rings, to be used
    155155      for the new definitions for (polynomial) rings (@nref{General syntax of a ring declaration})
    156 @item new command @code{ring_list} to access the parts used to contruct polynomial rings (@nref{ring_list},@nref{ringlist})
     156@item new command @code{ring_list} to access the parts used to construct polynomial rings (@nref{ring_list},@nref{ringlist})
    157157@item extended polynomial ring construction: also from lists produced by @code{ring_list}
    158158@item new attribute @code{ring_cf} for @code{ring} (@nref{attrib})
     
    267267@heading News for version 4-0-0
    268268
    269 Version 4-0-0 is a milestone relase of Singular.
     269Version 4-0-0 is a milestone release of Singular.
    270270The new release series 4 aims for an entirely modularized architecture
    271271simplifying connectivity with other systems and paving the way
  • doc/changes_in_singular4.texi

    r538e06 r4bde6b  
    2727@item d is changed with each release (i.e. with bug fixes, etc.)
    2828@end itemize
    29 @sc{Singular} does also have "unofficial" build orginating from
     29@sc{Singular} does also have "unofficial" build originating from
    3030a code version between "official" version: such builds display
    3131"Development version a.b.c" in the header while "official" versions
     
    5050@itemize @bullet
    5151@item setting @code{minpoly} results in changing the current coefficient domain
    52 and clears all previously defined varaiables of that ring
     52and clears all previously defined variables of that ring
    5353
    5454@item Minor changes in the output of coefficient ring description. Moreover the output of elements of certain rings has been improved (for example, reals).
     
    5959      bases and related computations. For example a Groebner basis element may differ by a unit.
    6060
    61 @item Most noteably, due to the redesign of the coefficient rings, if the user sets the minimal polynomial
     61@item Most notably, due to the redesign of the coefficient rings, if the user sets the minimal polynomial
    6262      all variables dependent on the current ring are deleted.
    6363
  • doc/sample_lib0.lib

    r538e06 r4bde6b  
    1111        { return(sum(j,k)); }
    1212  /* { and } does not need to be the
    13      first charater in line */
     13     first character in line */
    1414
    1515  //////////////////////////
  • doc/singcard.tex

    r538e06 r4bde6b  
    161161% \opt: print optional arguments
    162162% \alt: separate alternative arguments
    163 % \rep: denote repitition of arguments
     163% \rep: denote repetition of arguments
    164164% \rmslash: print a slash in roman type face
    165165% \eg, \ie: obvious
  • dox/Doxyfile.in

    r538e06 r4bde6b  
    16361636# following commands have a special meaning inside the header: $title,
    16371637# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
    1638 # $projectbrief, $projectlogo. Doxygen will replace $title with the empy string,
    1639 # for the replacement values of the other commands the user is refered to
     1638# $projectbrief, $projectlogo. Doxygen will replace $title with the empty string,
     1639# for the replacement values of the other commands the user is referred to
    16401640# HTML_HEADER.
    16411641# This tag requires that the tag GENERATE_LATEX is set to YES.
  • dox/Doxyfile.latex.short

    r538e06 r4bde6b  
    282282# probably good enough. For larger projects a too small cache size can cause
    283283# doxygen to be busy swapping symbols to and from disk most of the time
    284 # causing a significant performance penality.
     284# causing a significant performance penalty.
    285285# If the system has enough physical memory increasing the cache will improve the
    286286# performance by keeping more symbols in memory. Note that the value works on
    287 # a logarithmic scale so increasing the size by one will rougly double the
     287# a logarithmic scale so increasing the size by one will roughly double the
    288288# memory usage. The cache size is given by this formula:
    289289# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
  • emacs/BUGS

    r538e06 r4bde6b  
    33  trotzdem sichtbar bleiben (->Fehlermeldungen)
    44o singular-cursor-key-model aus customize speichern hat nicht funktioniert
    5 o loading file default coice/dir does not end with an "/"
     5o loading file default choice/dir does not end with an "/"
    66o no key binding for 'comint-interrupt-subjob
    77  (i.e., for interrupting Singular), should be extra menu item
  • emacs/singular.el

    r538e06 r4bde6b  
    109109  "Major debugging hook for singular.el.
    110110Evaluates FORM if `singular-debug' equals t or if MODE is an element
    111 of `singular-debug', othwerwise ELSE-FORM."
     111of `singular-debug', otherwise ELSE-FORM."
    112112  `(if (or (eq singular-debug t)
    113113           (memq ,mode singular-debug))
     
    323323;; rewrite large portions of Comint to adapt it to our needs.  At some
    324324;; point it came clear that it would be best to throw out Comint
    325 ;; alltogether, would not have been there some auxilliary functions which
     325;; all together, would not have been there some auxiliary functions which
    326326;; are really useful but annoying to rewrite.  These are, for example, the
    327327;; command line history functions or the completion stuff offered by
     
    621621(defconst singular-menu-initial-library-menu
    622622  '(["other..." (singular-load-library t) t])
    623   "Menu definition for the inital library sub menu.
     623  "Menu definition for the initial library sub menu.
    624624This should be a list of vectors.")
    625625
     
    677677
    678678This function is called by `singular-exec'."
    679   (singular-debug 'interactive (message "Initializing menue stuff"))
     679  (singular-debug 'interactive (message "Initializing menu stuff"))
    680680  (make-local-variable 'singular-standard-libraries-alist)
    681681  (make-local-variable 'singular-standard-libraries-with-categories))
     
    690690
    691691;; For some reasons emacs inserts new menus in the oppsite order.
    692 ;; Defining menu-2 prior to menu-1 will result in the follwoing menu:
     692;; Defining menu-2 prior to menu-1 will result in the following menu:
    693693;;   Singular   Commands
    694694;; That's what we want. So DO NOT exchange both (or ..) statements!
     
    790790  ;; is that really the simplest and fastest method?  The problem is that
    791791  ;; `re-search-backward' is not greedy so on an regexp as "\\([>.] \\)+"
    792   ;; it stops right after the first occurence of the sub-expression.
     792  ;; it stops right after the first occurrence of the sub-expression.
    793793  ;; Anyway, the `(- (point) 2)' expression is OK, even at bob.
    794794  (while (re-search-backward "[>.] " (- (point) 2) t)))
     
    12011201;;   section spans up to end of buffer?  By definition, eob is not included
    12021202;;   in that section since they are right-opened intervals.  Most of the
    1203 ;;   functions react as if there is an imagenary empty clear simple section
     1203;;   functions react as if there is an imaginary empty clear simple section
    12041204;;   at eob.
    12051205;; - Even though by now there are only two types of different simple
     
    13801380(defun singular-emacs-simple-sec-start-at (pos)
    13811381  "Return start of clear simple section at position POS.
    1382 Assumes the existence of an imagenary empty clear simple section if POS is
     1382Assumes the existence of an imaginary empty clear simple section if POS is
    13831383at end of buffer and there is non-clear simple section immediately ending
    13841384at POS.
    13851385Assumes that no narrowing is in effect (since `previous-overlay-change'
    1386 imlicitly does so)."
     1386implicitly does so)."
    13871387  ;; yes, this `(1+ pos)' is OK at eob for
    13881388  ;; `singular-emacs-simple-sec-before' as well as
     
    14011401(defun singular-emacs-simple-sec-end-at (pos)
    14021402  "Return end of clear simple section at position POS.
    1403 Assumes the existence of an imagenary empty clear simple section if POS is
     1403Assumes the existence of an imaginary empty clear simple section if POS is
    14041404at end of buffer and there is non-clear simple section immediately ending
    14051405at POS.
    14061406Assumes that no narrowing is in effect (since `next-overlay-change'
    1407 imlicitly does so)."
     1407implicitly does so)."
    14081408  (let ((next-overlay-change-pos (next-overlay-change pos)))
    14091409    ;; this `while' loop at last will run into the beginning of the next
     
    14191419(defun singular-emacs-simple-sec-at (pos)
    14201420  "Return simple section at buffer position POS.
    1421 Assumes the existence of an imagenary empty clear simple section if POS is
     1421Assumes the existence of an imaginary empty clear simple section if POS is
    14221422at end of buffer and there is non-clear simple section immediately ending
    14231423at POS.
     
    14391439startpoints in increasing order and clear simple sections (that is, nil's)
    14401440inserted as necessary.  BEG is assumed to be less than or equal to END.
    1441 The imagenary empty clear simple section at end of buffer is never included
     1441The imaginary empty clear simple section at end of buffer is never included
    14421442in the result.
    14431443Narrowing has no effect on this function."
     
    15781578(defun singular-xemacs-simple-sec-start-at (pos)
    15791579  "Return start of clear simple section at position POS.
    1580 Assumes the existence of an imagenary empty clear simple section if POS is
     1580Assumes the existence of an imaginary empty clear simple section if POS is
    15811581at end of buffer and there is non-clear simple section immediately ending
    15821582at POS.
    15831583Assumes that no narrowing is in effect (since `previous-extent-change'
    1584 imlicitly does so)."
     1584implicitly does so)."
    15851585  ;; get into some hairy details at end of buffer.  Look if there is a
    15861586  ;; non-clear simple section immediately ending at end of buffer and
    1587   ;; return the start of the imagenary empty clear simple section in that
     1587  ;; return the start of the imaginary empty clear simple section in that
    15881588  ;; case.  If buffer is empty this test fails since
    1589   ;; `singular-xemacs-simple-sec-before' (corretly) returns nil.  But in
     1589  ;; `singular-xemacs-simple-sec-before' (correctly) returns nil.  But in
    15901590  ;; that case the following loop returns the correct result.
    15911591  (if (and (eq pos (point-max))
     
    16051605(defun singular-xemacs-simple-sec-end-at (pos)
    16061606  "Return end of clear simple section at position POS.
    1607 Assumes the existence of an imagenary empty clear simple section if POS is
     1607Assumes the existence of an imaginary empty clear simple section if POS is
    16081608at end of buffer and there is non-clear simple section immediately ending
    16091609at POS.
    16101610Assumes that no narrowing is in effect (since `next-extent-change'
    1611 imlicitly does so)."
     1611implicitly does so)."
    16121612  (let ((next-extent-change-pos (next-extent-change pos)))
    16131613    ;; this `while' loop at last will run into the beginning of the next
     
    16231623(defun singular-xemacs-simple-sec-at (pos)
    16241624  "Return simple section at buffer position POS.
    1625 Assumes the existence of an imagenary empty clear simple section if POS is
     1625Assumes the existence of an imaginary empty clear simple section if POS is
    16261626at end of buffer and there is non-clear simple section immediately ending
    16271627at POS.
     
    16391639startpoints in increasing order and clear simple sections (that is, nil's)
    16401640inserted as necessary.  BEG is assumed to be less than or equal to END.
    1641 The imagenary empty clear simple section at end of buffer is never included
     1641The imaginary empty clear simple section at end of buffer is never included
    16421642in the result.
    16431643Narrowing has no effect on this function."
     
    17451745                     (const :format "" output)
    17461746                     (choice :format
    1747 "Choose either clear or non-clear ouput sections.  For non-clear sections,
     1747"Choose either clear or non-clear output sections.  For non-clear sections,
    17481748select or modify a face (preferably `singular-section-output-face') used to
    17491749display the sections.
     
    18271827           (> start (point-max)))
    18281828      (singular-section-create simple-sec type (point-max) (point-max)))
    1829      ;; restricted but not degenrated
     1829     ;; restricted but not degenerated
    18301830     (t
    18311831      (singular-section-create simple-sec type
  • emacs/singular.el.decl

    r538e06 r4bde6b  
    22------------------
    33private:        symbol is accessed only in same folding
    4 public:         symbol is accessed througout whole singular.el
     4public:         symbol is accessed throughout whole singular.el
    55semipub:        symbol is accessed only in a feq functions
    66                outside same folding.  Functions have to be
  • kernel/GBEngine/kutil.cc

    r538e06 r4bde6b  
    14181418  *the set B collects the pairs of type (S[j],p)
    14191419  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p) != lcm(r,p)
    1420   *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    1421   *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     1420  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     1421  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    14221422  */
    14231423
     
    20362036    *the set B collects the pairs of type (S[j],p)
    20372037    *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
    2038     *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    2039     *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     2038    *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     2039    *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    20402040    */
    20412041    {
     
    20802080      *i.e. lcm(s,p)=product of the leading terms of s and p.
    20812081      *Suppose (s,r) is in L and the leading term
    2082       *of p devides lcm(s,r)
    2083       *(==> the leading term of p devides the leading term of r)
    2084       *but the leading term of s does not devide the leading term of r
     2082      *of p divides lcm(s,r)
     2083      *(==> the leading term of p divides the leading term of r)
     2084      *but the leading term of s does not divide the leading term of r
    20852085      *(notice that tis condition is automatically satisfied if r is still
    20862086      *in S), then (s,r) can be canceled.
     
    21012101      *the set B collects the pairs of type (S[j],p)
    21022102      *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
    2103       *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    2104       *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     2103      *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     2104      *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    21052105      */
    21062106      for(j = strat->Bl;j>=0;j--)
     
    21922192    *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
    21932193    *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
    2194     *devide lcm(r,p)). In the last case (s,r) can be canceled if the leading
    2195     *term of p devides the lcm(s,r)
     2194    *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
     2195    *term of p divides the lcm(s,r)
    21962196    *(this canceling should be done here because
    21972197    *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
     
    23122312    *the set B collects the pairs of type (S[j],p)
    23132313    *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
    2314     *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    2315     *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     2314    *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     2315    *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    23162316    */
    23172317    {
     
    23522352    *i.e. lcm(s,p)=product of the leading terms of s and p.
    23532353    *Suppose (s,r) is in L and the leading term
    2354     *of p devides lcm(s,r)
    2355     *(==> the leading term of p devides the leading term of r)
    2356     *but the leading term of s does not devide the leading term of r
     2354    *of p divides lcm(s,r)
     2355    *(==> the leading term of p divides the leading term of r)
     2356    *but the leading term of s does not divide the leading term of r
    23572357    *(notice that tis condition is automatically satisfied if r is still
    23582358    *in S), then (s,r) can be canceled.
     
    23732373    *the set B collects the pairs of type (S[j],p)
    23742374    *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
    2375     *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    2376     *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     2375    *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     2376    *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    23772377    */
    23782378    for(j = strat->Bl;j>=0;j--)
     
    24212421    *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
    24222422    *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
    2423     *devide lcm(r,p)). In the last case (s,r) can be canceled if the leading
    2424     *term of p devides the lcm(s,r)
     2423    *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
     2424    *term of p divides the lcm(s,r)
    24252425    *(this canceling should be done here because
    24262426    *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
     
    42344234  *the set B collects the pairs of type (S[j],p)
    42354235  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p) != lcm(r,p)
    4236   *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    4237   *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     4236  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     4237  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    42384238  */
    42394239  for(j = strat->Bl;j>=0;j--)
     
    42924292    *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
    42934293    *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
    4294     *devide lcm(r,p)). In the last case (s,r) can be canceled if the leading
    4295     *term of p devides the lcm(s,r)
     4294    *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
     4295    *term of p divides the lcm(s,r)
    42964296    *(this canceling should be done here because
    42974297    *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
     
    1256912569  *the set B collects the pairs of type (S[j],p)
    1257012570  *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p) != lcm(r,p)
    12571   *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    12572   *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     12571  *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     12572  *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    1257312573  */
    1257412574
     
    1295212952    *the set B collects the pairs of type (S[j],p)
    1295312953    *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
    12954     *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    12955     *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     12954    *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     12955    *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    1295612956    */
    1295712957    {
     
    1300813008      *i.e. lcm(s,p)=product of the leading terms of s and p.
    1300913009      *Suppose (s,r) is in L and the leading term
    13010       *of p devides lcm(s,r)
    13011       *(==> the leading term of p devides the leading term of r)
    13012       *but the leading term of s does not devide the leading term of r
     13010      *of p divides lcm(s,r)
     13011      *(==> the leading term of p divides the leading term of r)
     13012      *but the leading term of s does not divide the leading term of r
    1301313013      *(notice that tis condition is automatically satisfied if r is still
    1301413014      *in S), then (s,r) can be canceled.
     
    1303513035      *the set B collects the pairs of type (S[j],p)
    1303613036      *suppose (r,p) is in B and (s,p) is the new pair and lcm(s,p)#lcm(r,p)
    13037       *if the leading term of s devides lcm(r,p) then (r,p) will be canceled
    13038       *if the leading term of r devides lcm(s,p) then (s,p) will not enter B
     13037      *if the leading term of s divides lcm(r,p) then (r,p) will be canceled
     13038      *if the leading term of r divides lcm(s,p) then (s,p) will not enter B
    1303913039      */
    1304013040      for(j = strat->Bl;j>=0;j--)
     
    1314113141    *suppose we have (s,r),(r,p),(s,p) and spoly(s,p) == 0 and (r,p) is
    1314213142    *still in B (i.e. lcm(r,p) == lcm(s,p) or the leading term of s does not
    13143     *devide lcm(r,p)). In the last case (s,r) can be canceled if the leading
    13144     *term of p devides the lcm(s,r)
     13143    *divide lcm(r,p)). In the last case (s,r) can be canceled if the leading
     13144    *term of p divides the lcm(s,r)
    1314513145    *(this canceling should be done here because
    1314613146    *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
  • kernel/RULES

    r538e06 r4bde6b  
    33* call rComplete after constructing a ring (returns purely commutative ring!)
    44
    5 ** call nc_CallPlural to make a newly constucted commutative ring (see above) noncommutative
     5** call nc_CallPlural to make a newly constructed commutative ring (see above) noncommutative
    66
    77* never allocate memory with 0 as size request
  • kernel/combinatorics/combinatorics.dox

    r538e06 r4bde6b  
    1 /*! \page kernel_combinatorics_page Combinatorical algorithms
     1/*! \page kernel_combinatorics_page Combinatorial algorithms
    22
    3  \brief This sub-package of \ref kernel_page contains some combinatorical algorithms.
     3 \brief This sub-package of \ref kernel_page contains some combinatorial algorithms.
    44
    55 Main header in `/kernel/combinatorics/`:
  • kernel/ideals.cc

    r538e06 r4bde6b  
    27692769}
    27702770#endif
    2771 /* currently unsed:
     2771/* currently unused:
    27722772ideal idChineseRemainder(ideal *xx, intvec *iv)
    27732773{
  • libpolys/coeffs/README.coeffs

    r538e06 r4bde6b  
    11The structure pointed to by "coeffs" describes a commutative ring with 1
    2 which could be used as coeffcients for polynomials.
     2which could be used as coefficients for polynomials.
    33
    44To create a new representant of coeffs, implement all of the following
     
    1818  to be Euclidean and an exact division otherwise.
    1919-cfInit
    20 -cfInt (returns 0, if the arguemnt is not in int)
    21 -cfMPZ (returns mpz_init_si(0), if the arguemnt is not an integer)
     20-cfInt (returns 0, if the argument is not in int)
     21-cfMPZ (returns mpz_init_si(0), if the argument is not an integer)
    2222-cfInpNeg
    2323  negates (mult. by -1) in-place.
     
    120120 n_coeffType type=nRegister(n_unknown,<your InitChar procedure>);
    121121// create the new coeff type:
    122  coeffs cf=nInitChar(type,<your paramater for the InitChar procedure>);
     122 coeffs cf=nInitChar(type,<your parameter for the InitChar procedure>);
    123123// cf may now be used for (polynomial) ring definitions etc.
    124124
  • main.dox

    r538e06 r4bde6b  
    2323  - \subpage singular_page "Singular Interpreter and related".
    2424
    25 \Note Singlar relies on some third-party \subpage external_packages_page "Packages".
     25\Note Singular relies on some third-party \subpage external_packages_page "Packages".
    2626
    2727\Note In case of any uncovered topics or unanswered questions please report
     
    5656
    5757
    58 Dependencies between Singular packages (and sub-grouppings) are shown as arrows on the following diagramm:
     58Dependencies between Singular packages (and sub-grouppings) are shown as arrows on the following diagram:
    5959\dotfile Includes.dot Package dependency diagram
    6060*/
  • omalloc/omDefaultConfig.h

    r538e06 r4bde6b  
    9595   memory request can not be serviced. If set, this function should never return.*/
    9696#ifndef OM_DEFAULT_OUT_OF_MEMORY_FUNC
    97 /* This initalizes om_Opts.OutOfMemoryFunc which is declared as
     97/* This initializes om_Opts.OutOfMemoryFunc which is declared as
    9898   void (*OutOfMemoryFunc)(); */
    9999#define OM_DEFAULT_OUT_OF_MEMORY_FUNC NULL
     
    114114   It should trigger the release of as much memory by the application as possible */
    115115#ifndef OM_DEFAULT_MEMORY_LOW_FUNC
    116 /* This initalizes om_Opts.MemoryLowFunc which is declared as
     116/* This initializes om_Opts.MemoryLowFunc which is declared as
    117117   void (*MemoryLowFunc)(); */
    118118#define OM_DEFAULT_MEMORY_LOW_FUNC NULL
     
    231231#endif
    232232
    233 /* pattern with which memory is initalized, for front and back padding,
     233/* pattern with which memory is initialized, for front and back padding,
    234234   and for free memory: only relevant if track >= 3*/
    235235#ifndef OM_INIT_PATTERN
  • ppcc/gclib/README

    r538e06 r4bde6b  
    5555malloc());
    5656- objects finalization and memory recycling (reclaiming to the
    57 underlaying malloc implementation) is done lazily (between
     57underlying malloc implementation) is done lazily (between
    5858collections).
    5959
     
    6666- small initial internal data size;
    6767- less source code (to verify);
    68 - minimal set of the underlaying clib/pthread/Win32 functions used.
     68- minimal set of the underlying clib/pthread/Win32 functions used.
    6969
    7070The drawbacks of TinyGC are:
     
    8181blacklisting, memory unmapping, thread-local allocation, parallel
    8282marking, generation and incremental collections);
    83 - relies on the underlaying malloc/free() implementation (which may be
     83- relies on the underlying malloc/free() implementation (which may be
    8484broken for large heaps, like, e.g., in some versions of msvcrt);
    8585- "all-interior-pointers" mode is limited by the offset of 256
     
    104104symbols are not visible outside);
    105105- both pthreads and Win32 threads are supported;
    106 - no thread-safety of the underlaying malloc/free is required;
     106- no thread-safety of the underlying malloc/free is required;
    107107- the stack direction is detected at TinyGC initialization;
    108108- no warnings are printed;
     
    112112- CPU state is saved by setjmp();
    113113- there is no object "header" (i.e. the original object size is passed
    114 to the underlaying malloc()).
     114to the underlying malloc()).
    115115
    116116Usage notes:
  • ppcc/gclib/htdocs/index.html

    r538e06 r4bde6b  
    178178<LI>malloc-based allocation (i.e. every object is allocated using
    179179<CODE>malloc()</CODE>);
    180 <LI>objects finalization and memory recycling (reclaiming to the underlaying
     180<LI>objects finalization and memory recycling (reclaiming to the underlying
    181181malloc implementation) is done lazily (between collections).
    182182</UL></DIV>
     
    191191<LI>small initial internal data size;
    192192<LI>less source code (to verify);
    193 <LI>minimal set of the underlaying
     193<LI>minimal set of the underlying
    194194<ACRONYM>clib</ACRONYM>/<ACRONYM>pthread</ACRONYM>/<ACRONYM>Win32</ACRONYM>
    195195functions used.
     
    209209memory unmapping, thread-local allocation, parallel marking, generation and
    210210incremental collections);
    211 <LI>relies on the underlaying malloc/free() implementation (which may be
     211<LI>relies on the underlying malloc/free() implementation (which may be
    212212broken for large heaps, like, e.g., in some versions of msvcrt);
    213213<LI>"all-interior-pointers" mode is limited by the offset of 256
     
    237237<LI>both <ACRONYM>pthreads</ACRONYM> and <ACRONYM>Win32</ACRONYM> threads are
    238238supported;
    239 <LI>no thread-safety of the underlaying malloc/free is required;
     239<LI>no thread-safety of the underlying malloc/free is required;
    240240<LI>the stack direction is detected at <ACRONYM>TinyGC</ACRONYM>
    241241initialization;
     
    246246<LI><ACRONYM>CPU</ACRONYM> state is saved by <CODE>setjmp()</CODE>;
    247247<LI>there is no object "header" (i.e. the original object size is passed to
    248 the underlaying <CODE>malloc()</CODE>).
     248the underlying <CODE>malloc()</CODE>).
    249249</UL>
    250250<P>Usage notes:
  • templates/Doxyfile

    r538e06 r4bde6b  
    290290# probably good enough. For larger projects a too small cache size can cause
    291291# doxygen to be busy swapping symbols to and from disk most of the time
    292 # causing a significant performance penality.
     292# causing a significant performance penalty.
    293293# If the system has enough physical memory increasing the cache will improve the
    294294# performance by keeping more symbols in memory. Note that the value works on
    295 # a logarithmic scale so increasing the size by one will rougly double the
     295# a logarithmic scale so increasing the size by one will roughly double the
    296296# memory usage. The cache size is given by this formula:
    297297# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
Note: See TracChangeset for help on using the changeset viewer.