Changeset a1b40a in git


Ignore:
Timestamp:
May 15, 2020, 4:01:02 PM (4 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '38077648e7239f98078663eb941c3c979511150a')
Children:
3a0213023f3c3472cf129b261990b9b4cc171574
Parents:
4bde6b203dcb1ba4a861631c9cef3629b77043c4
Message:
spelling p2
Location:
Singular/LIB
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/nctools.lib

    r4bde6b ra1b40a  
    17691769{
    17701770  // supports qring;
    1771   // can be extended to handle C istead of c
     1771  // can be extended to handle C instead of c
    17721772  /* input/basering business */
    17731773  def save; int Noinput = 0;

  • Singular/LIB/nets.lib

    r4bde6b ra1b40a  
    11371137  0. Erstellung der benötigten Datenstrukturen
    11381138  2. ÜberprÃŒfung ob P das Nullpolynom ist und dieses gegenfalls ausgeben
    1139   3. Entscheidung ob es sich um den ersten Term handel oder nicht
     1139  3. Entscheidung ob es sich um den ersten Term handelt oder nicht
    11401140    3.1 Verarbeitung des ersten Term
    11411141    3.2 Verarbeitung foldender Terme

  • Singular/LIB/noether.lib

    r4bde6b ra1b40a  
    33category="Commutative Algebra";
    44info="
    5 LIBRARY: noether.lib   Noether normalization of an ideal (not nessecary
     5LIBRARY: noether.lib   Noether normalization of an ideal (not necessary
    66                       homogeneous)
    77AUTHORS: A. Hashemi,  Amir.Hashemi@lip6.fr

  • Singular/LIB/normal.lib

    r4bde6b ra1b40a  
    10361036   //Now the ideal is 0-dim
    10371037   //First an easy test
    1038    //If I is homogenous and not constant it is concentrated at 0
     1038   //If I is homogeneous and not constant it is concentrated at 0
    10391039   if( homog(I)==1 && size(jet(I,0))==0)
    10401040   {
    … …  
    20012001
    20022002"//Repeated application of elimpart to endid, until no variables can be
    2003 //directy substituded. homo=1 if input is homogeneous, rw contains
     2003//directly substituted. homo=1 if input is homogeneous, rw contains
    20042004//original weights, endphi (partial) normalization map";
    20052005
    … …  
    20082008//and so on: none of the x or y will be eliminated
    20092009//Now subst: first x and then y: x+y+z->f(g(x,z),z)+g(x,z)+z eliminates y
    2010 //further subst replaces x by y, makes no sense (objects more compicated).
     2010//further subst replaces x by y, makes no sense (objects more complicated).
    20112011//Subst first y and then x eliminates x
    20122012//In our situation we have triangular form: x->f(y,z), y->g(z).
    … …  
    20152015//subst y,x: x+y+z->f(y,z)+g(z)+z eliminates only x
    20162016//HENCE: substitute vars depending on most other vars first
    2017 //However, if the sytem xi-fi is reduced then xi does not appear in any of the
    2018 //fj and hence the order does'nt matter when substitutinp xi by fi
     2017//However, if the system xi-fi is reduced then xi does not appear in any of the
     2018//fj and hence the order doesn't matter when substitutinp xi by fi
    20192019
    20202020{
    … …  
    35073507        p = NF(backmap(h),std(ker));
    35083508     }
    3509      // Whe are down to R(1), store here the result in the list preimages
     3509     // We are down to R(1), store here the result in the list preimages
    35103510     preimages = insert(preimages,p,j-1);
    35113511  }
    … …  
    48024802    if(isNormal == 1)
    48034803    {
    4804       // We go one step back. In the last step we didnt get antyhing new,
     4804      // We go one step back. In the last step we didn't get anything new,
    48054805      // we just verified that the ring was already normal.
    48064806      dbprint(dbg, "The ring in the previous step was already normal.");
    … …  
    53295329  int i;      // Counter
    53305330  int d = 0;  // The degree
    5331   int e;      // Degree (auxiliar variable)
     5331  int e;      // Degree (auxiliary variable)
    53325332  for(i = 1; i <= size(p); i++)
    53335333  {
    … …  
    63636363// Used for timing and comparing the different normalization procedures.
    63646364// Option (can be entered in any order)
    6365 // "normal"   -> uses the new algortihm (normal)
     6365// "normal"   -> uses the new algorithm (normal)
    63666366// "normalP"  -> uses normalP
    63676367// "normalC"  -> uses normalC, without "withGens" option
    … …  
    66266626    def BAS = basering;
    66276627
    6628     //### make a copy of nor to have a cpoy of nor[1][1]  (not a reference to)
     6628    //### make a copy of nor to have a copy of nor[1][1]  (not a reference to)
    66296629    // in order not to override norid and normap.
    66306630    // delete nor[2] (if it contains the module generators, which are not used)
    … …  
    73577357//normalP char withRing 2: 1sec, char 11: 40sec
    73587358
    7359 //Horrocks: cahr 0: 17 (8 in char 11) Komponenten alle normal, delta 1
     7359//Horrocks: char 0: 17 (8 in char 11) Komponenten alle normal, delta 1
    73607360//char 11: 8 Komponenten alle normal, delta -1
    73617361ring r=0,(a,b,c,d,e,f),dp;

  • Singular/LIB/normaliz.lib

    r4bde6b ra1b40a  
    13691369RETURN:   The exponent vectors of the leading monomials of the elements of I
    13701370          are considered as generators of a monomial ideal for which the
    1371           normalization of its Rees algebra is computed. For a Definiton of the
     1371          normalization of its Rees algebra is computed. For a Definition of the
    13721372          Rees algebra (or Rees ring) see Bruns and Herzog, Cohen-Macaulay
    13731373          rings, Cambridge University Press 1998, p. 182.
    … …  
    16891689// 2 is default value
    16901690// 3 is command line option to be passed to Normaliz
    1691 // 4 indictes whether file "gen" is generated
     1691// 4 indicates whether file "gen" is generated
    16921692// value 2 of 4 indicates "no influence"
    16931693

  • Singular/LIB/numerAlg.lib

    r4bde6b ra1b40a  
    1616PROCEDURES:
    1717
    18  Incl(ideal I, ideal J);   test if I containes J
     18 Incl(ideal I, ideal J);   test if I contains J
    1919
    2020 Equal(ideal I, ideal J);  test if I equals to J

  • Singular/LIB/olga.lib

    r4bde6b ra1b40a  
    13591359RETURN:   list or ideal
    13601360NOTE:     the optional parameter is passed to factorize after changing to a
    1361           commutative ring, the result of factorize is transfered back to
     1361          commutative ring, the result of factorize is transferred back to
    13621362          basering
    13631363SEE ALSO: factorize

  • Singular/LIB/paraplanecurves.lib

    r4bde6b ra1b40a  
    13511351@item @code{L[3]}; list:
    13521352         consists of one list for each primary component
    1353          of the singular locus of C which correponds to a set of conjugated
     1353         of the singular locus of C which corresponds to a set of conjugated
    13541354         ordinary multiple points. Each list consists of an int, the
    13551355         multiplicity of the points, and an ideal, the primary component.
    … …  
    24182418RETURN:  returns 0 in case of unexpected input (e.g. non-quadratic,
    24192419         reducible); 1 otherwise
    2420 NOTE:    This method calles rationalPointConic, measures time consumption
     2420NOTE:    This method calls rationalPointConic, measures time consumption
    24212421         and checks whether the computed point lies indeed on the conic pp.
    24222422         The results will be printed to standard output.
    … …  
    28752875// -------------------------------------------------------
    28762876ring SS = 0, (u,v,z), dp;
    2877 poly f = u^4-14*u^2*v^2+v^4+8*u^2*v*z+8*v^3*z; // 1 OMP of mult 3 at orgin
     2877poly f = u^4-14*u^2*v^2+v^4+8*u^2*v*z+8*v^3*z; // 1 OMP of mult 3 at origin
    28782878adjointIdeal(f,1);
    28792879adjointIdeal(f,2);

  • Singular/LIB/pointid.lib

    r4bde6b ra1b40a  
    5252static proc subst1(def id, int m)
    5353{
    54 //id = poly/ideal/list, substitute the first m variables occuring in id by 1
     54//id = poly/ideal/list, substitute the first m variables occurring in id by 1
    5555
    5656  int i,j;

  • Singular/LIB/poly.lib

    r4bde6b ra1b40a  
    935935// perform standard basis computation or interreduction of a submodule
    936936// of a free module with generators gen(1),...,gen(n) over a ring R
    937 // in a ring R[t1,...,tn]/<ti*tj> with gen(i) maped to ti
     937// in a ring R[t1,...,tn]/<ti*tj> with gen(i) mapped to ti
    938938////////////////////////////////////////////////////////////////////////
    939939

  • Singular/LIB/polybori.lib

    r4bde6b ra1b40a  
    2727to @code{var(i)} from current @code{ring};
    2828
    29 For convenience, the corresponding types can be converted explictely or implicitely
     29For convenience, the corresponding types can be converted explicitly or implicitly
    3030while assigning.
    3131Also several SINGULAR operators were overloaded: @code{bring} comes with @code{nvars},
    … …  
    6161
    6262 For building your own @code{PolyBoRi} please ensure that you have @code{scons} and a
    63  development version of the boost libaries installed on you system.
     63 development version of the boost libraries installed on you system.
    6464 Then you may execute the following commands in a @code{bash}-style shell
    6565 to build @code{PolyBoRi} available to @code{python}:
    … …  
    11901190  ideal I=f1,f2,f3,f4;
    11911191
    1192   boolean_std(I);        // implicitely add x(i)^2-x(i)
     1192  boolean_std(I);        // implicitly add x(i)^2-x(i)
    11931193
    11941194  bideal bI=I;           // alternative syntax

  • Singular/LIB/polymake.lib

    r4bde6b ra1b40a  
    107107
    108108////////////////////////////////////////////////////////////////////////////////
    109 /// Auxilary Static Procedures in this Library
     109/// Auxiliary Static Procedures in this Library
    110110////////////////////////////////////////////////////////////////////////////////
    111111/// - scalarproduct
    … …  
    159159                        there means that the vertex L[1][i] is connected to the
    160160                        vertex L[1][k]
    161 @*            L[4] : an matrix of type bigintmat whose rows mulitplied by
     161@*            L[4] : an matrix of type bigintmat whose rows multiplied by
    162162                     (1,var(1),...,var(nvar)) give a linear system of equations
    163163                     describing the affine hull of the polytope,
    … …  
    222222                        there means that the vertex L[1][i] is
    223223                        connected to the vertex L[1][k]
    224 @*            L[4] : an matrix of type bigintmat whose rows mulitplied by
     224@*            L[4] : an matrix of type bigintmat whose rows multiplied by
    225225                     (1,var(1),...,var(nvar)) give a linear system of equations
    226226                     describing the affine hull of the Newton polytope, i.e. the
    … …  
    284284proc newtonPolytopeLP (poly f)
    285285"USAGE:  newtonPolytopeLP(f);  f poly
    286 RETURN: list, the exponent vectors of the monomials occuring in f,
     286RETURN: list, the exponent vectors of the monomials occurring in f,
    287287              i.e. the lattice points of the Newton polytope of f
    288288EXAMPLE: example newtonPolytopeLP;   shows an example"
    … …  
    826826         with indices i, j and k
    827827RETURN:  intvec, the integer vector eta describing that vertex of the Newton
    828                  polytope discriminant of the polygone whose dual cone in the
     828                 polytope discriminant of the polygon whose dual cone in the
    829829                 Groebner fan contains the cone of the secondary fan of the
    830830                 polygon corresponding to the given triangulation
    … …  
    16211621  if (sbd==intvec(2,2,2,3,3))
    16221622  {
    1623     // find the vertix to be mapped to (2,0)
     1623    // find the vertex to be mapped to (2,0)
    16241624    if (tboundary[max+1]!=3)
    16251625    {
    … …  
    17481748/////////////////////////////////////////////////////////////////////////////////
    17491749/////////////////////////////////////////////////////////////////////////////////
    1750 /// AUXILARY PROCEDURES, WHICH ARE DECLARED STATIC
     1750/// AUXILIARY PROCEDURES, WHICH ARE DECLARED STATIC
    17511751/////////////////////////////////////////////////////////////////////////////////
    17521752/////////////////////////////////////////////////////////////////////////////////
    … …  
    21092109             polygonDB
    21102110RETURN:      list, the first entry is a string representing the coordinates
    2111                    corresponding to the latticpoints seperated by commata
     2111                   corresponding to the latticpoints separated by commata
    21122112                   the second entry is a list where the ith entry is a string
    21132113                   representing the coordinate of corresponding to the ith
    … …  
    27432743proc latticeCodegree()
    27442744"USAGE:   latticeCodegree(p);  p polytope
    2745 RETURN:  int, the smalles number n such that n*p has a relative interior lattice point
     2745RETURN:  int, the smallest number n such that n*p has a relative interior lattice point
    27462746NOTE:    dimension(p)+1==latticeDegree(p)+latticeCodegree(p)
    27472747EXAMPLE: example latticeCodegree; shows an example

  • Singular/LIB/presolve.lib

    r4bde6b ra1b40a  
    1212 elimpartanyr(i,p);     factors of p partially eliminated from i in any ring
    1313 fastelim(i,p[..]);     fast elimination of factors of p from i [options]
    14  findvars(id);          variables occuring/not occurring  in id
     14 findvars(id);          variables occurrring/not occurring  in id
    1515 hilbvec(id[,c,o]);     intvec of Hilberseries of id [in char c and ord o]
    1616 linearpart(id);        elements of id of total degree <=1
    17  tolessvars(id[,]);     maps id to new basering having only vars occuring in id
     17 tolessvars(id[,]);     maps id to new basering having only vars occurring in id
    1818 solvelinearpart(id);   reduced std-basis of linear part of id
    1919 sortandmap(id[..]);    map to new basering with vars sorted w.r.t. complexity
    … …  
    367367Alte Version mit interred:
    368368// Then go to ring newBAS with ordering c,dp(n) and create a matrix with
    369 // size(k1) colums and 2 rows, such that if [f1,f2] is a column of M then f1+f2
     369// size(k1) columns and 2 rows, such that if [f1,f2] is a column of M then f1+f2
    370370// is one of the polys of lin containing a pure degree 1 part and f1 is this
    371371// part interreduce this matrix (i.e. Gauss elimination on linear part, with
    … …  
    408408
    409409   lin2 = matrix(lin) - matrix(lin1);      //difference as matrix
    410    // rest of lin, part of pure degree 1 substracted from each generator of lin
     410   // rest of lin, part of pure degree 1 subtracted from each generator of lin
    411411
    412412   for( ii=1; ii<=l; ii++ )
    … …  
    466466                  eva = eva+var(ii); //var(ii) added to list of elimin. vars
    467467                  neva[ii] = 0;
    468                   sub = sub+kip;     //polynomial defining substituion
     468                  sub = sub+kip;     //polynomial defining substitution
    469469                  //## gmg: geaendert 08/2008, map durch subst ersetzt
    470470                  //(viel schneller)
    … …  
    839839RETURN:  list L with 4 entries:
    840840  @format
    841   L[1]: ideal of variables occuring in id
    842   L[2]: intvec of variables occuring in id
    843   L[3]: ideal of variables not occuring in id
    844   L[4]: intvec of variables not occuring in id
     841  L[1]: ideal of variables occurring in id
     842  L[2]: intvec of variables occurring in id
     843  L[3]: ideal of variables not occurring in id
     844  L[4]: intvec of variables not occurring in id
    845845  @end format
    846846SEE ALSO: variables
    … …  
    927927"
    928928{
    929 //---------------- initialisation and check occurence of vars -----------------
     929//---------------- initialisation and check occurrence of vars -----------------
    930930   int s,ii,n,fp,fs;
    931931   string s2,newvar;
    … …  
    10441044         The new monomial ordering and sorting of vars is as follows:
    10451045  @format
    1046   - each block of vars occuring in pi is sorted w.r.t. its complexity in id,
    1047   - ni controls the sorting in i-th block (= vars occuring in pi):
     1046  - each block of vars occurring in pi is sorted w.r.t. its complexity in id,
     1047  - ni controls the sorting in i-th block (= vars occurring in pi):
    10481048    ni=0 (resp. ni!=0) means that least complex (resp. most complex) vars come
    10491049    first
    … …  
    10611061         consider id as list of polynomials in x with coefficients in the
    10621062         remaining variables. Then:@*
    1063          val(x) = (maximal occuring power of x,  # of all monomials in leading
     1063         val(x) = (maximal occurring power of x,  # of all monomials in leading
    10641064         coefficient, # of all monomials in coefficient of next smaller power
    10651065         of x,...).
    … …  
    11361136  @format
    11371137  [1]: ideal, variables of basering sorted w.r.t their complexity in id
    1138        ni controls the ordering in i-th block (= vars occuring in pi):
     1138       ni controls the ordering in i-th block (= vars occurring in pi):
    11391139       ni=0 (resp. ni!=0) means that less (resp. more) complex vars come first
    11401140  [2]: a list with 4 entries for each pi:
    … …  
    11511151         consider id as list of polynomials in x with coefficients in the
    11521152         remaining variables. Then:@*
    1153          val(x) = (maximal occuring power of x,  # of all monomials in leading
     1153         val(x) = (maximal occurring power of x,  # of all monomials in leading
    11541154         coefficient, # of all monomials in coefficient of next smaller power
    11551155         of x,...).
    … …  
    11931193         n1,n2,...= integers,
    11941194
    1195          ni controls the ordering of vars occuring in pi: ni=0 (resp. ni!=0)
     1195         ni controls the ordering of vars occurring in pi: ni=0 (resp. ni!=0)
    11961196         means that less (resp. more) complex vars come first (default: p1=product of all vars, n1=0),@*
    11971197         the last pi (containing the remaining vars) may be omitted
    11981198COMPUTE: valuation (complexity) of variables with respect to id.@*
    1199          ni controls the ordering of vars occuring in pi:@*
     1199         ni controls the ordering of vars occurring in pi:@*
    12001200         ni=0 (resp. ni!=0) means that less (resp. more) complex vars come first.
    12011201RETURN:  list with 3 entries:
    … …  
    12161216         consider id as list of polynomials in x with coefficients in the
    12171217         remaining variables. Then:@*
    1218          val(x) = (maximal occuring power of x,  # of all monomials in leading
     1218         val(x) = (maximal occurring power of x,  # of all monomials in leading
    12191219         coefficient, # of all monomials in coefficient of next smaller power
    12201220         of x,...).
    … …  
    12861286      {
    12871287         C = coeffs(i,a(kk)[ii]);
    1288          w = nrows(C); // =(maximal occuring power of a(kk)[ii])+1
     1288         w = nrows(C); // =(maximal occurring power of a(kk)[ii])+1
    12891289         for ( jj=w[1]; jj>1; jj-- )
    12901290         {
    … …  
    12921292            w[w[1]-jj+2] = sum(s);
    12931293         }
    1294          // w[1] should represent the maximal occuring power of a(kk)[ii] so it
     1294         // w[1] should represent the maximal occurring power of a(kk)[ii] so it
    12951295         // has to be decreased by 1 since otherwise the constant term is also
    12961296         // counted

  • Singular/LIB/primdec.lib

    r4bde6b ra1b40a  
    476476          "// WARNING: The characteristic is perhaps too small to use";
    477477          "// the algorithm of Gianni/Trager/Zacharias.";
    478           "// This may result in an infinte loop";
     478          "// This may result in an infinite loop";
    479479          "// loop in primaryTest, voice:",voice;"";
    480480        }
    … …  
    28372837         (at even positions in the list)
    28382838         (resp. a list of the minimal associated primes)
    2839          if I is unit ideal, returns emtpy list
     2839         if I is unit ideal, returns empty list
    28402840NOTE:    Algorithm of Gianni/Trager/Zacharias
    28412841EXAMPLE: example decompE; shows an example
    … …  
    39203920         as polynomial over Fp(t(1)^(p^-k),...,t(m)^(p^-k))
    39213921 RETURN: the separabel part of f as polynomial in Fp(t1,...,tm)
    3922         and an integer k to indicate that f should be considerd
     3922        and an integer k to indicate that f should be considered
    39233923        as polynomial over Fp(t(1)^(p^-k),...,t(m)^(p^-k))
    39243924 EXAMPLE: example sep; shows an example
    … …  
    53565356  quotM[2]=fac;
    53575357  quotM[3]=f0;
    5358   // we deal seperately with the first quotient;
     5358  // we deal separately with the first quotient;
    53595359  // factors, which do not contribute to this one,
    53605360  // are omitted
    … …  
    54055405  quotM[2]=fac;
    54065406  quotM[3]=f0;
    5407   // we deal seperately with the first quotient;
     5407  // we deal separately with the first quotient;
    54085408  // factors, which do not contribute to this one,
    54095409  // are omitted
    … …  
    74047404         newDecompStep_i(patchPrimaryDecomposition, I,3);        (for the absolute primary decomposition (not tested!))
    74057405         "oneIndep";        (for using only one max indep set)
    7406          "intersect";        (returns alse the intersection of the components founded)
     7406         "intersect";        (returns also the intersection of the components founded)
    74077407
    74087408RETURN:  list = list of primary ideals and their associated primes

  • Singular/LIB/primdecint.lib

    r4bde6b ra1b40a  
    9898      setring Rhelp;
    9999      number q=imap(R,q);
    100       //=== computes the primes occuring in a generator of I intersect Z
     100      //=== computes the primes occurring in a generator of I intersect Z
    101101      list L = primefactors(q);
    102102
    … …  
    328328   }
    329329   //=== find h in Z such that I is the intersection of I:h and <I,h>
    330    //=== and I:h = IQ[variables] intersected with Z[varables]
     330   //=== and I:h = IQ[variables] intersected with Z[variables]
    331331   list H =coefZ(J);
    332332   ideal Y=H[1];
    … …  
    427427      setring Rhelp;
    428428      number q=imap(R,q);
    429       //=== computes the primes occuring in a generator of I intersect Z
     429      //=== computes the primes occurring in a generator of I intersect Z
    430430      //list L=PollardRho(q,5000,1);
    431431      list L=primefactors(q)[1];
    … …  
    480480   }
    481481   //=== find h in Z such that I is the intersection of I:h and I,h
    482    //=== and I:h =IQ[variables] intersected with Z[varables]
     482   //=== and I:h =IQ[variables] intersected with Z[variables]
    483483   list H=coefZ(J);
    484484   int h=H[2];
    … …  
    566566      setring Rhelp;
    567567      number q=imap(R,q);
    568       //=== computes the primes occuring in a generator of I intersect Z
     568      //=== computes the primes occurring in a generator of I intersect Z
    569569      //list L=PollardRho(q,5000,1);
    570570      list L=primefactors(q)[1];
    … …  
    597597   setring R;
    598598   //=== find h in Z such that I is the intersection of I:h and I,h
    599    //=== and I:h =IQ[variables] intersected with Z[varables]
     599   //=== and I:h =IQ[variables] intersected with Z[variables]
    600600   list H=coefZ(J);
    601601   int h=H[2];
    … …  
    658658      setring Rhelp;
    659659      number q=imap(R,q);
    660       //=== computes the primes occuring in a generator of I intersect Z
     660      //=== computes the primes occurring in a generator of I intersect Z
    661661      //list L=PollardRho(q,5000,1);
    662662      list L=primefactors(q)[1];
    … …  
    697697   K=coefZ(K)[1];
    698698   //=== find h in Z such that I is the intersection of I:h and I,h
    699    //=== and I:h =IQ[variables] intersected with Z[varables]
     699   //=== and I:h =IQ[variables] intersected with Z[variables]
    700700   list H=coefZ(J);
    701701   int h=H[2];
    … …  
    765765      setring Rhelp;
    766766      number q=imap(R,q);
    767       //=== computes the primes occuring in a generator of I intersect Z
     767      //=== computes the primes occurring in a generator of I intersect Z
    768768      //list L=PollardRho(q,5000,1);
    769769      list L=primefactors(q)[1];
    … …  
    877877   E=coefZ(E)[1];
    878878   //=== find h in Z such that I is the intersection of I:h and I,h
    879    //=== and I:h =IQ[variables] intersected with Z[varables]
     879   //=== and I:h =IQ[variables] intersected with Z[variables]
    880880   int h =coefZ(J)[2];
    881881   J=J,h;
    … …  
    989989static proc coefPrimeZ(ideal I)
    990990{
    991 //=== computes the primes occuring in the product of the leading coefficients
     991//=== computes the primes occurring in the product of the leading coefficients
    992992//=== of I
    993993   number h=1;
    … …  
    13271327{
    13281328//=== this is needed because we want the leading coefficients to be positive
    1329 //=== otherwhise reduce gives wrong results! should be replaced later by std
     1329//=== otherwise reduce gives wrong results! should be replaced later by std
    13301330   I=simplify(I,2);
    13311331   I=normalizeZ(I);  // why is this done before std() call?

  • Singular/LIB/qhmoduli.lib

    r4bde6b ra1b40a  
    134134    export(RME4);
    135135
    136     // simplify the ideal and create a new ring with propably less variables
     136    // simplify the ideal and create a new ring with probably less variables
    137137
    138138    if(opt == 1 || opt == 3) {      // equations computed ?
    … …  
    449449ASSUME:  f semiquasihomogeneous polynomial with an isolated singularity at 0
    450450RETURN:  list of two rings 'S1', 'S2'
    451          - 'S1' contians the equations of the stabilizer (ideal 'stabid') @*
     451         - 'S1' contains the equations of the stabilizer (ideal 'stabid') @*
    452452         - 'S2' contains the action of the stabilizer (ideal 'actionid')
    453453EXAMPLE: example StabEqn; shows an example
    … …  
    562562    qhsubs[i] = g;
    563563  }
    564   dbprint(dbPrt, "  qhasihomogenous substituion =" + string(qhsubs));
     564  dbprint(dbPrt, "  qhasihomogenous substitution =" + string(qhsubs));
    565565  map F = RSTR, qhsubs;
    566566  kill varSubsList;
    … …  
    612612  actionid = phi(qhsubs);
    613613
    614         // change to new ring, auxillary construction
     614        // change to new ring, auxiliary construction
    615615
    616616        setring(RSTT);
    … …  
    756756static proc MonosAndTerms(poly f,def wt, int ub)
    757757"USAGE:   MonosAndTerms(f, w, ub); poly f, intvec w, int ub
    758 PURPOSE: returns a list of all monomials and terms occuring in f of
     758PURPOSE: returns a list of all monomials and terms occurring in f of
    759759         weighted degree < ub
    760760RETURN:  list
    … …  
    794794static proc SelectMonos(def parts, intvec wt, int d)
    795795"USAGE:   SelectMonos(parts, w, d); list/ideal parts, intvec w, int d
    796 PURPOSE: returns a list of all monomials and terms occuring in f of
     796PURPOSE: returns a list of all monomials and terms occurring in f of
    797797         weighted degree = d
    798798RETURN:  list
    … …  
    10801080  }
    10811081
    1082   // substitute in each monomial seperately
     1082  // substitute in each monomial separately
    10831083
    10841084  g = 0;
    … …  
    11351135static proc StabVar(intvec wt)
    11361136"USAGE:   StabVar(w); intvec w
    1137 PURPOSE: compute the indicies for quasihomogeneous substitutions of each
     1137PURPOSE: compute the indices for quasihomogeneous substitutions of each
    11381138         variable.
    11391139ASSUME:  f semiquasihomogeneous polynomial with an isolated singularity at 0
    … …  
    15431543PURPOSE: find the minimal integer contained in 'data'
    15441544RETURN:  list
    1545 ASSUME:  'data' contians only integers and is not empty
     1545ASSUME:  'data' contains only integers and is not empty
    15461546"
    15471547{
Note: See TracChangeset for help on using the changeset viewer.