Changeset 4f8fd1d in git


Ignore:
Timestamp:
Nov 14, 2022, 10:53:35 AM (3 months ago)
Author:
Frédéric Chapoton <chapoton@…>
Branches:
(u'spielwiese', 'ad2543eab51733612ba7d118afc77edca719600e')
Children:
569754d2a9ccf1842ac61e82c0dfb411f5bb9a97
Parents:
317c1453d644836d66288dc2a633068067f64ab7
Message:
trying to add a codespell linter for kernel/
Files:
2 added
16 edited

Legend:

Unmodified
Added
Removed
  • kernel/GBEngine/GBEngine.dox

    r317c14 r4f8fd1d  
    2525
    2626
    27  Some importat data structures and classes:
     27 Some important data structures and classes:
    2828 - \ref skStrategy
    2929 - \ref sLObject
  • kernel/GBEngine/f5lists.cc

    r317c14 r4f8fd1d  
    9999    //pWrite(temp->getPoly());
    100100    //pWrite(p);
    101     //Print("COMAPRE: %d\n",pLmEqual(p,temp->getPoly()));
     101    //Print("COMPARE: %d\n",pLmEqual(p,temp->getPoly()));
    102102    if(1 == pLmEqual(p,temp->getPoly())) {
    103103      //Print("YES!\n");
     
    217217return newElement;
    218218}
    219 // insert new elemets to the list w.r.t. increasing labels
     219// insert new elements to the list w.r.t. increasing labels
    220220// only used for the S-polys to be reduced (TopReduction building new S-polys with higher label)
    221221inline LNode* LNode::insertByLabel(poly t, int i, poly p, RuleOld* r) {
     
    916916====================================
    917917*/
    918 // for initialization of CListOlds, last element alwas has data=NULL and next=NULL
     918// for initialization of CListOlds, last element always has data=NULL and next=NULL
    919919CListOld::CListOld() {
    920920    first   =   NULL;
  • kernel/GBEngine/f5lists.h

    r317c14 r4f8fd1d  
    271271        CNode*  first;
    272272    public:
    273                 // for initialization of CListOlds, last element alwas has data=NULL and next=NULL
     273                // for initialization of CListOlds, last element always has data=NULL and next=NULL
    274274                CListOld();
    275275                CListOld(CPairOld* c);
     
    314314    private:
    315315        RNode*  first;
    316         // last alway has data=NULL and next=NULL, for initialization purposes used
     316        // last always has data=NULL and next=NULL, for initialization purposes used
    317317        RNode*  last;
    318318    public:
  • kernel/GBEngine/khstd.cc

    r317c14 r4f8fd1d  
    135135
    136136/*
    137 This will be used for the local orderings in the case of the inhomogenous ideals.
     137This will be used for the local orderings in the case of the inhomogeneous ideals.
    138138Assume f1,...,fs are already in the standard basis. Test if hilb(LM(f1),...,LM(fs),1)
    139 is equal to the inputed one.
     139is equal to the inputted one.
    140140If no, do nothing.
    141141If Yes, we know that all polys that we need are already in the standard basis
  • kernel/GBEngine/kspoly.cc

    r317c14 r4f8fd1d  
    150150#endif
    151151
    152   // take care of coef buisness
     152  // take care of coef business
    153153  if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
    154154  {
     
    284284#endif
    285285
    286   // take care of coef buisness
     286  // take care of coef business
    287287  if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
    288288  {
     
    427427
    428428  number ct, an, bn;
    429   // take care of coef buisness
     429  // take care of coef business
    430430  if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
    431431  {
     
    687687#endif
    688688
    689   // take care of coef buisness
     689  // take care of coef business
    690690  if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
    691691  {
     
    901901#endif
    902902
    903   // take care of coef buisness
     903  // take care of coef business
    904904  if (! n_IsOne(pGetCoeff(p2), tailRing->cf))
    905905  {
     
    11481148#endif
    11491149
    1150   // take care of coef buisness
     1150  // take care of coef business
    11511151  if(rField_is_Ring(currRing))
    11521152  {
  • kernel/GBEngine/kutil.cc

    r317c14 r4f8fd1d  
    22482248    *(this canceling should be done here because
    22492249    *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
    2250     *the first case is handeled in chainCrit
     2250    *the first case is handled in chainCrit
    22512251    */
    22522252    if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
     
    24792479    *(this canceling should be done here because
    24802480    *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
    2481     *the first case is handeled in chainCrit
     2481    *the first case is handled in chainCrit
    24822482    */
    24832483    if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
     
    29332933    if(pSigMult != NULL && sSigMult != NULL && p_LmCmp(pSigMult,sSigMult,currRing) == 0)
    29342934    {
    2935       //Same lm, have to substract
     2935      //Same lm, have to subtract
    29362936      Lp.sig = p_Sub(pCopy(pSigMult),pCopy(sSigMult),currRing);
    29372937    }
     
    46924692  else
    46934693*/
    4694 //   #endif // ??? Why was the following cancelation disabled for non-commutative rings?
     4694//   #endif // ??? Why was the following cancellation disabled for non-commutative rings?
    46954695  {
    46964696    j=pos;
     
    61006100* to the ordering-procedure pLmCmp,totaldegree,coefficient
    61016101* For the same totaldegree, original pairs (from F) will
    6102 * be put at the end and smalles coefficents
     6102* be put at the end and smallest coefficients
    61036103*/
    61046104int posInL11Ring (const LSet set, const int length,
     
    97419741
    97429742  //if the ordering is local, then hilb criterion
    9743   //can be used also if the ideal is not homogenous
     9743  //can be used also if the ideal is not homogeneous
    97449744  if((rHasLocalOrMixedOrdering(currRing)) && (rHasMixedOrdering(currRing)==FALSE))
    97459745  {
     
    97859785  if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
    97869786  strat->pairtest = NULL;
    9787   /* alway use tailreduction, except:
     9787  /* always use tailreduction, except:
    97889788  * - in local rings, - in lex order case, -in ring over extensions */
    97899789  strat->noTailReduction = !TEST_OPT_REDTAIL;
     
    98599859  if (TEST_OPT_NOT_SUGAR) strat->honey = FALSE;
    98609860  strat->pairtest = NULL;
    9861   /* alway use tailreduction, except:
     9861  /* always use tailreduction, except:
    98629862  * - in local rings, - in lex order case, -in ring over extensions */
    98639863  strat->noTailReduction = !TEST_OPT_REDTAIL;
     
    1291812918    *(this canceling should be done here because
    1291912919    *the case lcm(s,p) == lcm(s,r) is not covered in chainCrit)
    12920     *the first case is handeled in chainCrit
     12920    *the first case is handled in chainCrit
    1292112921    */
    1292212922    if (Lp.lcm!=NULL) pLmFree(Lp.lcm);
     
    1336813368              || (pGetComp(strat->S[j])==0))
    1336913369          {
    13370             assume(isFromQ == 0); // this case is not handeled here and should also never happen
     13370            assume(isFromQ == 0); // this case is not handled here and should also never happen
    1337113371            poly s = strat->S[j];
    1337213372            if (strat->fromQ != NULL && strat->fromQ[j])
  • kernel/GBEngine/sca.cc

    r317c14 r4f8fd1d  
    458458#endif
    459459
    460   // redtailBBa against T for inhomogenous input
     460  // redtailBBa against T for inhomogeneous input
    461461  if (!TEST_OPT_OLDSTD)
    462462    withT = ! strat->homog;
  • kernel/GBEngine/syz.cc

    r317c14 r4f8fd1d  
    295295  while ((index<length) && (res[index]!=NULL))
    296296  {
    297 /*---we take out dependend elements from syz---------------------*/
     297/*---we take out dependent elements from syz---------------------*/
    298298    if (res[index+1]!=NULL)
    299299    {
  • kernel/GBEngine/syz.h

    r317c14 r4f8fd1d  
    2222                 poly  lcm;   /*- the lcm of p1,p2 -*/
    2323                 poly  syz;   /*- the syzygy associated to p1,p2 -*/
    24                  int   ind1,ind2; /*- the indeces of p1,p2 -*/
     24                 int   ind1,ind2; /*- the indices of p1,p2 -*/
    2525                 poly  isNotMinimal;
    2626                 int   syzind;
  • kernel/GBEngine/syz1.cc

    r317c14 r4f8fd1d  
    514514      same_comp = SYZ_SHIFT_BASE;
    515515
    516     // test wheter we have enough space for new shifted component
     516    // test whether we have enough space for new shifted component
    517517    if ((LONG_MAX - same_comp) <= shind[ie-1])
    518518    {
     
    22702270/*2
    22712271* re-computes the order of pairs during the algorithm
    2272 * this ensures to procede with a triangular matrix
     2272* this ensures to proceed with a triangular matrix
    22732273*/
    22742274static intvec * syOrdPairs(SSet sPairs, int length)
     
    23802380    rChangeCurrRing(origR);
    23812381    // Thomas: now make sure that all data which you need is pFetchCopied
    2382     // maybe incoporate it into syReorder ??
     2382    // maybe incorporate it into syReorder ??
    23832383  }
    23842384  tres = syReorder(tres,syzstr->length,syzstr,FALSE,syzstr->res);
  • kernel/GBEngine/syz3.cc

    r317c14 r4f8fd1d  
    5151/*3
    5252* assumes the ideals old_ideal and new_ideal to be homogeneous
    53 * tests wether the new_ideal is a regular extension of the old_ideal
     53* tests whether the new_ideal is a regular extension of the old_ideal
    5454*/
    5555static BOOLEAN syIsRegular(ideal old_ideal,ideal new_ideal,int deg)
     
    684684    if (index==0)
    685685    {
    686 /*--- tests wether a generator must be replaced (lt(f1)|lt(f2)!)--*/
     686/*--- tests whether a generator must be replaced (lt(f1)|lt(f2)!)--*/
    687687      if (p_FDeg(tso.p1,currRing)==p_FDeg(tso.lcm,currRing))
    688688        toReplace = tso.ind1+1;
     
    691691    }
    692692#ifdef EXPERIMENT3
    693 /*--- tests wether the product criterion applies --------------*/
     693/*--- tests whether the product criterion applies --------------*/
    694694    if ((index==0) && (old_generators->rank==1) &&
    695695        (p_FDeg(tso.p1,currRing)+p_FDeg(tso.p2,currRing)==tso.order))
     
    852852  if (toReplace)
    853853  {
    854 /*-- replaces the generator if neccesary ------------------*/
     854/*-- replaces the generator if necessary ------------------*/
    855855    pDelete(&old_generators->m[toReplace-1]);
    856856    pDelete(&old_repr->m[toReplace-1]);
     
    14081408* we proceed the generators of the next module;
    14091409* they are stored in add_generators and add_repr;
    1410 * if the normal form of a new genrators w.r.t. add_generators has
     1410* if the normal form of a new generators w.r.t. add_generators has
    14111411* pGetComp<crit_comp it is skipped from the reduction;
    14121412* new_generators and new_repr (which are empty) stores the result of the
     
    15231523    if ((next_place_add>next_new_el) || (next_deg<0))  //there are new generators or pairs
    15241524    {
    1525 /*-reducing and generating pairs untill the degree of the next generators-*/
     1525/*-reducing and generating pairs until the degree of the next generators-*/
    15261526      pairs_left = TRUE;
    15271527      while (pairs_left && ((next_deg<0) || (red_deg<= next_deg)))
     
    17461746PrintS("Add new generators:\n");
    17471747idPrint(new_generators);
    1748 PrintS("with representaions:\n");
     1748PrintS("with representations:\n");
    17491749idPrint(new_repr);
    17501750#endif
  • kernel/GBEngine/tgb.cc

    r317c14 r4f8fd1d  
    12361236  }
    12371237
    1238   //can also try dependend search
     1238  //can also try dependent search
    12391239  omFree (i_con);
    12401240  omFree (j_con);
     
    17161716      shorten_tails (c, c->S->m[c->n - 1]);
    17171717  }
    1718   //you should really update c->lengths, c->strat->lenS, and the oder of polys in strat if you sort after lengths
     1718  //you should really update c->lengths, c->strat->lenS, and the order of polys in strat if you sort after lengths
    17191719
    17201720  //for(i=c->strat->sl; i>0;i--)
  • kernel/GBEngine/tgb_internal.h

    r317c14 r4f8fd1d  
    332332{
    333333 public:
    334   /// we assume hat all occuring red_objects have same lm, and all
     334  /// we assume that all occurring red_objects have same lm, and all
    335335  /// occ. lm's in r[l...u] are the same, only reductor does not occur
    336336  virtual void reduce(red_object* r, int l, int u);
  • kernel/combinatorics/hilb.cc

    r317c14 r4f8fd1d  
    6363*/
    6464
    65 //adds the new polynomial at the coresponding position
     65//adds the new polynomial at the corresponding position
    6666//and simplifies the ideal, destroys p
    6767static void SortByDeg_p(ideal I, poly p)
     
    11641164{
    11651165  /*
    1166    * shifts the varibles of monomial p in the  i^th layer,
     1166   * shifts the variables of monomial p in the  i^th layer,
    11671167   * p remains unchanged,
    11681168   * creates new poly and returns it for the colon ideal
     
    11971197{
    11981198  /*
    1199    * deletes the variables upto i^th layer of monomial w
     1199   * deletes the variables up to i^th layer of monomial w
    12001200   * w remains unchanged
    12011201   * creates new poly and returns it for the colon ideal
     
    18291829}
    18301830poly hilbert_series(ideal A, const ring src, const intvec* wdegree, const ring Qt)
    1831 // accoding to:
     1831// according to:
    18321832// Algorithm 2.6 of
    18331833// Dave Bayer, Mike Stillman - Computation of Hilbert Function
  • kernel/combinatorics/test.cc

    r317c14 r4f8fd1d  
    316316  poly p1=pISet(1);
    317317
    318   // create tthe polynomial 2*x^3*z^2
     318  // create the polynomial 2*x^3*z^2
    319319  poly p2=p_ISet(2,R);
    320320  pSetExp(p2,1,3);
     
    352352  feInitResources(argv[0]);
    353353
    354   StringSetS("ressources in use (as reported by feStringAppendResources(0):\n");
     354  StringSetS("resources in use (as reported by feStringAppendResources(0):\n");
    355355  feStringAppendResources(0);
    356356
  • kernel/fglm/fglmvec.cc

    r317c14 r4f8fd1d  
    222222  int vsize = v.size ();
    223223  number term1, term2;
    224   fglmASSERT (vsize <= rep->size (), "v has to be smaller oder equal");
     224  fglmASSERT (vsize <= rep->size (), "v has to be smaller or equal");
    225225  if(rep->isUnique ())
    226226  {
Note: See TracChangeset for help on using the changeset viewer.