Changeset 1a3778 in git


Ignore:
Timestamp:
Sep 28, 2022, 5:07:30 PM (19 months ago)
Author:
Frédéric Chapoton <chapoton@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
aec6fead7ad079baf52b503b680f55839809e605
Parents:
1291fb4c2054a2414ab193f6b00166905b065f98
Message:
fix some typos in IntegerProgramming
Location:
IntegerProgramming
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • IntegerProgramming/IP_algorithms.cc

    r1291fb r1a3778  
    7070/////////////////////////// input /////////////////////////////////////////
    7171
    72   char format_string[128]; // to verifie file format
     72  char format_string[128]; // to verify file format
    7373  int constraints;       // number of equality constraints
    7474  int variables;         // number of variables (without auxiliary variables)
     
    358358/////////////////////////// input /////////////////////////////////////////
    359359
    360   char format_string[128]; // to verifie file format
     360  char format_string[128]; // to verify file format
    361361  int constraints;       // number of equality constraints
    362362  int variables;         // number of variables (without auxiliary variables)
     
    655655/////////////////////////// input /////////////////////////////////////////
    656656
    657   char format_string[128]; // to verifie file format
     657  char format_string[128]; // to verify file format
    658658  int constraints;       // number of equality constraints
    659659  int variables;         // number of variables (without auxiliary variables)
     
    944944/////////////////////////// input /////////////////////////////////////////
    945945
    946   char format_string[128]; // to verifie file format
     946  char format_string[128]; // to verify file format
    947947  int constraints;       // number of equality constraints
    948948  int variables;         // number of variables (without auxiliary variables)
     
    12321232/////////////////////////// input /////////////////////////////////////////
    12331233
    1234   char format_string[128]; // to verifie file format
     1234  char format_string[128]; // to verify file format
    12351235  int constraints;       // number of equality constraints
    12361236  int variables;         // number of variables
     
    14051405
    14061406  // read positive vector in the row space of the matrix
    1407   // such a vector induces a homogenous grading on the ideal
     1407  // such a vector induces a homogeneous grading on the ideal
    14081408
    14091409  input>>format_string;
     
    14931493  clock_t start, end;
    14941494
    1495   // construct homogenous term ordering
     1495  // construct homogeneous term ordering
    14961496  term_ordering w(variables, hom_grad, W_REV_LEX, HOMOGENEOUS);
    14971497
     
    20092009/////////////////////////// input /////////////////////////////////////////
    20102010
    2011   char format_string[128];     // to verifie file format
     2011  char format_string[128];     // to verify file format
    20122012  int constraints;       // number of equality constraints
    20132013  int variables;         // number of variables
     
    21892189  // read positive vector in the row space of the matrix
    21902190  // such a vector induces a grading with respect to which the ideal is
    2191   // homogenous
     2191  // homogeneous
    21922192
    21932193  input>>format_string;
     
    22842284  clock_t start, end;
    22852285
    2286   // construct homogenous term ordering
     2286  // construct homogeneous term ordering
    22872287  term_ordering w(variables, hom_grad, W_REV_LEX, HOMOGENEOUS);
    22882288
     
    30643064/////////// computation and output (second part) //////////////////////////
    30653065
    3066   // distinguish 3 cases to verifie the consistency of the vector dimension
     3066  // distinguish 3 cases to verify the consistency of the vector dimension
    30673067  // and the number of variables
    30683068
     
    33813381  ifstream _new(NEW_COST);
    33823382
    3383   // verifie existence of files
     3383  // verify existence of files
    33843384
    33853385  if(!old)
     
    37163716  }
    37173717
    3718   // Now we can verifie consistency of both files with respect to the number
     3718  // Now we can verify consistency of both files with respect to the number
    37193719  // of weighted variables:
    37203720
  • IntegerProgramming/LLL.h

    r1291fb r1a3778  
    33// This file contains the implementation of two special variants of the
    44// LLL-algorithm.
    5 // For further explainations see the book of Henri Cohen, A Course in
     5// For further explanations see the book of Henri Cohen, A Course in
    66// Computational Algebraic Number Theory.
    77
  • IntegerProgramming/binomial.h

    r1291fb r1a3778  
    111111  short error_status() const;
    112112  // Returns _number_of_variables iff _number_of_variables<0
    113   // (this is the "errror flag").
     113  // (this is the "error flag").
    114114
    115115
     
    123123  // Access operator for reading exponent_vector[i]
    124124  // (cannot be used to overwrite exponent_vector[i]);
    125   // no range chack on i!
     125  // no range check on i!
    126126
    127127
  • IntegerProgramming/list.cc

    r1291fb r1a3778  
    5858// - The end_dummy guarantees that the deletion method of the simply linked
    5959//   list works: Deletion is done by copying the next element to the actual
    60 //   position and then deleting the original, see below for an explaination.
     60//   position and then deleting the original, see below for an explanation.
    6161//   This would cause problems when deleting the last element; then the
    62 //   next-pointer of the preceeding element would reference freed memory
     62//   next-pointer of the preceding element would reference freed memory
    6363//   (it cannot be manipulated, is unknown). So the end_dummy as an
    6464//   artificial last element avoids this problem.
     
    388388  // .. and finally inserting bin at the old place
    389389  // Remember that we cannot insert a new element between the referenced
    390   // element and its preceeding (we do not know the preceeding element)
     390  // element and its preceding (we do not know the preceding element)
    391391  iter->entry=&bin;
    392392  iter->done=FALSE;
     
    430430  // .. and finally inserting bin at the old place
    431431  // Remember that we cannot insert a new element between the referenced
    432   // element and its preceeding (we do not know the preceeding element)
     432  // element and its preceding (we do not know the preceding element)
    433433  iter->entry=&bin;
    434434  iter->next=aux;
     
    10941094
    10951095// When deleting or extracting an element of a simply linked list, the
    1096 // next-pointer of the previous element cannot be manipulated (is unkonwn!).
     1096// next-pointer of the previous element cannot be manipulated (is unknown!).
    10971097// So deletion must be done by copying the next element to the actual position
    10981098// and then deleting the original. Notice that only pointers are copies, never
  • IntegerProgramming/matrix.cc

    r1291fb r1a3778  
    347347
    348348  // determine the start vector, i.e. the one with least zero components, but
    349   // smallest possible (euclidian) norm
     349  // smallest possible (euclidean) norm
    350350  int min_index=-1;
    351351  for(int i=0;i<_kernel_dimension;i++)
     
    397397
    398398
    399 // STEP 3: Can a furhter zero component be "eliminated"?
     399// STEP 3: Can a further zero component be "eliminated"?
    400400// If this is the case, find a basis vector that can do this.
    401401
  • IntegerProgramming/matrix.h

    r1291fb r1a3778  
    55// problem. It offers facilities to convert a two-dimensional integer array
    66// into a matrix and to read a matrix from an input file.
    7 // Furhermore, some special routines needed by the IP-algorithms are
     7// Furthermore, some special routines needed by the IP-algorithms are
    88// implemented:
    99// - the computation of a lattice basis for the integer kernel via the LLL
     
    106106
    107107  int row_number() const;
    108   // Retuns the row number.
     108  // Returns the row number.
    109109
    110110  int column_number() const;
  • IntegerProgramming/term_ordering.h

    r1291fb r1a3778  
    2121//   separate function instead of doing it in the constructors.
    2222
    23 // For the same reasons as mentionned in the binomial class, frequently
     23// For the same reasons as mentioned in the binomial class, frequently
    2424// used operations on Integer vectors do not perform range checks. Nor do
    2525// they check if an error has occurred (i.e. control the "error flag", see
     
    6767  // homogeneous one (i.e. the weighted part), else to FALSE. The standard
    6868  // setting is FALSE.
    69   // The routine compare_to_zero is faster if the term ordering is homogenous.
     69  // The routine compare_to_zero is faster if the term ordering is homogeneous.
    7070  // It would be safer and more natural to take this flag as a member of
    7171  // the ideal class; this would, however, require many supplementary
     
    7878  term_ordering(const BOOLEAN& homogeneous=FALSE);
    7979  // Sets weighted_block_size and elimination_block_size to zero.
    80   // With this default contructor, the term ordering can be taken as a member
     80  // With this default constructor, the term ordering can be taken as a member
    8181  // of another class (the ideal class in our case).
    8282
     
    175175  // actual term ordering. The comparison of its two monomials is done
    176176  // according to the binomial data structure:
    177   // Instead of comparing explicitely two monomials, the Integer vector
     177  // Instead of comparing explicitly two monomials, the Integer vector
    178178  // corresponding to their difference is compared to the zero vector.
    179179  // The function returns
Note: See TracChangeset for help on using the changeset viewer.