Changeset 6cf934 in git


Ignore:
Timestamp:
Nov 14, 2022, 11:41:51 AM (3 months ago)
Author:
Frédéric Chapoton <chapoton@…>
Branches:
(u'spielwiese', 'ad2543eab51733612ba7d118afc77edca719600e')
Children:
c57af60be7b45c4f30db8913b7cde4eb782e6121
Parents:
c858487b7689b030112512a2e1be0f968d4f7c22
Message:
more typos fixed in kernel
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • .codespell_ignore

    rc858487 r6cf934  
     1alle
     2als
     3degres
    14ende
    25erros
     6funktion
    37froms
    48fromt
     
    812nin
    913nnumber
     14oder
    1015padd
    1116preverse
     17pres
    1218ressources
    1319sring
    1420strat
     21thev
    1522witht
    1623wth
  • kernel/fglm/fglmcomb.cc

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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
  • kernel/fglm/fglmzero.cc

    rc858487 r6cf934  
    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.
     
    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

    rc858487 r6cf934  
    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/walkMain.cc

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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/linear_algebra/Cache.h

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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/interpolation.cc

    rc858487 r6cf934  
    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/test.cc

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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

    rc858487 r6cf934  
    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/test.cc

    rc858487 r6cf934  
    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/numeric/mpr_base.cc

    rc858487 r6cf934  
    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/test.cc

    rc858487 r6cf934  
    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);
Note: See TracChangeset for help on using the changeset viewer.