# Changeset c57af60 in git

Ignore:
Timestamp:
Nov 14, 2022, 11:56:50 AM (3 months ago)
Branches:
Children:
Parents:
6cf934536bdf5e13d6b4393257098584b66634f1
Message:
again fixing typos in kernel/
Location:
kernel
Files:
13 edited

Unmodified
Removed
• ## kernel/GBEngine/kstd1.cc

 r6cf934 #endif // redtailBBa against T for inhomogenous input // redtailBBa against T for inhomogeneous input if (!TEST_OPT_OLDSTD) withT = ! strat->homog;
• ## kernel/GBEngine/kstd2.cc

 r6cf934 for(int i = 0;isbaEnterS;i++) { //Update: now the element is at the corect place //Update: now the element is at the correct place //i+1 because on the 0 position is the sigdrop element enterT(strat->L[strat->Ll-(i)],strat); if(strat->P.sig != NULL) strat->sbaEnterS = pGetComp(strat->P.sig)-1; //else we already set it at the beggining of the loop //else we already set it at the beginning of the loop #ifdef KDEBUG memset(&(strat->P), 0, sizeof(strat->P)); k = strat->Ll; #if 1 // 1 - adds just the unused ones, 0 - adds everthing // 1 - adds just the unused ones, 0 - adds everything for(;k>=0 && (strat->L[k].p1 != NULL || strat->L[k].p2 != NULL);k--) {
• ## kernel/fglm/fglmzero.cc

 r6cf934 // some elements of v are zeroed in data.gaussreduce(). Which // ones and how this was done is stored in p. // originalV containes the unchanged v, which is later inserted // originalV contains the unchanged v, which is later inserted // into the working list (via data.updateCandidates(). fglmVector v = l.multiply( candidate.v, candidate.var );
• ## kernel/groebner_walk/test.cc

 r6cf934 poly p1=pISet(1); // create tthe polynomial 2*x^3*z^2 // create the polynomial 2*x^3*z^2 poly p2=p_ISet(2,R); pSetExp(p2,1,3);
• ## kernel/ideals.h

 r6cf934 // GB algorithm for syz computaions: // GB algorithm for syz computations: enum GbVariant {
• ## kernel/linear_algebra/Minor.h

 r6cf934 * the number of ints (i.e. 32-bit-numbers) we need to encode the set of * rows; * If the higest row index is 70, we need 3 blocks of 32 bits to also * If the highest row index is 70, we need 3 blocks of 32 bits to also * encode the 70th bit. */ * the number of ints (i.e. 32-bit-numbers) we need to encode the set of * columns; * If the higest column index is 70, we need 3 blocks of 32 bits to also * If the highest column index is 70, we need 3 blocks of 32 bits to also * encode the 70th bit. */
• ## kernel/linear_algebra/MinorProcessor.cc

 r6cf934 rowPermutation[r] = j; /* Now we know that tempMatrix[rowPermutation[r] * k + r] is not zero. But carefull; we have to negate the sign, as there is always an odd But careful; we have to negate the sign, as there is always an odd number of row transpositions to swap two given rows of a matrix. */ sign = -sign; rowPermutation[r] = j; /* Now we know that tempMatrix[rowPermutation[r] * k + r] is not zero. But carefull; we have to negate the sign, as there is always an odd But careful; we have to negate the sign, as there is always an odd number of row transpositions to swap two given rows of a matrix. */ sign = -sign;
• ## kernel/linear_algebra/MinorProcessor.h

 r6cf934 * \c k columns inside a pre-defined submatrix of a pre-defined matrix.
* The method will set \c _rowKey and \c columnKey to represent the * next possbile subsets of \c k rows and columns inside the submatrix * next possible subsets of \c k rows and columns inside the submatrix * determined by \c _globalRowKey and \c _globalColumnKey.
* When first called, this method will just shift \c _rowKey and * the underlying matrix; * \c _container will be used to fix a submatrix (e.g. 40 x 50) of a * larger matrix (e.g. 70 x 100). This is usefull when we would like to * larger matrix (e.g. 70 x 100). This is useful when we would like to * compute all minors of a given size (e.g. 4 x 4) inside such a * pre-defined submatrix. * characteristic is non-zero, all results will be computed modulo this * characteristic. * @param k the number of rows and columns in the minor to be comuted * @param k the number of rows and columns in the minor to be computed * @param mk the representation of rows and columns of the minor to be *        comuted *        computed * @param multipleMinors decides whether we compute just one or all minors *        of a specified size * characteristic is non-zero, all results will be computed modulo this * characteristic. * @param k the number of rows and columns in the minor to be comuted * @param k the number of rows and columns in the minor to be computed * @param mk the representation of rows and columns of the minor to be *        comuted *        computed * @param characteristic 0 or the characteristic of the underlying *        coefficient ring/field * given characteristic is non-zero, all results will be computed modulo * this characteristic. * @param k the number of rows and columns in the minor to be comuted * @param k the number of rows and columns in the minor to be computed * @param mk the representation of rows and columns of the minor to be *        computed * If an ideal is given, it is assumed to be a standard basis. In this case, * all results will be reduced w.r.t. to this basis. * @param k the number of rows and columns in the minor to be comuted * @param k the number of rows and columns in the minor to be computed * @param mk the representation of rows and columns of the minor to be *        comuted *        computed * @param multipleMinors decides whether we compute just one or all minors *        of a specified size * If an ideal is given, it is assumed to be a standard basis. In this case, * all results will be reduced w.r.t. to this basis. * @param k the number of rows and columns in the minor to be comuted * @param k the number of rows and columns in the minor to be computed * @param mk the representation of rows and columns of the minor to be *        comuted *        computed * @param iSB NULL or a standard basis * @return an instance of MinorValue representing the value of the * If an ideal is given, it is assumed to be a standard basis. In this case, * all results will be reduced w.r.t. to this basis. * @param k the number of rows and columns in the minor to be comuted * @param k the number of rows and columns in the minor to be computed * @param mk the representation of rows and columns of the minor to be *        comuted *        computed * @param iSB NULL or a standard basis * @return an instance of MinorValue representing the value of the
• ## kernel/linear_algebra/linearAlgebra.cc

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

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

 r6cf934 /*! \page kernel_linear_algebra_page Linar algebra related algorithms /*! \page kernel_linear_algebra_page Linear algebra related algorithms This sub-package of kernel (\ref kernel_page) contains
• ## kernel/linear_algebra/minpoly.h

 r6cf934 * Every time a new row VA^i is inserted, it is reduced via Gauss' Algorithm,      * * using right hand sides. If VA^i is reduced to zero, then the vectors are        * * linearly dependend, and the dependency can be read of at the right hand sides.  * * linearly dependent, and the dependency can be read of at the right hand sides.  * *                                                                                 * * Example: Compute the minimal polynomial of A = [[0,1],[1,1]] with V = [1,0]     * // reset the matrix, so that we can use it to find another linear dependence // Note: there is no need to reinitalize the matrix and vectors! // Note: there is no need to reinitialize the matrix and vectors! void resetMatrix();
• ## kernel/oswrapper/vspace.h

 r6cf934 #endif #ifdef HAVE_CPP_THREADS // We only need to define the copy constructur for the // We only need to define the copy constructor for the // atomic version, as the std::atomic_flag constructor // is deleted.
Note: See TracChangeset for help on using the changeset viewer.