Moved formSimplexLpBasisAndFactor, accommodateAlienBasis and considerScaling from lp_data/HighsSolution to simplex/HSimplex

Author: jajhall

highs/lp_data/HighsLpSolverObject.h

@@ -5,7 +5,7 @@
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-/**@file simplex/HighsLpSolverObject.h
+/**@file lp_data/HighsLpSolverObject.h
  * @brief Collection of class instances required to solve an LP
  */
 #ifndef LP_DATA_HIGHS_LP_SOLVER_OBJECT_H_

highs/lp_data/HighsLpUtils.cpp

@@ -92,22 +92,6 @@ void relaxSemiVariables(HighsLp& lp, bool& made_semi_variable_mods);
 bool activeModifiedUpperBounds(const HighsOptions& options, const HighsLp& lp,
                                const std::vector<double> col_value);
 
-bool considerScaling(const HighsOptions& options, HighsLp& lp);
-void scaleLp(const HighsOptions& options, HighsLp& lp,
-             const bool force_scaling = false);
-bool equilibrationScaleMatrix(const HighsOptions& options, HighsLp& lp,
-                              const HighsInt use_scale_strategy);
-bool maxValueScaleMatrix(const HighsOptions& options, HighsLp& lp,
-                         const HighsInt use_scale_strategy);
-
-HighsStatus applyScalingToLpCol(HighsLp& lp, const HighsInt col,
-                                const double colScale);
-
-HighsStatus applyScalingToLpRow(HighsLp& lp, const HighsInt row,
-                                const double rowScale);
-
-void unscaleSolution(HighsSolution& solution, const HighsScale& scale);
-
 void appendColsToLpVectors(HighsLp& lp, const HighsInt num_new_col,
                            const vector<double>& colCost,
                            const vector<double>& colLower,

highs/lp_data/HighsLpUtils.h

@@ -1503,139 +1503,6 @@ HighsStatus ipxBasicSolutionToHighsBasicSolution(
   return HighsStatus::kOk;
 }
 
-HighsStatus formSimplexLpBasisAndFactorReturn(
-    const HighsStatus return_status, HighsLpSolverObject& solver_object) {
-  HighsLp& lp = solver_object.lp_;
-  HighsLp& ekk_lp = solver_object.ekk_instance_.lp_;
-  if (lp.is_moved_) lp.moveBackLpAndUnapplyScaling(ekk_lp);
-  return return_status;
-}
-
-HighsStatus formSimplexLpBasisAndFactor(HighsLpSolverObject& solver_object,
-                                        const bool only_from_known_basis) {
-  // Ideally, forms a SimplexBasis from the HighsBasis in the
-  // HighsLpSolverObject
-  //
-  // If only_from_known_basis is true and
-  // initialiseSimplexLpBasisAndFactor finds that there is no simplex
-  // basis, then its error return is passed down
-  //
-  // If only_from_known_basis is false, then the basis is completed
-  // with logicals if it is rank deficient (from singularity or being
-  // incomplete)
-  //
-  HighsStatus return_status = HighsStatus::kOk;
-  HighsStatus call_status;
-  HighsLp& lp = solver_object.lp_;
-  HighsBasis& basis = solver_object.basis_;
-  HighsOptions& options = solver_object.options_;
-  HEkk& ekk_instance = solver_object.ekk_instance_;
-  HighsSimplexStatus& ekk_status = ekk_instance.status_;
-  lp.ensureColwise();
-  const bool passed_scaled = lp.is_scaled_;
-  // Consider scaling the LP
-  if (!passed_scaled) considerScaling(options, lp);
-  const bool check_basis = basis.alien || (!basis.valid && basis.useful);
-  if (check_basis) {
-    // The basis needs to be checked for rank deficiency, and possibly
-    // completed if it is rectangular
-    //
-    // If it's not valid but useful, but not alien,
-    // accommodateAlienBasis will assert, so make the basis alien
-    basis.alien = true;
-    assert(!only_from_known_basis);
-    accommodateAlienBasis(solver_object);
-    basis.alien = false;
-    // Unapply any scaling used only for factorization to check and
-    // complete the basis
-    if (!passed_scaled) lp.unapplyScale();
-    // Check that any scaling the LP arrived with has not been removed
-    assert(lp.is_scaled_ == passed_scaled);
-    return HighsStatus::kOk;
-  }
-  // Move the HighsLpSolverObject's LP to EKK
-  ekk_instance.moveLp(solver_object);
-  if (!ekk_status.has_basis) {
-    // The Ekk instance has no simplex basis, so pass the HiGHS basis
-    HighsStatus call_status = ekk_instance.setBasis(basis);
-    return_status = interpretCallStatus(options.log_options, call_status,
-                                        return_status, "setBasis");
-    if (return_status == HighsStatus::kError)
-      return formSimplexLpBasisAndFactorReturn(return_status, solver_object);
-  }
-  // Now form the invert
-  assert(ekk_status.has_basis);
-  call_status =
-      ekk_instance.initialiseSimplexLpBasisAndFactor(only_from_known_basis);
-  // If the current basis cannot be inverted, return an error
-  if (call_status != HighsStatus::kOk)
-    return formSimplexLpBasisAndFactorReturn(HighsStatus::kError,
-                                             solver_object);
-  // Once the invert is formed, move back the LP and remove any scaling.
-  return formSimplexLpBasisAndFactorReturn(HighsStatus::kOk, solver_object);
-}
-
-void accommodateAlienBasis(HighsLpSolverObject& solver_object) {
-  HighsLp& lp = solver_object.lp_;
-  HighsBasis& basis = solver_object.basis_;
-  HighsOptions& options = solver_object.options_;
-  assert(basis.alien);
-  HighsInt num_row = lp.num_row_;
-  HighsInt num_col = lp.num_col_;
-  assert((int)basis.col_status.size() >= num_col);
-  assert((int)basis.row_status.size() >= num_row);
-  std::vector<HighsInt> basic_index;
-  for (HighsInt iCol = 0; iCol < num_col; iCol++) {
-    if (basis.col_status[iCol] == HighsBasisStatus::kBasic)
-      basic_index.push_back(iCol);
-  }
-  for (HighsInt iRow = 0; iRow < num_row; iRow++) {
-    if (basis.row_status[iRow] == HighsBasisStatus::kBasic)
-      basic_index.push_back(num_col + iRow);
-  }
-  HighsInt num_basic_variables = basic_index.size();
-  HFactor factor;
-  factor.setupGeneral(&lp.a_matrix_, num_basic_variables, basic_index.data(),
-                      kDefaultPivotThreshold, kDefaultPivotTolerance,
-                      kHighsDebugLevelMin, &options.log_options);
-  HighsInt rank_deficiency = factor.build();
-  // Must not have timed out
-  assert(rank_deficiency >= 0);
-  // Deduce the basis from basic_index
-  //
-  // Set all basic variables to nonbasic
-  for (HighsInt iCol = 0; iCol < num_col; iCol++) {
-    if (basis.col_status[iCol] == HighsBasisStatus::kBasic)
-      basis.col_status[iCol] = HighsBasisStatus::kNonbasic;
-  }
-  for (HighsInt iRow = 0; iRow < num_row; iRow++) {
-    if (basis.row_status[iRow] == HighsBasisStatus::kBasic)
-      basis.row_status[iRow] = HighsBasisStatus::kNonbasic;
-  }
-  // Set at most the first num_row variables in basic_index to basic
-  const HighsInt use_basic_variables = std::min(num_row, num_basic_variables);
-  // num_basic_variables is no longer needed, so can be used as a check
-  num_basic_variables = 0;
-  for (HighsInt iRow = 0; iRow < use_basic_variables; iRow++) {
-    HighsInt iVar = basic_index[iRow];
-    if (iVar < num_col) {
-      basis.col_status[iVar] = HighsBasisStatus::kBasic;
-    } else {
-      basis.row_status[iVar - num_col] = HighsBasisStatus::kBasic;
-    }
-    num_basic_variables++;
-  }
-  // Complete the assignment of basic variables using the logicals of
-  // non-pivotal rows
-  const HighsInt num_missing = num_row - num_basic_variables;
-  for (HighsInt k = 0; k < num_missing; k++) {
-    HighsInt iRow = factor.row_with_no_pivot[rank_deficiency + k];
-    basis.row_status[iRow] = HighsBasisStatus::kBasic;
-    num_basic_variables++;
-  }
-  assert(num_basic_variables == num_row);
-}
-
 void resetModelStatusAndHighsInfo(HighsLpSolverObject& solver_object) {
   resetModelStatusAndHighsInfo(solver_object.model_status_,
                                solver_object.highs_info_);

highs/lp_data/HighsSolution.cpp

@@ -135,14 +135,6 @@ HighsStatus ipxBasicSolutionToHighsBasicSolution(
     const IpxSolution& ipx_solution, HighsBasis& highs_basis,
     HighsSolution& highs_solution);
 
-HighsStatus formSimplexLpBasisAndFactorReturn(
-    const HighsStatus return_status, HighsLpSolverObject& solver_object);
-HighsStatus formSimplexLpBasisAndFactor(
-    HighsLpSolverObject& solver_object,
-    const bool only_from_known_basis = false);
-
-void accommodateAlienBasis(HighsLpSolverObject& solver_object);
-
 void resetModelStatusAndHighsInfo(HighsLpSolverObject& solver_object);
 void resetModelStatusAndHighsInfo(HighsModelStatus& model_status,
                                   HighsInfo& highs_info);