Changeset 0a4a20d in git


Ignore:
Timestamp:
Nov 14, 2022, 4:32:07 PM (3 months ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', 'ad2543eab51733612ba7d118afc77edca719600e')
Children:
08e898f2667529913af21341f62336e64bc3bc3c4df27e2988096e614ab54338dbdd2bb990a110e3
Parents:
323776f85628804d361dfbd827431f866bf943d232c48290ade9c8b3bf376a8ed769638bcc54abdf
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2022-11-14 16:32:07+01:00
git-committer:
GitHub <noreply@github.com>2022-11-14 16:32:07+01:00
Message:
Merge pull request #1159 from fchapoton/codespell_linter

trying to add a codespell linter for kernel/
Files:
2 added
67 edited

Legend:

Unmodified
Added
Removed
  • kernel/GBEngine/GBEngine.dox

    r323776f r0a4a20d  
    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

    r323776f r0a4a20d  
    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

    r323776f r0a4a20d  
    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/gr_kstd2.cc

    r323776f r0a4a20d  
    301301      }
    302302    }
    303     // first try usal division
     303    // first try usual division
    304304    if (p_LmDivisibleBy(strat->S[j],(*h).p,currRing))
    305305    {
  • kernel/GBEngine/kChinese.cc

    r323776f r0a4a20d  
    6363  long *d=(long*)s;
    6464  s+=SIZEOF_LONG;
    65   if (((*d)&1)==1) // immidiate number
     65  if (((*d)&1)==1) // immediate number
    6666  {
    6767    *n=(number)(*d);
  • kernel/GBEngine/khstd.cc

    r323776f r0a4a20d  
    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

    r323776f r0a4a20d  
    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  {
     
    10071007#endif
    10081008    p_ExpVectorAddSub(sigMult,PR->GetLmCurrRing(),PW->GetLmCurrRing(),currRing);
    1009     //I have also to set the leading coeficient for sigMult (in the case of rings)
     1009    //I have also to set the leading coefficient for sigMult (in the case of rings)
    10101010    if(rField_is_Ring(currRing))
    10111011    {
     
    10411041      if(sigMult != NULL)
    10421042        PR->sig = pHead(pSub(PR->sig, sigMult));
    1043       //The sigs have the same lm, have to substract
     1043      //The sigs have the same lm, have to subtract
    10441044      //It may happen that now the signature is 0 (drop)
    10451045      if(PR->sig == NULL)
     
    11481148#endif
    11491149
    1150   // take care of coef buisness
     1150  // take care of coef business
    11511151  if(rField_is_Ring(currRing))
    11521152  {
     
    14331433/***************************************************************
    14341434 *
    1435  * Auxillary Routines
     1435 * Auxiliary Routines
    14361436 *
    14371437 *
  • kernel/GBEngine/kstd1.cc

    r323776f r0a4a20d  
    5757
    5858/* the list of all options which may be used by option and test */
    59 /* defintion of ALL options: libpolys/misc/options.h */
     59/* definition of ALL options: libpolys/misc/options.h */
    6060VAR BITSET validOpts=Sy_bit(0)
    6161                |Sy_bit(1)
     
    135135  if (intoT)
    136136  {
    137     // need to do it exacly like this: otherwise
     137    // need to do it exactly like this: otherwise
    138138    // we might get errors
    139139    LObject L= *h;
     
    21302130  // do only a reduction of the leading term
    21312131//#define KSTD_NF_ECART  2
    2132   // only local: recude even with bad ecart
     2132  // only local: reduce even with bad ecart
    21332133  poly   p;
    21342134  int   i;
     
    22342234  /*- release temp data------------------------------- -*/
    22352235  cleanT(strat);
    2236   assume(strat->L==NULL); /*strat->L unsed */
     2236  assume(strat->L==NULL); /*strat->L unused */
    22372237  assume(strat->B==NULL); /*strat->B unused */
    22382238  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
     
    22752275  // do only a reduction of the leading term
    22762276//#define KSTD_NF_ECART  2
    2277   // only local: recude even with bad ecart
     2277  // only local: reduce even with bad ecart
    22782278  poly   p;
    22792279  int   i;
     
    23872387  }
    23882388  /*- release temp data------------------------------- -*/
    2389   assume(strat->L==NULL); /*strat->L unsed */
     2389  assume(strat->L==NULL); /*strat->L unused */
    23902390  assume(strat->B==NULL); /*strat->B unused */
    23912391  omFreeSize((ADDRESS)strat->T,strat->tmax*sizeof(TObject));
     
    35533553#endif
    35543554
    3555   // redtailBBa against T for inhomogenous input
     3555  // redtailBBa against T for inhomogeneous input
    35563556  if (!TEST_OPT_OLDSTD)
    35573557    withT = ! strat->homog;
  • kernel/GBEngine/kstd1.h

    r323776f r0a4a20d  
    1818  // do only a reduction of the leading term
    1919#define KSTD_NF_ECART  2
    20   // only local: recude even with bad ecart
     20  // only local: reduce even with bad ecart
    2121#define KSTD_NF_NONORM 4
    2222  // only global: avoid normalization, return a multiply of NF
  • kernel/GBEngine/kstd2.cc

    r323776f r0a4a20d  
    660660/*  unsigned long alpha_k = twoPow(leadRing->ch - k_ind2);
    661661  if (1 == 0 && alpha_k <= a)
    662   {  // Temporarly disabled, reducing coefficients not compatible with std TODO Oliver
     662  {  // Temporarily disabled, reducing coefficients not compatible with std TODO Oliver
    663663    zeroPoly = p_ISet((a / alpha_k)*alpha_k, tailRing);
    664664    for (int i = 1; i <= leadRing->N; i++)
     
    702702int redRing_Z (LObject* h,kStrategy strat)
    703703{
    704   if (h->IsNull()) return 0; // spoly is zero (can only occure with zero divisors)
     704  if (h->IsNull()) return 0; // spoly is zero (can only occur with zero divisors)
    705705  if (strat->tl<0) return 1;
    706706
     
    861861{
    862862  if (strat->tl<0) return 1;
    863   if (h->IsNull()) return 0; // spoly is zero (can only occure with zero divisors)
     863  if (h->IsNull()) return 0; // spoly is zero (can only occur with zero divisors)
    864864
    865865  int at/*,i*/;
     
    24482448    strat->use_buckets = 1;
    24492449#endif
    2450   // redtailBBa against T for inhomogenous input
     2450  // redtailBBa against T for inhomogeneous input
    24512451  if (!TEST_OPT_OLDSTD)
    24522452    withT = ! strat->homog;
     
    29422942#endif
    29432943
    2944   // redtailBBa against T for inhomogenous input
     2944  // redtailBBa against T for inhomogeneous input
    29452945  // if (!TEST_OPT_OLDSTD)
    29462946  //   withT = ! strat->homog;
     
    29642964    for(int i = 0;i<strat->sbaEnterS;i++)
    29652965    {
    2966       //Update: now the element is at the corect place
     2966      //Update: now the element is at the correct place
    29672967      //i+1 because on the 0 position is the sigdrop element
    29682968      enterT(strat->L[strat->Ll-(i)],strat);
     
    35503550    if(strat->P.sig != NULL)
    35513551      strat->sbaEnterS = pGetComp(strat->P.sig)-1;
    3552     //else we already set it at the beggining of the loop
     3552    //else we already set it at the beginning of the loop
    35533553    #ifdef KDEBUG
    35543554    memset(&(strat->P), 0, sizeof(strat->P));
     
    36323632    k = strat->Ll;
    36333633    #if 1
    3634     // 1 - adds just the unused ones, 0 - adds everthing
     3634    // 1 - adds just the unused ones, 0 - adds everything
    36353635    for(;k>=0 && (strat->L[k].p1 != NULL || strat->L[k].p2 != NULL);k--)
    36363636    {
     
    44184418    strat->use_buckets = 1;
    44194419#endif
    4420   // redtailBBa against T for inhomogenous input
     4420  // redtailBBa against T for inhomogeneous input
    44214421  //  if (!TEST_OPT_OLDSTD)
    44224422  //    withT = ! strat->homog;
  • kernel/GBEngine/kutil.cc

    r323776f r0a4a20d  
    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,
     
    83088308        // diff should be zero, but sometimes also the initial generating
    83098309        // elements of the input ideal reduce to zero. then there is an
    8310         // index-gap between the signatures. for these inbetween signatures we
     8310        // index-gap between the signatures. for these in-between signatures we
    83118311        // can safely set syzIdx[j] = 0 as no such element will be ever computed
    83128312        // in the following.
     
    83538353    // diff should be zero, but sometimes also the initial generating
    83548354    // elements of the input ideal reduce to zero. then there is an
    8355     // index-gap between the signatures. for these inbetween signatures we
     8355    // index-gap between the signatures. for these in-between signatures we
    83568356    // can safely set syzIdx[j] = 0 as no such element will be ever computed
    83578357    // in the following.
     
    93349334  /*- save result -*/
    93359335  strat->S[atS] = p.p;
    9336   strat->sig[atS] = p.sig; // TODO: get ths correct signature in here!
     9336  strat->sig[atS] = p.sig; // TODO: get the correct signature in here!
    93379337  if (strat->honey) strat->ecartS[atS] = p.ecart;
    93389338  if (p.sev == 0)
     
    94779477  assume(strat->tailRing == p.tailRing);
    94789478  // redMoraNF complains about this -- but, we don't really
    9479   // neeed this so far
     9479  // need this so far
    94809480  assume(p.pLength == 0 || pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
    94819481  assume(!strat->homog || (p.FDeg == p.pFDeg()));
     
    95659565  assume(strat->tailRing == p.tailRing);
    95669566  // redMoraNF complains about this -- but, we don't really
    9567   // neeed this so far
     9567  // need this so far
    95689568  assume(p.pLength == 0 || (int)pLength(p.p) == p.pLength || rIsSyzIndexRing(currRing)); // modulo syzring
    95699569  assume(p.FDeg == p.pFDeg());
     
    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/kutil.h

    r323776f r0a4a20d  
    768768// Reduces PR at Current->next with PW
    769769// Assumes PR != NULL, Current contained in PR
    770 //         Current->next != NULL, LM(PW) devides LM(Current->next)
     770//         Current->next != NULL, LM(PW) divides LM(Current->next)
    771771// Changes: PR
    772772// Const:   PW
  • kernel/GBEngine/ratgring.cc

    r323776f r0a4a20d  
    497497  poly H  = NULL;
    498498  HH = p_HeadRat(p1,is,r); //p_Copy(p_HeadRat(p1,is,r),r); // lm_D(g)
    499 //  H  = r->nc->p_Procs.mm_Mult_p(m, p_Copy(HH, r), r); // d^aplha lm_D(g)
    500   H  = nc_mm_Mult_p(m, HH, r); // d^aplha lm_D(g) == h_g in the paper
     499//  H  = r->nc->p_Procs.mm_Mult_p(m, p_Copy(HH, r), r); // d^alpha lm_D(g)
     500  H  = nc_mm_Mult_p(m, HH, r); // d^alpha lm_D(g) == h_g in the paper
    501501
    502502  poly K  = p_GetCoeffRat(H,  is, r); //p_Copy( p_GetCoeffRat(H,  is, r), r); // k in the paper
     
    538538#endif
    539539
    540 //  out = r->nc->p_Procs.mm_Mult_p(m, out, r); // d^aplha t_g
    541   out = nc_mm_Mult_p(m, out, r); // d^aplha t_g
     540//  out = r->nc->p_Procs.mm_Mult_p(m, out, r); // d^alpha t_g
     541  out = nc_mm_Mult_p(m, out, r); // d^alpha t_g
    542542  p_Delete(&m,r);
    543543
  • kernel/GBEngine/sca.cc

    r323776f r0a4a20d  
    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;
     
    484484  //  due to std( SB, p).
    485485  // Note that after initBuchMora :: initSSpecial all these additional
    486   // elements are in S and T (and some pairs are in L, which also has no initiall
     486  // elements are in S and T (and some pairs are in L, which also has no initial
    487487  // elements!!!)
    488488  if(TEST_OPT_SB_1)
  • kernel/GBEngine/syz.cc

    r323776f r0a4a20d  
    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

    r323776f r0a4a20d  
    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

    r323776f r0a4a20d  
    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    {
     
    18071807  return result; /// Don't change the syzstr???
    18081808
    1809   // TODO: cleanup thses!
     1809  // TODO: cleanup these!
    18101810  if( fullres != NULL && syzstr->fullres == NULL )
    18111811    syzstr->fullres = fullres;
     
    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/syz2.cc

    r323776f r0a4a20d  
    898898/*3
    899899* reorders the result (stored in orderedRes) according
    900 * to the seqence given by res
     900* to the sequence given by res
    901901*/
    902902static void syReOrdResult_Hilb(syStrategy syzstr,int maxindex,int maxdeg)
  • kernel/GBEngine/syz3.cc

    r323776f r0a4a20d  
    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]);
     
    10521052
    10531053/*3
    1054 * updates the pairs inthe higher modules
     1054* updates the pairs in the higher modules
    10551055*/
    10561056static void updatePairsHIndex(SSet *resPairs,int *l_pairs,syStrategy /*syzstr*/,
     
    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/syz4.cc

    r323776f r0a4a20d  
    781781 * subtree attached to the node which represents this term, see reference.
    782782 *
    783  * If use_tensor_trick == true, the current module is modfied after each
     783 * If use_tensor_trick == true, the current module is modified after each
    784784 * lifting step in the resolution: any term which contains a variable which
    785785 * does not appear among the (induced) leading terms is deleted. Note that the
  • kernel/GBEngine/test.cc

    r323776f r0a4a20d  
    449449  poly p1=pISet(1);
    450450
    451   // create tthe polynomial 2*x^3*z^2
     451  // create the polynomial 2*x^3*z^2
    452452  poly p2=p_ISet(2,R);
    453453  pSetExp(p2,1,3);
  • kernel/GBEngine/tgb.cc

    r323776f r0a4a20d  
    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

    r323776f r0a4a20d  
    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/Makefile.am

    r323776f r0a4a20d  
    4343${builddir}/libkernelCommon.la
    4444
    45 ### TODO: the following has to be addapted...
     45### TODO: the following has to be adapted...
    4646TESTS_ENVIRONMENT = SINGULARPATH='${abs_top_builddir}/libpolys/polys/.libs:${abs_top_builddir}/factory/gftables'
    4747TESTS_ENVIRONMENT += SINGULAR_ROOT_DIR='${abs_top_builddir}'
  • kernel/combinatorics/hilb.cc

    r323776f r0a4a20d  
    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

    r323776f r0a4a20d  
    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/fglmcomb.cc

    r323776f r0a4a20d  
    164164
    165165    int * weights = NULL;
    166     int * lengthes = NULL;
     166    int * lengths = NULL;
    167167    int * order = NULL;
    168168
     
    174174    STICKYPROT2( "%i monoms\n", numMonoms );
    175175
    176     // Allcoate Memory and initialize sets
     176    // Allocate Memory and initialize sets
    177177    m= (polyset)omAlloc( numMonoms * sizeof( poly ) );
    178178    poly temp= monset;
     
    216216    }
    217217    STICKYPROT( "\n" );
    218     lengthes= (int *)omAlloc( numMonoms * sizeof( int ) );
     218    lengths= (int *)omAlloc( numMonoms * sizeof( int ) );
    219219    order= (int *)omAlloc( numMonoms * sizeof( int ) );
    220220
     
    307307    STICKYPROT( "sizes: " );
    308308    for ( k= 0; k < numMonoms; k++ ) {
    309         lengthes[k]= v[k].numNonZeroElems();
    310         STICKYPROT2( "%i ", lengthes[k] );
     309        lengths[k]= v[k].numNonZeroElems();
     310        STICKYPROT2( "%i ", lengths[k] );
    311311    }
    312312    STICKYPROT( "\n" );
     
    316316        int best = 0;
    317317        for ( k= numMonoms - 1; k >= 0; k-- ) {
    318             if ( lengthes[k] > 0 ) {
     318            if ( lengths[k] > 0 ) {
    319319                if ( best == 0 ) {
    320320                    best= k+1;
    321321                }
    322322                else {
    323                     if ( lengthes[k] < lengthes[best-1] ) {
     323                    if ( lengths[k] < lengths[best-1] ) {
    324324                        best= k+1;
    325325                    }
     
    327327            }
    328328        }
    329         lengthes[best-1]= 0;
     329        lengths[best-1]= 0;
    330330        order[act]= best-1;
    331331        STICKYPROT2( " (%i) ", best );
     
    382382    }
    383383    // Free Memory
    384     omFreeSize( (ADDRESS)lengthes, numMonoms * sizeof( int ) );
     384    omFreeSize( (ADDRESS)lengths, numMonoms * sizeof( int ) );
    385385    omFreeSize( (ADDRESS)order, numMonoms * sizeof( int ) );
    386386//     for ( k= 0; k < numMonoms; k++ )
  • kernel/fglm/fglmgauss.cc

    r323776f r0a4a20d  
    66/*
    77* ABSTRACT - class gaussReducer. Used in fglmzero.cc and fglmhom.cc
    8 *  to find linear dependecies of fglmVectors.
     8*  to find linear dependencies of fglmVectors.
    99*/
    1010
  • kernel/fglm/fglmhom.cc

    r323776f r0a4a20d  
    3636#include "factory/templates/ftmpl_list.h"
    3737
    38 // obachman: Got rid off those "redefiende messages by includeing fglm.h
     38// obachman: Got rid of those "redefined" messages by including fglm.h
    3939#include "fglm.h"
    4040#if 0
     
    223223    for ( s= dat.numMonoms - 1; s >= 0; s-- ) {
    224224//        dat.monlist[s].mon.sm= pPermPoly( dat.monlist[s].mon.dm, vperm, currRing->N, NULL, 0 );
    225       // obachman: changed the folowing to reflect the new calling interface of
     225      // obachman: changed the following to reflect the new calling interface of
    226226      // pPermPoly -- Tim please check whether this is correct!
    227227        dat.monlist[s].mon.sm= pPermPoly( dat.monlist[s].mon.dm, vperm, oldRing, NULL, 0 );
  • kernel/fglm/fglmvec.cc

    r323776f r0a4a20d  
    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  {
  • kernel/fglm/fglmzero.cc

    r323776f r0a4a20d  
    572572}
    573573
    574 //     Searches through the border for a monomoial bm which devides m and returns
     574//     Searches through the border for a monomial bm which divides m and returns
    575575//      its normalform in vector representation.
    576576//     var contains the number of the variable v, s.t. bm = m * v
     
    662662//     returns them in "l".
    663663//     The ideal has to be zero-dimensional and reduced and has to be a
    664 //     real subset of the polynomal ring.
     664//     real subset of the polynomial ring.
    665665//     In any case it has to be zero-dimensional and minimal (check this
    666666//      via fglmIdealcheck). Any minimal but not reduced ideal is detected.
     
    10791079            // some elements of v are zeroed in data.gaussreduce(). Which
    10801080            // ones and how this was done is stored in p.
    1081             // originalV containes the unchanged v, which is later inserted
     1081            // originalV contains the unchanged v, which is later inserted
    10821082            // into the working list (via data.updateCandidates().
    10831083            fglmVector v = l.multiply( candidate.v, candidate.var );
     
    10871087            data.gaussreduce( v, p, pdenom );
    10881088            if ( v.isZero() ) {
    1089                 // Now v is linear dependend to the already found basis elements.
    1090                 // This means that v (rsp. candidate.monom) is the leading
     1089                // Now v is linear dependent to the already found basis elements.
     1090                // This means that v (resp. candidate.monom) is the leading
    10911091                // monomial of the next groebner-basis polynomial.
    10921092                data.newGroebnerPoly( p, candidate.monom );
     
    11891189}
    11901190
    1191 // for a descritption of the parameters see fglm.h
     1191// for a description of the parameters see fglm.h
    11921192BOOLEAN
    11931193fglmzero( ring sourceRing, ideal & sourceIdeal, ring destRing, ideal & destIdeal, BOOLEAN switchBack, BOOLEAN deleteIdeal )
  • kernel/fglm/test.cc

    r323776f r0a4a20d  
    313313  poly p1=pISet(1);
    314314
    315   // create tthe polynomial 2*x^3*z^2
     315  // create the polynomial 2*x^3*z^2
    316316  poly p2=p_ISet(2,R);
    317317  pSetExp(p2,1,3);
  • kernel/groebner_walk/test.cc

    r323776f r0a4a20d  
    314314  poly p1=pISet(1);
    315315
    316   // create tthe polynomial 2*x^3*z^2
     316  // create the polynomial 2*x^3*z^2
    317317  poly p2=p_ISet(2,R);
    318318  pSetExp(p2,1,3);
  • kernel/groebner_walk/walkMain.cc

    r323776f r0a4a20d  
    307307
    308308
    309 //unperturbedStartVectorStrategy IS NOW NOT ALLWAYS AS DEFAULT SET
     309//unperturbedStartVectorStrategy IS NOW NOT ALWAYS AS DEFAULT SET
    310310//TO TRUE BUT IS INPUT FROM fractalWalk64
    311311WalkState firstFractalWalkStep64(ideal & G,int64vec* & currw64,
     
    316316    if(unperturbedStartVectorStrategy){
    317317      return(unperturbedFirstStep64(G,currw64,destRing));
    318     //here G is updated since its adress is given as argument
     318    //here G is updated since its address is given as argument
    319319    }
    320320
     
    548548      state=fractalRec64(Gw,sigma,destMat,level+1,step);
    549549
    550       //The resulting GB is Gw since its adress is given as argument.
     550      //The resulting GB is Gw since its address is given as argument.
    551551      ideal recG=Gw;
    552552      ring temp=currRing;
  • kernel/groebner_walk/walkSupport.cc

    r323776f r0a4a20d  
    739739//leadExp
    740740///////////////////////////////////////////////////////////////////
    741 //Description: returns an intvec containg the exponet vector of p
     741//Description: returns an intvec containing the exponent vector of p
    742742///////////////////////////////////////////////////////////////////
    743743//Uses: sizeof,omAlloc,omFree
     
    971971//matIdLift
    972972///////////////////////////////////////////////////////////////////
    973 //Description: yields the same reslut as lift in Singular
     973//Description: yields the same result as lift in Singular
    974974///////////////////////////////////////////////////////////////////
    975975//Uses: idLift,idModule2formatedMatrix
  • kernel/ideals.cc

    r323776f r0a4a20d  
    559559    rChangeCurrRing(orig_ring);
    560560
    561   /* interprete result ----------------------------------------*/
     561  /* interpret result ----------------------------------------*/
    562562  result = idInit(IDELEMS(tempstd),maxrk);
    563563  k = 0;
     
    21642164
    21652165/*3
    2166 *handles for some ideal operations the ring/syzcomp managment
     2166*handles for some ideal operations the ring/syzcomp management
    21672167*returns all syzygies (componentwise-)shifted by -syzcomp
    21682168*or -syzcomp-1 (in case of ideals as input)
     
    25832583/*2
    25842584*decomposes the monom in a part of coefficients described by the
    2585 *complement of how and a monom in variables occuring in how, the
     2585*complement of how and a monom in variables occurring in how, the
    25862586*index of which in kbase is returned as integer pos (-1 if it don't
    25872587*exists)
  • kernel/ideals.h

    r323776f r0a4a20d  
    115115
    116116
    117 // GB algorithm for syz computaions:
     117// GB algorithm for syz computations:
    118118enum GbVariant
    119119{
  • kernel/linear_algebra/Cache.h

    r323776f r0a4a20d  
    255255     * If so, the method returns true; false otherwise.
    256256     * In order to make Cache::getValue (const KeyClass&) const
    257      * work properly, the user is strongly adviced to always check key
     257     * work properly, the user is strongly advised to always check key
    258258     * containment by means of Cache::hasKey (const KeyClass&) const.
    259259     * (The implementation at hand ensures that invoking hasKey and
     
    292292     * newly inserted pair (key --> value).<br>
    293293     * Because of that undesirable but possible effect, the method returns
    294      * whether the pair is actually contained in the cache after invokation of
     294     * whether the pair is actually contained in the cache after invocation of
    295295     * Cache::put (const KeyClass&, const ValueClass&).
    296296     * @param key an instance of KeyClass
  • kernel/linear_algebra/Minor.cc

    r323776f r0a4a20d  
    757757      };
    758758      _columnKey[newBitBlockIndex] = anInt;
    759       /* ...and we delete all entries in _columnKey[i] fo
     759      /* ...and we delete all entries in _columnKey[i] for
    760760         0 <= i < newBitBlockIndex */
    761761      for (int i = 0; i < newBitBlockIndex; i++)
  • kernel/linear_algebra/Minor.h

    r323776f r0a4a20d  
    5959     * the number of ints (i.e. 32-bit-numbers) we need to encode the set of
    6060     * rows;
    61      * If the higest row index is 70, we need 3 blocks of 32 bits to also
     61     * If the highest row index is 70, we need 3 blocks of 32 bits to also
    6262     * encode the 70th bit.
    6363     */
     
    6767     * the number of ints (i.e. 32-bit-numbers) we need to encode the set of
    6868     * columns;
    69      * If the higest column index is 70, we need 3 blocks of 32 bits to also
     69     * If the highest column index is 70, we need 3 blocks of 32 bits to also
    7070     * encode the 70th bit.
    7171     */
     
    456456    * on MinorValues has an impact on the caching behaviour in a given cache:
    457457    * Greater MinorValues will be cached longer than lower ones.<br>
    458     * More explicitely, this means: Make the return value of this method
     458    * More explicitly, this means: Make the return value of this method
    459459    * greater, and the given MinorValue will be cached longer when caching
    460460    * strategy 1 is deployed.<br>
     
    472472    * in a given cache: Greater MinorValues will be cached longer than lower
    473473    * ones.<br>
    474     * More explicitely, this means: Make the return value of this method
     474    * More explicitly, this means: Make the return value of this method
    475475    * greater, and the given MinorValue will be cached longer when caching
    476476    * strategy 1 is deployed.<br>
     
    490490    * in a given cache: Greater MinorValues will be cached longer than lower
    491491    * ones.<br>
    492     * More explicitely, this means: Make the return value of this method
     492    * More explicitly, this means: Make the return value of this method
    493493    * greater, and the given MinorValue will be cached longer when caching
    494494    * strategy 1 is deployed.<br>
     
    507507    * in a given cache: Greater MinorValues will be cached longer than lower
    508508    * ones.<br>
    509     * More explicitely, this means: Make the return value of this method
     509    * More explicitly, this means: Make the return value of this method
    510510    * greater, and the given MinorValue will be cached longer when caching
    511511    * strategy 1 is deployed.<br>
     
    524524    * in a given cache: Greater MinorValues will be cached longer than lower
    525525    * ones.<br>
    526     * More explicitely, this means: Make the return value of this method
     526    * More explicitly, this means: Make the return value of this method
    527527    * greater, and the given MinorValue will be cached longer when caching
    528528    * strategy 1 is deployed.<br>
     
    663663    * of the underlying cache: Greater MinorValues will be cached longer than
    664664    * lower ones.<br>
    665     * More explicitely, this means: Make the return value of this method
     665    * More explicitly, this means: Make the return value of this method
    666666    * greater, and the given MinorValue will be cached longer.<br>
    667667    * Internally, this method will call one of several implementations,
  • kernel/linear_algebra/MinorProcessor.cc

    r323776f r0a4a20d  
    616616        rowPermutation[r] = j;
    617617        /* Now we know that tempMatrix[rowPermutation[r] * k + r] is not zero.
    618            But carefull; we have to negate the sign, as there is always an odd
     618           But careful; we have to negate the sign, as there is always an odd
    619619           number of row transpositions to swap two given rows of a matrix. */
    620620        sign = -sign;
     
    14711471        rowPermutation[r] = j;
    14721472        /* Now we know that tempMatrix[rowPermutation[r] * k + r] is not zero.
    1473            But carefull; we have to negate the sign, as there is always an odd
     1473           But careful; we have to negate the sign, as there is always an odd
    14741474           number of row transpositions to swap two given rows of a matrix. */
    14751475        sign = -sign;
  • kernel/linear_algebra/MinorProcessor.h

    r323776f r0a4a20d  
    111111    * \c k columns inside a pre-defined submatrix of a pre-defined matrix.<br>
    112112    * The method will set \c _rowKey and \c columnKey to represent the
    113     * next possbile subsets of \c k rows and columns inside the submatrix
     113    * next possible subsets of \c k rows and columns inside the submatrix
    114114    * determined by \c _globalRowKey and \c _globalColumnKey.<br>
    115115    * When first called, this method will just shift \c _rowKey and
     
    129129    * the underlying matrix;
    130130    * \c _container will be used to fix a submatrix (e.g. 40 x 50) of a
    131     * larger matrix (e.g. 70 x 100). This is usefull when we would like to
     131    * larger matrix (e.g. 70 x 100). This is useful when we would like to
    132132    * compute all minors of a given size (e.g. 4 x 4) inside such a
    133133    * pre-defined submatrix.
     
    323323    * characteristic is non-zero, all results will be computed modulo this
    324324    * characteristic.
    325     * @param k the number of rows and columns in the minor to be comuted
     325    * @param k the number of rows and columns in the minor to be computed
    326326    * @param mk the representation of rows and columns of the minor to be
    327     *        comuted
     327    *        computed
    328328    * @param multipleMinors decides whether we compute just one or all minors
    329329    *        of a specified size
     
    355355    * characteristic is non-zero, all results will be computed modulo this
    356356    * characteristic.
    357     * @param k the number of rows and columns in the minor to be comuted
     357    * @param k the number of rows and columns in the minor to be computed
    358358    * @param mk the representation of rows and columns of the minor to be
    359     *        comuted
     359    *        computed
    360360    * @param characteristic 0 or the characteristic of the underlying
    361361    *        coefficient ring/field
     
    383383    * given characteristic is non-zero, all results will be computed modulo
    384384    * this characteristic.
    385     * @param k the number of rows and columns in the minor to be comuted
     385    * @param k the number of rows and columns in the minor to be computed
    386386    * @param mk the representation of rows and columns of the minor to be
    387387    *        computed
     
    582582    * If an ideal is given, it is assumed to be a standard basis. In this case,
    583583    * all results will be reduced w.r.t. to this basis.
    584     * @param k the number of rows and columns in the minor to be comuted
     584    * @param k the number of rows and columns in the minor to be computed
    585585    * @param mk the representation of rows and columns of the minor to be
    586     *        comuted
     586    *        computed
    587587    * @param multipleMinors decides whether we compute just one or all minors
    588588    *        of a specified size
     
    608608    * If an ideal is given, it is assumed to be a standard basis. In this case,
    609609    * all results will be reduced w.r.t. to this basis.
    610     * @param k the number of rows and columns in the minor to be comuted
     610    * @param k the number of rows and columns in the minor to be computed
    611611    * @param mk the representation of rows and columns of the minor to be
    612     *        comuted
     612    *        computed
    613613    * @param iSB NULL or a standard basis
    614614    * @return an instance of MinorValue representing the value of the
     
    627627    * If an ideal is given, it is assumed to be a standard basis. In this case,
    628628    * all results will be reduced w.r.t. to this basis.
    629     * @param k the number of rows and columns in the minor to be comuted
     629    * @param k the number of rows and columns in the minor to be computed
    630630    * @param mk the representation of rows and columns of the minor to be
    631     *        comuted
     631    *        computed
    632632    * @param iSB NULL or a standard basis
    633633    * @return an instance of MinorValue representing the value of the
  • kernel/linear_algebra/interpolation.cc

    r323776f r0a4a20d  
    129129STATIC_VAR bool denom_divisible; // common denominator is divisible by p (not used for modp)
    130130
    131 STATIC_VAR poly comparizon_p1;  //polynomials used to do comparizons by Singular
     131STATIC_VAR poly comparizon_p1;  //polynomials used to do comparisons by Singular
    132132STATIC_VAR poly comparizon_p2;
    133133
     
    974974
    975975
    976 static void NewGenerator (mono_type mon)  // new generator in modp comp found, shoul be stored on the list
     976static void NewGenerator (mono_type mon)  // new generator in modp comp found, should be stored on the list
    977977{
    978978     generator_entry *cur_ptr;
     
    10141014}
    10151015#if 0 /* only debbuging */
    1016 void PresentGenerator (int i)  // only for debuging, writes a generator in its form in program
     1016void PresentGenerator (int i)  // only for debugging, writes a generator in its form in program
    10171017{
    10181018     int j;
     
    11641164}
    11651165
    1166 static void Discard ()  // some unlucky prime occures
     1166static void Discard ()  // some unlucky prime occurs
    11671167{
    11681168     modp_result_entry *temp;
  • kernel/linear_algebra/linearAlgebra.cc

    r323776f r0a4a20d  
    3939 * numbers (, see numbers.h): nSize(n) provides a measure for the
    4040 * complexity of n. Thus, less complex pivot elements will be
    41  * prefered, and get therefore a smaller pivot score. Consequently,
     41 * preferred, and get therefore a smaller pivot score. Consequently,
    4242 * we simply return the value of nSize.
    4343 * An exception to this rule are the ground fields R, long R, and
  • kernel/linear_algebra/linearAlgebra.h

    r323776f r0a4a20d  
    1313 * the entries of the matrices are 'numbers' representing elements of K (and
    1414 * NOT 'polys' in K[x_1, x_2, ..., x_n]).
    15  * This restriction may become obselete in the future.
     15 * This restriction may become obsolete in the future.
    1616 *
    1717 * @author Frank Seelisch
  • kernel/linear_algebra/linear_algebra.dox

    r323776f r0a4a20d  
    1 /*! \page kernel_linear_algebra_page Linar algebra related algorithms
     1/*! \page kernel_linear_algebra_page Linear algebra related algorithms
    22
    33 This sub-package of kernel (\ref kernel_page) contains
  • kernel/linear_algebra/minpoly.h

    r323776f r0a4a20d  
    2222 * Every time a new row VA^i is inserted, it is reduced via Gauss' Algorithm,      *
    2323 * using right hand sides. If VA^i is reduced to zero, then the vectors are        *
    24  * linearly dependend, and the dependency can be read of at the right hand sides.  *
     24 * linearly dependent, and the dependency can be read of at the right hand sides.  *
    2525 *                                                                                 *
    2626 * Example: Compute the minimal polynomial of A = [[0,1],[1,1]] with V = [1,0]     *
     
    8181
    8282    // reset the matrix, so that we can use it to find another linear dependence
    83     // Note: there is no need to reinitalize the matrix and vectors!
     83    // Note: there is no need to reinitialize the matrix and vectors!
    8484    void resetMatrix();
    8585
  • kernel/linear_algebra/test.cc

    r323776f r0a4a20d  
    314314  poly p1=pISet(1);
    315315
    316   // create tthe polynomial 2*x^3*z^2
     316  // create the polynomial 2*x^3*z^2
    317317  poly p2=p_ISet(2,R);
    318318  pSetExp(p2,1,3);
  • kernel/maps/fast_maps.cc

    r323776f r0a4a20d  
    432432**********************************************************************/
    433433
    434 // substitute p everywhere the monomial occours,
     434// substitute p everywhere the monomial occurs,
    435435// return the number of substitutions
    436436static int maPoly_Substitute(macoeff c, poly p, ring dest_r)
  • kernel/maps/fast_maps.h

    r323776f r0a4a20d  
    7575// inserts ("adds") monomial what into poly into
    7676// returns the maMonomial which was inserted, or, if an equal one was found,
    77 // the monomial which "swalloed" the monomial
     77// the monomial which "swallowed" the monomial
    7878// It furthermore might reset into
    7979mapoly maPoly_InsertMonomial(mapoly &into, mapoly what, ring src_r);
     
    9696                       ring &src_r, ring &dest_r, BOOLEAN &no_sort);
    9797
    98 // collects tthe results into an ideal and destroys maideal
     98// collects the results into an ideal and destroys maideal
    9999ideal maIdeal_2_Ideal(maideal ideal, ring dest_r);
    100100
  • kernel/maps/find_perm.cc

    r323776f r0a4a20d  
    44/***************************************************************
    55 *  File:    find_perm.cc
    6  *  Purpose: is a map a permuation ?
     6 *  Purpose: is a map a permutation ?
    77 *  Author:  hannes
    88 *  Created: 16/01
  • kernel/maps/gen_maps.cc

    r323776f r0a4a20d  
    109109    }
    110110    // ----------------------------------------------------------
    111     // long polys in the image ?: possiblity of many common subexpressions
     111    // long polys in the image ?: possibility of many common subexpressions
    112112    if ((nMap==ndCopyMap) /* and !rIsPluralRing(image_r) */
    113113    && (map_id->nrows==1) /* i.e. only for ideal/map */
  • kernel/maps/gen_maps.h

    r323776f r0a4a20d  
    99/// image_id: the image of the variables
    1010/// image_r: the base ring for image_id
    11 /// nMap: map for coeffcients
     11/// nMap: map for coefficients
    1212ideal maMapIdeal(const ideal map_id, const ring map_r,const ideal image_id, const ring image_r, const nMapFunc nMap);
    1313
     
    1717/// image_id: the image of the variables
    1818/// image_r: the base ring for image_id
    19 /// nMap: map for coeffcients
     19/// nMap: map for coefficients
    2020poly maMapPoly(const poly map_p, const ring map_r,const ideal image_id, const ring image_r, const nMapFunc nMap);
    2121
  • kernel/maps/test.cc

    r323776f r0a4a20d  
    314314  poly p1=pISet(1);
    315315
    316   // create tthe polynomial 2*x^3*z^2
     316  // create the polynomial 2*x^3*z^2
    317317  poly p2=p_ISet(2,R);
    318318  pSetExp(p2,1,3);
  • kernel/mod2.h

    r323776f r0a4a20d  
    8888
    8989/*******************************************************************
    90  * Miscellanous Defines
     90 * Miscellaneous Defines
    9191 ******************************************************************/
    9292#ifndef HAVE_LIBPARSER
     
    186186   The omDebug routines are controlled by the values of OM_TRACK, OM_CHECK
    187187   and OM_KEEP.  There meaning is roughly as follows:
    188    OM_TRACK: strored with address                              : extra space
    189      0     : no additional info is stored                      : 0
    190      1     : file:line of location where address was allocated : 1 word
    191      2     : plus backtrace of stack where adress was allocated: 6 words
    192      3     : plus size/bin info and front-, and back padding   : 9 words
    193      4     : plus file:line of location where adress was freed : 10 words
    194      5     : plus backtrace of stack where adress was allocated: 15 words
     188   OM_TRACK: stored with address                                 : extra space
     189     0     : no additional info is stored                        : 0
     190     1     : file:line of location where address was allocated   : 1 word
     191     2     : plus backtrace of stack where address was allocated : 6 words
     192     3     : plus size/bin info and front-, and back padding     : 9 words
     193     4     : plus file:line of location where address was freed : 10 words
     194     5     : plus backtrace of stack where address was allocated : 15 words
    195195   OM_CHECK: checks done
    196196     0     : no checks
     
    224224     ExternalRoutine();
    225225     om_Opts.MinCheck = check; omOpts.MinTrack = track; omOpts.Keep = keep;
    226    ensures that all calls omDebug routines  occuring during the computation of
     226   ensures that all calls omDebug routines  occurring during the computation of
    227227   ExternalRoutine() are done with OM_CHECK==3 and OM_TRACK==5, and
    228228   calls to omFree only mark addresses as free and not really free them.
     
    254254   + You can safely use any free/realloc routine in combination with any alloc
    255255     routine (including the debug versions): E.g., an address allocated with
    256      omAllocBin can be freed with omfree, or an adress allocated with
     256     omAllocBin can be freed with omfree, or an address allocated with
    257257     om(Debug)Alloc can be freed with omfree, or omFree, or omFreeSize, etc.
    258258     However, keep in mind that the efficiency decreases from
  • kernel/numeric/mpr_base.cc

    r323776f r0a4a20d  
    9595
    9696  /* Remaps a result of LP to the according point set Qi.
    97    * Returns false iff remaping was not possible, otherwise true.
     97   * Returns false iff remapping was not possible, otherwise true.
    9898   */
    9999  bool remapXiToPoint( const int indx, pointSet **pQ, int *set, int *vtx );
     
    176176  inline onePointP operator[] ( const int index );
    177177
    178   /** Adds a point to pointSet, copy vert[0,...,dim] ot point[num+1][0,...,dim].
     178  /** Adds a point to pointSet, copy vert[0,...,dim] to point[num+1][0,...,dim].
    179179   * Returns false, iff additional memory was allocated ( i.e. num >= max )
    180180   * else returns true
     
    182182  bool addPoint( const onePointP vert );
    183183
    184   /** Adds a point to pointSet, copy vert[0,...,dim] ot point[num+1][0,...,dim].
     184  /** Adds a point to pointSet, copy vert[0,...,dim] to point[num+1][0,...,dim].
    185185   * Returns false, iff additional memory was allocated ( i.e. num >= max )
    186186   * else returns true
     
    188188  bool addPoint( const int * vert );
    189189
    190   /** Adds a point to pointSet, copy vert[0,...,dim] ot point[num+1][0,...,dim].
     190  /** Adds a point to pointSet, copy vert[0,...,dim] to point[num+1][0,...,dim].
    191191   * Returns false, iff additional memory was allocated ( i.e. num >= max )
    192192   * else returns true
     
    295295  void runMayanPyramid( int dim );
    296296
    297   /**  Compute v-distance via Linear Programing
     297  /**  Compute v-distance via Linear Programming
    298298   * Linear Program finds the v-distance of the point in accords[].
    299299   * The v-distance is the distance along the direction v to boundary of
     
    11971197    {     // acoords[dim] >= minR  ??
    11981198      mprSTICKYPROT(ST_SPARSE_MREC1);
    1199       runMayanPyramid( dim + 1 );         // recurse with higer dimension
     1199      runMayanPyramid( dim + 1 );         // recurse with higher dimension
    12001200    }
    12011201    else
     
    12071207      {
    12081208        mprSTICKYPROT(ST_SPARSE_MREC2);
    1209         runMayanPyramid( dim + 1 );       // recurse with higer dimension
     1209        runMayanPyramid( dim + 1 );       // recurse with higher dimension
    12101210      }
    12111211    }
     
    12561256      LP->n++;
    12571257
    1258       // objective funtion, minimize
     1258      // objective function, minimize
    12591259      LP->LiPM[1][LP->n] = - ( (mprfloat) (*pQ[i])[k]->point[pQ[i]->dim] / SCALEDOWN );
    12601260
     
    14541454      if ( epos == 0 )
    14551455      {
    1456         // this can happen, if the shift vektor or the lift funktions
     1456        // this can happen, if the shift vector or the lift functions
    14571457        // are not generically chosen.
    14581458        Werror("resMatrixSparse::createMatrix: Found exponent not in E, id %d, set [%d, %d]!",
  • kernel/numeric/mpr_numeric.h

    r323776f r0a4a20d  
    200200  int m1,m2,m3;  // constraints <=, >= and ==
    201201  int icase;     // == 0: finite solution found;
    202                  // == +1 objective funtion unbound; == -1: no solution
     202                 // == +1 objective function unbound; == -1: no solution
    203203  int *izrov,*iposv;
    204204
  • kernel/numeric/test.cc

    r323776f r0a4a20d  
    314314  poly p1=pISet(1);
    315315
    316   // create tthe polynomial 2*x^3*z^2
     316  // create the polynomial 2*x^3*z^2
    317317  poly p2=p_ISet(2,R);
    318318  pSetExp(p2,1,3);
  • kernel/old/old.Poly.h

    r323776f r0a4a20d  
    340340    ptr->print();
    341341  }
    342   //* ressource managed by Singular
     342  //* resource managed by Singular
    343343  char* c_string() const{
    344344
  • kernel/old/old.PowerSeries.h

    r323776f r0a4a20d  
    141141  PowerSeriesBase(const numerator_type &a, const denominator_type & b):numerator(a),denominator(b){
    142142    assume(a.getRing()==b.getRing());
    143     //asume b!=NULL
     143    //assume b!=NULL
    144144  }
    145145  typedef PowerSeriesInputIterator<traits> iterator;
  • kernel/oswrapper/feread.cc

    r323776f r0a4a20d  
    124124  #endif
    125125  #ifndef READLINE_READLINE_H_OK
    126     /* declare everything we need explicitely and do not rely on includes */
     126    /* declare everything we need explicitly and do not rely on includes */
    127127    EXTERN_VAR char * rl_readline_name;
    128128    EXTERN_VAR char *rl_line_buffer;
  • kernel/oswrapper/test.cc

    r323776f r0a4a20d  
    314314  poly p1=pISet(1);
    315315
    316   // create tthe polynomial 2*x^3*z^2
     316  // create the polynomial 2*x^3*z^2
    317317  poly p2=p_ISet(2,R);
    318318  pSetExp(p2,1,3);
  • kernel/oswrapper/vspace.h

    r323776f r0a4a20d  
    116116#endif
    117117#ifdef HAVE_CPP_THREADS
    118   // We only need to define the copy constructur for the
     118  // We only need to define the copy constructor for the
    119119  // atomic version, as the std::atomic_flag constructor
    120120  // is deleted.
     
    14471447#endif
    14481448#ifdef HAVE_CPP_THREADS
    1449   // We only need to define the copy constructur for the
     1449  // We only need to define the copy constructor for the
    14501450  // atomic version, as the std::atomic_flag constructor
    14511451  // is deleted.
  • kernel/polys.cc

    r323776f r0a4a20d  
    99#include "polys/clapconv.h"
    1010
    11 /// Widely used global variable which specifies the current polynomial ring for Singular interpreter and legacy implementatins.
     11/// Widely used global variable which specifies the current polynomial ring for Singular interpreter and legacy implementations.
    1212/// @Note: one should avoid using it in newer designs, for example due to possible problems in parallelization with threads.
    1313VAR ring  currRing = NULL;
  • kernel/polys.h

    r323776f r0a4a20d  
    1 /*! \file kernel/polys.h Compatiblity layer for legacy polynomial operations (over @ref currRing)
     1/*! \file kernel/polys.h Compatibility layer for legacy polynomial operations (over @ref currRing)
    22
    33 Macro defines for legacy polynomial operations used in @ref kernel_page and @ref singular_page.
     
    55 Notice that they have different prefix: `p` instead of `p_`.
    66
    7  See also related global ring variable and the correct ring changeing routine:
     7 See also related global ring variable and the correct ring changing routine:
    88 - \ref currRing
    99 - \ref rChangeCurrRing
     
    5252/***************************************************************
    5353 *
    54  * Allocation/Initalization/Deletion
     54 * Allocation/Initialization/Deletion
    5555 * except for pHead, all polys must be != NULL
    5656 *
     
    162162/// polynomial division a/b, ignoring the rest
    163163/// via singclap_pdivide resp. idLift
    164 /// destroyes a,b
     164/// destroys a,b
    165165poly p_Divide(poly a, poly b, const ring r);
    166166/// polynomial division a/b, ignoring the rest
     
    222222
    223223
    224 /// Assume: If considerd only as poly in any component of p
     224/// Assume: If considered only as poly in any component of p
    225225/// (say, monomials of other components of p are set to 0),
    226226/// then p is already sorted correctly
     
    275275/***************************************************************
    276276 *
    277  * Degree stuff -- see p_polys.cc for explainations
     277 * Degree stuff -- see p_polys.cc for explanations
    278278 *
    279279 ***************************************************************/
     
    371371#define   pMinDeg(p,w) p_MinDeg(p,w,currRing)
    372372#define   pSeries(n,p,u,w) p_Series(n,p,u,w,currRing)
    373 // maximum weigthed degree of all monomials of p, w is indexed from
     373// maximum weighted degree of all monomials of p, w is indexed from
    374374// 1..pVariables
    375375
  • kernel/preimage.cc

    r323776f r0a4a20d  
    1919*shifts the variables between minvar and maxvar of p  \in p_ring to the
    2020*first maxvar-minvar+1 variables in the actual ring
    21 *be carefull: there is no range check for the variables of p
     21*be careful: there is no range check for the variables of p
    2222*/
    2323static poly pChangeSizeOfPoly(ring p_ring, poly p,int minvar,int maxvar, const ring dst_r)
     
    132132                              tmpR);
    133133  }
    134   // we ignore here homogenity - may be changed later:
     134  // we ignore here homogeneity - may be changed later:
    135135
    136136  temp2 = kStd(temp1,NULL,isNotHomog,NULL);
  • kernel/test.cc

    r323776f r0a4a20d  
    544544  poly p1=pISet(1);
    545545
    546   // create tthe polynomial 2*x^3*z^2
     546  // create the polynomial 2*x^3*z^2
    547547  poly p2=p_ISet(2,R);
    548548  pSetExp(p2,1,3);
Note: See TracChangeset for help on using the changeset viewer.