Changeset c57af60 in git


Ignore:
Timestamp:
Nov 14, 2022, 11:56:50 AM (3 months ago)
Author:
Frédéric Chapoton <chapoton@…>
Branches:
(u'spielwiese', 'ad2543eab51733612ba7d118afc77edca719600e')
Children:
32c48290ade9c8b3bf376a8ed769638bcc54abdf
Parents:
6cf934536bdf5e13d6b4393257098584b66634f1
Message:
again fixing typos in kernel/
Location:
kernel
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • kernel/GBEngine/kstd1.cc

    r6cf934 rc57af60  
    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/kstd2.cc

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

    r6cf934 rc57af60  
    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 );
  • kernel/groebner_walk/test.cc

    r6cf934 rc57af60  
    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/ideals.h

    r6cf934 rc57af60  
    115115
    116116
    117 // GB algorithm for syz computaions:
     117// GB algorithm for syz computations:
    118118enum GbVariant
    119119{
  • kernel/linear_algebra/Minor.h

    r6cf934 rc57af60  
    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     */
  • kernel/linear_algebra/MinorProcessor.cc

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

    r6cf934 rc57af60  
    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/linearAlgebra.cc

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

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

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

    r6cf934 rc57af60  
    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/oswrapper/vspace.h

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