fix: typo spelling grammar

Author: slowy07

examples/dotnet/BalanceGroupSat.cs

@@ -129,7 +129,7 @@ static void Main(string[] args)
 
         // Compute the maximum number of colors in a group.
         int maxColor = numItemsPerGroup / minItemsOfSameColorPerGroup;
-        // Redundant contraint: The problem does not solve in reasonable time
+        // Redundant constraint: The problem does not solve in reasonable time
         // without it.
         if (maxColor < numberColors)
         {

examples/dotnet/csrabbitspheasants.cs

@@ -42,7 +42,7 @@ public override Decision Next(Solver solver)
 public class CsRabbitsPheasants
 {
     /**
-     * Solves the rabbits + pheasants problem.  We are seing 20 heads
+     * Solves the rabbits + pheasants problem.  We are seeing 20 heads
      * and 56 legs. How many rabbits and how many pheasants are we thus
      * seeing?
      */

ortools/bop/bop_lns.cc

@@ -208,7 +208,7 @@ bool UseLinearRelaxationForSatAssignmentPreference(
 
 // Note(user): We prefer to start with a really low difficulty as this works
 // better for large problem, and for small ones, it will be really quickly
-// increased anyway. Maybe a better appproach is to start by relaxing something
+// increased anyway. Maybe a better approach is to start by relaxing something
 // like 10 variables instead of having a fixed percentage.
 BopAdaptiveLNSOptimizer::BopAdaptiveLNSOptimizer(
     const std::string& name, bool use_lp_to_guide_sat,

ortools/constraint_solver/constraint_solver.h

@@ -1643,7 +1643,7 @@ class Solver {
                                 std::vector<int64_t> sinks,
                                 std::vector<IntVar*> status);
 #ifndef SWIG
-  /// Contraint enforcing, for each pair (i,j) in precedences, i to be before j
+  /// Constraint enforcing, for each pair (i,j) in precedences, i to be before j
   /// in paths defined by next variables.
   // TODO(user): This constraint does not make holes in variable domains;
   /// the implementation can easily be modified to do that; evaluate the impact

ortools/constraint_solver/routing.h

@@ -1328,7 +1328,7 @@ class RoutingModel {
       const Assignment& solution_assignment, const RoutingDimension& dimension);
 #endif
   /// Returns the underlying constraint solver. Can be used to add extra
-  /// constraints and/or modify search algoithms.
+  /// constraints and/or modify search algorithms.
   Solver* solver() const { return solver_.get(); }
 
   /// Returns true if the search limit has been crossed.

ortools/constraint_solver/routing_search.h

@@ -124,7 +124,7 @@ AutomaticFirstSolutionStrategy(bool has_pickup_deliveries,
 /// More details:
 /// Using local search filters to build a solution. The approach is pretty
 /// straight-forward: have a general assignment storing the current solution,
-/// build delta assigment representing possible extensions to the current
+/// build delta assignment representing possible extensions to the current
 /// solution and validate them with filters.
 /// The tricky bit comes from using the assignment and filter APIs in a way
 /// which avoids the lazy creation of internal hash_maps between variables
@@ -794,7 +794,7 @@ class ComparatorCheapestAdditionFilteredHeuristic
 /// Clarke & Wright's Savings heuristic. For each pair of nodes, the savings
 /// value is the difference between the cost of two routes visiting one node
 /// each and one route visiting both nodes. Routes are built sequentially, each
-/// route being initialized from the pair with the best avalaible savings value
+/// route being initialized from the pair with the best available savings value
 /// then extended by selecting the nodes with best savings on both ends of the
 /// partial route. Cost is based on the arc cost function of the routing model
 /// and cost classes are taken into account.

ortools/constraint_solver/samples/VrpInitialRoutes.cs

@@ -131,7 +131,7 @@ public static void Main(String[] args)
         distanceDimension.SetGlobalSpanCostCoefficient(100);
         // [END distance_constraint]
 
-        // Get inital solution from routes.
+        // Get initial solution from routes.
         // [START print_initial_solution]
         Assignment initialSolution = routing.ReadAssignmentFromRoutes(data.InitialRoutes, true);
         // Print initial solution on console.

ortools/constraint_solver/samples/minimal_jobshop_cp.cc

@@ -69,7 +69,7 @@ void SolveJobShopExample() {
     }
   }
 
-  // Add conjunctive contraints.
+  // Add conjunctive constraints.
   for (int i = 0; i < jobs.size(); ++i) {
     for (int j = 0; j < jobs[i].size() - 1; ++j) {
       solver.AddConstraint(solver.MakeIntervalVarRelation(

ortools/dotnet/README.md

@@ -156,7 +156,7 @@ Here some dev-note concerning this `Google.OrTools.csproj`.
   ```xml
   <RestoreSources>{...}/packages;$(RestoreSources)</RestoreSources>
   ```
-* Add dependency (i.e. `PackageReference`) on each runtime package(s) availabe:
+* Add dependency (i.e. `PackageReference`) on each runtime package(s) available:
   ```xml
   <ItemGroup Condition="Exists('{...}/packages/Google.OrTools.runtime.linux-x64.1.0.0.nupkg')">
     <PackageReference Include="Google.OrTools.runtime.linux-x64" Version="1.0.0" />
@@ -202,7 +202,7 @@ provided you have generated the three architecture dependent `Google.OrTools.run
 ![Legend](doc/legend.svg)
 
 ### Building All runtime Google.OrTools Package 
-Like in the previous scenario, on each targeted OS Platform you can build the coresponding
+Like in the previous scenario, on each targeted OS Platform you can build the corresponding
 `Google.OrTools.runtime.{rid}.nupkg` package.
 
 Simply run on each platform

ortools/glop/basis_representation.h

@@ -210,7 +210,7 @@ class BasisFactorization {
                                      RowIndex leaving_variable_row,
                                      const ScatteredColumn& direction);
 
-  // Left solves the system y.B = rhs, where y initialy contains rhs.
+  // Left solves the system y.B = rhs, where y initially contains rhs.
   void LeftSolve(ScatteredRow* y) const;
 
   // Left solves the system y.B = e_j, where e_j has only 1 non-zero

ortools/glop/lu_factorization.h

@@ -113,7 +113,7 @@ class LuFactorization {
   void RightSolveLForScatteredColumn(const ScatteredColumn& b,
                                      ScatteredColumn* x) const;
 
-  // Specialized version of RightSolveLWithNonZeros() where x is originaly equal
+  // Specialized version of RightSolveLWithNonZeros() where x is originally equal
   // to 'a' permuted by row_perm_. Note that 'a' is only used for DCHECK.
   void RightSolveLWithPermutedInput(const DenseColumn& a,
                                     ScatteredColumn* x) const;

ortools/glop/preprocessor.cc

@@ -121,7 +121,7 @@ bool MainLpPreprocessor::Run(LinearProgram* lp) {
     RUN_PREPROCESSOR(SingletonColumnSignPreprocessor);
   }
 
-  // The scaling is controled by use_scaling, not use_preprocessing.
+  // The scaling is controlled by use_scaling, not use_preprocessing.
   RUN_PREPROCESSOR(ScalingPreprocessor);
 
   return !preprocessors_.empty();
@@ -1451,7 +1451,7 @@ bool ImpliedFreePreprocessor::Run(LinearProgram* lp) {
   for (ColWithDegree col_with_degree : col_by_degree) {
     const ColIndex col = col_with_degree.col;
 
-    // If the variable is alreay free or fixed, we do nothing.
+    // If the variable is already free or fixed, we do nothing.
     const Fractional lower_bound = lp->variable_lower_bounds()[col];
     const Fractional upper_bound = lp->variable_upper_bounds()[col];
     if (!IsFinite(lower_bound) && !IsFinite(upper_bound)) {

ortools/glop/preprocessor.h

@@ -961,7 +961,7 @@ class DualizerPreprocessor : public Preprocessor {
 // Example:
 // - A variable with bound [1e10, infinity] will be shifted to [0, infinity].
 // - A variable with domain [-1e10, 1e10] will not be shifted. Note that
-//   compared to the first case, doing so here may introduce unecessary
+//   compared to the first case, doing so here may introduce unnecessary
 //   numerical errors if the variable value in the final solution is close to
 //   zero.
 //

ortools/glop/revised_simplex.h

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Solves a Linear Programing problem using the Revised Simplex algorithm
+// Solves a Linear Programming problem using the Revised Simplex algorithm
 // as described by G.B. Dantzig.
 // The general form is:
 // min c.x where c and x are n-vectors,

ortools/glop/variables_info.h

@@ -74,7 +74,7 @@ class VariablesInfo {
       const DenseColumn& constraint_upper_bounds);
 
   // Initializes the status according to the given BasisState. Incompatible
-  // statuses will be corrected, and we transfrom the state correctly if new
+  // statuses will be corrected, and we transform the state correctly if new
   // columns / rows were added. Note however that one will need to update the
   // BasisState with deletions to preserve the status of unchanged columns.
   void InitializeFromBasisState(ColIndex first_slack, ColIndex num_new_cols,
@@ -131,7 +131,7 @@ class VariablesInfo {
   //   I.e. they cost in the dual infeasibility minimization problem is
   //   multiplied by 1000.
   //
-  // It then update the status to get an inital dual feasible solution, and
+  // It then update the status to get an initial dual feasible solution, and
   // then one just have to apply the phase II algo on this problem to try to
   // find a feasible solution to the original problem.
   //

ortools/graph/christofides.h

@@ -58,7 +58,7 @@ class ChristofidesPathSolver {
   };
   ChristofidesPathSolver(NodeIndex num_nodes, CostFunction costs);
 
-  // Sets the matching algorith to use. A minimum weight perfect matching
+  // Sets the matching algorithm to use. A minimum weight perfect matching
   // (MINIMUM_WEIGHT_MATCHING) guarantees the 3/2 upper bound to the optimal
   // solution. A minimal weight perfect matching (MINIMAL_WEIGHT_MATCHING)
   // finds a locally minimal weight matching which does not offer any bound

ortools/graph/graph.h

@@ -176,7 +176,7 @@ template <typename T>
 class SVector;
 
 // Base class of all Graphs implemented here. The default value for the graph
-// index types is int32_t since allmost all graphs that fit into memory do not
+// index types is int32_t since almost all graphs that fit into memory do not
 // need bigger indices.
 //
 // Note: The type can be unsigned, except for the graphs with reverse arcs
@@ -978,7 +978,7 @@ void BaseGraph<NodeIndexType, ArcIndexType,
   arc_capacity_ = std::max(arc_capacity_, num_arcs_);
 }
 
-// Computes the cummulative sum of the entry in v. We only use it with
+// Computes the cumulative sum of the entry in v. We only use it with
 // in/out degree distribution, hence the Check() at the end.
 template <typename NodeIndexType, typename ArcIndexType, bool HasReverseArcs>
 void BaseGraph<NodeIndexType, ArcIndexType, HasReverseArcs>::

ortools/graph/perfect_matching.cc

@@ -772,7 +772,7 @@ void BlossomGraph::Shrink(EdgeIndex e) {
           continue;
         }
 
-        // This is a new-internal edge that we didn't proccess yet.
+        // This is a new-internal edge that we didn't process yet.
         //
         // TODO(user): It would be nicer to not to have to read the memory of
         // the other node at all. It might be possible once we store the

ortools/graph/perfect_matching.h

@@ -98,7 +98,7 @@ class MinCostPerfectMatching {
   };
   ABSL_MUST_USE_RESULT Status Solve();
 
-  // Returns the cost of the perfect macthing. Only valid when the last solve
+  // Returns the cost of the perfect matching. Only valid when the last solve
   // status was OPTIMAL.
   int64_t OptimalCost() const {
     DCHECK(optimal_solution_found_);

ortools/java/README.md

@@ -93,7 +93,7 @@ So now, let's create the local `com.google.ortools:ortools-java.jar` maven
 package which will depend on our previous native package.
 
 Here some dev-note concerning this `POM.xml`.
-* Add runtime dependency on each native package(s) availabe:
+* Add runtime dependency on each native package(s) available:
   ```xml
   <dependency>
     <groupId>com.google.ortools</groupId>

ortools/lp_data/sparse.cc

@@ -1005,7 +1005,7 @@ void TriangularMatrix::TransposeHyperSparseSolveWithReversedNonZerosInternal(
     const ColIndex row_as_col = RowToColIndex(row);
 
     // We do the loops this way so that the floating point operations are
-    // exactly the same as the ones perfomed by TransposeLowerSolveInternal().
+    // exactly the same as the ones performed by TransposeLowerSolveInternal().
     EntryIndex i = starts_[row_as_col + 1] - 1;
     const EntryIndex i_end = starts_[row_as_col];
     for (; i >= i_end; --i) {

ortools/lp_data/sparse.h

@@ -811,7 +811,7 @@ class TriangularMatrix : private CompactSparseMatrix {
   // can prune it and remove it from the adjacency list of the current node.
   //
   // Note(user): I couldn't find any reference for this algorithm, even though
-  // I suspect I am not the first one to need someting similar.
+  // I suspect I am not the first one to need something similar.
   mutable DenseBooleanColumn marked_;
 
   // This is used to represent a pruned sub-matrix of the current matrix that

ortools/math_opt/cpp/callback.h

@@ -50,7 +50,7 @@
 // possibly {{x, 0.0}} as well.
 //
 // If the callback argument to MathOpt::Solve() is not null, it will be invoked
-// on the events specificed by the callback_registration argument (and when the
+// on the events specified by the callback_registration argument (and when the
 // callback is null, callback_registration must not request any events or will
 // CHECK fail). Some solvers do not support callbacks or certain events, in this
 // case the callback is ignored. TODO(b/180617976): change this behavior.

ortools/math_opt/samples/lagrangian_relaxation.cc

@@ -69,7 +69,7 @@
 // dualized, we can have Z_LP <= Z_D because the resulting Lagrangian subproblem
 // needs to be solved as an MIP. For the particular data used in this example,
 // dualizing only the first resource constraint leads to Z_LP < Z_D, while
-// dualizing only the second resurce constraint leads to Z_LP = Z_D. In either
+// dualizing only the second resource constraint leads to Z_LP = Z_D. In either
 // case, solving the Lagrandual dual also provides an upper bound to Z.
 //
 // Usage: blaze build -c opt

ortools/sat/cp_model_loader.cc

@@ -696,7 +696,7 @@ void DetectOptionalVariables(const CpModelProto& model_proto, Model* m) {
   // of the constraints in which they appear.
   //
   // TODO(user): This deals with the simplest cases, but we could try to
-  // detect literals that implies all the constaints in which a variable
+  // detect literals that implies all the constraints in which a variable
   // appear to false. This can be done with a LCA computation in the tree of
   // Boolean implication (once the presolve remove cycles). Not sure if we can
   // properly exploit that afterwards though. Do some research!

ortools/sat/drat_proof_handler.h

@@ -97,7 +97,7 @@ class DratProofHandler {
   // We need to keep track of the variable newly created.
   int variable_index_;
 
-  // Temporary vector used for sorting the outputed clauses.
+  // Temporary vector used for sorting the outputted clauses.
   std::vector<Literal> values_;
 
   // This mapping will be applied to all clause passed to AddClause() or

ortools/sat/integer.cc

@@ -1864,7 +1864,7 @@ bool GenericLiteralWatcher::Propagate(Trail* trail) {
     //
     // TODO(user): The queue will not be emptied, but I am not sure the solver
     // will be left in an usable state. Fix if it become needed to resume
-    // the solve from the last time it was interupted.
+    // the solve from the last time it was interrupted.
     if (test_limit > 100) {
       test_limit = 0;
       if (time_limit_->LimitReached()) break;

ortools/sat/linear_programming_constraint.h

@@ -319,7 +319,7 @@ class LinearProgrammingConstraint : public PropagatorInterface,
   // Shortcut for an integer linear expression type.
   using LinearExpression = std::vector<std::pair<glop::ColIndex, IntegerValue>>;
 
-  // Converts a dense represenation of a linear constraint to a sparse one
+  // Converts a dense representation of a linear constraint to a sparse one
   // expressed in terms of IntegerVariable.
   void ConvertToLinearConstraint(
       const absl::StrongVector<glop::ColIndex, IntegerValue>& dense_vector,

ortools/sat/lp_utils.cc

@@ -479,7 +479,7 @@ std::vector<double> DetectImpliedIntegers(MPModelProto* mp_model,
 
 namespace {
 
-// We use a class to reuse the temporay memory.
+// We use a class to reuse the temporary memory.
 struct ConstraintScaler {
   // Scales an individual constraint.
   ConstraintProto* AddConstraint(const MPModelProto& mp_model,

ortools/sat/precedences.cc

@@ -282,7 +282,7 @@ void PrecedencesPropagator::AddArc(
   if (head == tail) {
     // A self-arc is either plain SAT or plain UNSAT or it forces something on
     // the given offset_var or presence_literal_index. In any case it could be
-    // presolved in something more efficent.
+    // presolved in something more efficient.
     VLOG(1) << "Self arc! This could be presolved. "
             << "var:" << tail << " offset:" << offset
             << " offset_var:" << offset_var
@@ -338,7 +338,7 @@ void PrecedencesPropagator::AddArc(
     // Since we add a new arc, we will need to consider its tail during the next
     // propagation. Note that the size of modified_vars_ will be automatically
     // updated when new integer variables are created since we register it with
-    // IntegerTrail in this class contructor.
+    // IntegerTrail in this class constructor.
     //
     // TODO(user): Adding arcs and then calling Untrail() before Propagate()
     // will cause this mecanism to break. Find a more robust implementation.
@@ -622,7 +622,7 @@ void PrecedencesPropagator::AnalyzePositiveCycle(
 // minimize the number of integer_trail_->Enqueue() as much as possible.
 //
 // TODO(user): The current algorithm is quite efficient, but there is probably
-// still room for improvments.
+// still room for improvements.
 bool PrecedencesPropagator::BellmanFordTarjan(Trail* trail) {
   const int num_nodes = impacted_arcs_.size();
 

ortools/sat/presolve_util.cc

@@ -187,7 +187,7 @@ void SubstituteVariable(int var, int64_t var_coeff_in_definition,
   CHECK(RefIsPositive(var));
   CHECK_EQ(std::abs(var_coeff_in_definition), 1);
 
-  // Copy all the terms (except the one refering to var).
+  // Copy all the terms (except the one referring to var).
   std::vector<std::pair<int, int64_t>> terms;
   int64_t var_coeff = GetVarCoeffAndCopyOtherTerms(var, ct->linear(), &terms);
 

ortools/sat/sat_parameters.proto

@@ -1014,7 +1014,7 @@ message SatParameters {
   // specify continuous variable domain with the wanted precision.
   optional double mip_var_scaling = 125 [default = 1.0];
 
-  // If true, some continuous variable might be automatially scaled. For now,
+  // If true, some continuous variable might be automatically scaled. For now,
   // this is only the case where we detect that a variable is actually an
   // integer multiple of a constant. For instance, variables of the form k * 0.5
   // are quite frequent, and if we detect this, we will scale such variable

ortools/sat/sat_solver.cc

@@ -1382,7 +1382,7 @@ void SatSolver::BumpClauseActivity(SatClause* clause) {
       // This one is similar to the one used by the Glucose SAT solver.
       //
       // TODO(user): why the +1? one reason may be that the LBD of a conflict
-      // decrease by 1 just afer the backjump...
+      // decrease by 1 just after the backjump...
       if (new_lbd + 1 < it->second.lbd) {
         it->second.protected_during_next_cleanup = true;
         it->second.lbd = new_lbd;

ortools/sat/simplification.cc

@@ -381,7 +381,7 @@ void SatPresolver::PresolveWithBva() {
   }
 }
 
-// We use the same notation as in the article mentionned in the .h
+// We use the same notation as in the article mentioned in the .h
 void SatPresolver::SimpleBva(LiteralIndex l) {
   literal_to_p_size_.resize(literal_to_clauses_.size(), 0);
   DCHECK(std::all_of(literal_to_p_size_.begin(), literal_to_p_size_.end(),

ortools/sat/timetable.cc

@@ -378,7 +378,7 @@ bool TimeTablingPerTask::BuildProfile() {
   // Add a sentinel to simplify the algorithm.
   profile_.emplace_back(kMinIntegerValue, IntegerValue(0));
 
-  // Start and height of the currently built profile rectange.
+  // Start and height of the currently built profile rectangle.
   IntegerValue current_start = kMinIntegerValue;
   IntegerValue current_height = starting_profile_height_;
 

ortools/util/affine_relation.h

@@ -157,7 +157,7 @@ class AffineRelation {
   //
   // TODO(user): Using a "rank" might be faster, but because we sometimes
   // need to merge the bad subtree into the better one, it is trickier to
-  // maintain than in the classic union-find algorihtm.
+  // maintain than in the classic union-find algorithm.
   std::vector<int> size_;
 
   // Used by CompressPath() to maintain the coeff/offset during compression.

ortools/util/bitset.h

@@ -736,7 +736,7 @@ class BitQueue64 {
 
     // Note(user): I experimented with reversing the bit order in a bucket to
     // use LeastSignificantBitPosition64() and it is only slightly faster at the
-    // cost of a lower Set() speed. So I prefered this version.
+    // cost of a lower Set() speed. So I preferred this version.
     top_ = static_cast<int>(BitShift64(bucket_index) +
                             MostSignificantBitPosition64(bucket));
   }