casadi 3.6.7__cp312-none-manylinux2014_x86_64.whl → 3.7.1__cp312-none-manylinux2014_x86_64.whl

casadi/include/highs/presolve/HPresolve.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -29,6 +26,7 @@
 #include "presolve/HPresolveAnalysis.h"
 #include "util/HighsCDouble.h"
 #include "util/HighsHash.h"
+#include "util/HighsHashTree.h"
 #include "util/HighsLinearSumBounds.h"
 #include "util/HighsMatrixSlice.h"
 
@@ -43,7 +41,6 @@ class HPresolve {
   HighsTimer* timer;
   HighsMipSolver* mipsolver = nullptr;
   double primal_feastol;
-  HighsInt run_clock = -1;
 
   // triplet storage
   std::vector<double> Avalue;
@@ -99,6 +96,10 @@ class HPresolve {
 
   std::vector<std::pair<HighsInt, HighsInt>> substitutionOpportunities;
 
+  std::unordered_map<HighsInt,
+                     HighsHashTree<std::pair<HighsInt, HighsInt>, double>>
+      liftingOpportunities;
+
   // set with the sizes and indices of equation rows sorted by the size and a
   // vector to access there iterator positions in the set by index for quick
   // removal
@@ -158,11 +159,15 @@ class HPresolve {
 
   void updateColImpliedBounds(HighsInt row, HighsInt col, double val);
 
-  void recomputeColImpliedBounds(HighsInt row);
+  void updateRowDualImpliedBounds(HighsInt row, HighsInt col, double val);
 
-  void recomputeRowDualImpliedBounds(HighsInt col);
+  void resetColImpliedBounds(HighsInt col, HighsInt row = -1);
 
-  void updateRowDualImpliedBounds(HighsInt row, HighsInt col, double val);
+  void resetRowDualImpliedBounds(HighsInt row, HighsInt col = -1);
+
+  void resetColImpliedBoundsDerivedFromRow(HighsInt row);
+
+  void resetRowDualImpliedBoundsDerivedFromCol(HighsInt col);
 
   bool rowCoefficientsIntegral(HighsInt row, double scale) const;
 
@@ -174,10 +179,17 @@ class HPresolve {
                                        HighsPostsolveStack::RowType& rowType,
                                        bool relaxRowDualBounds = false);
 
+  bool isImpliedEquationAtLower(HighsInt row) const;
+
+  bool isImpliedEquationAtUpper(HighsInt row) const;
+
   bool isImpliedIntegral(HighsInt col);
 
   bool isImpliedInteger(HighsInt col);
 
+  bool convertImpliedInteger(HighsInt col, HighsInt row = -1,
+                             bool skipInputChecks = false);
+
   bool isLowerImplied(HighsInt col) const;
 
   bool isUpperImplied(HighsInt col) const;
@@ -189,6 +201,11 @@ class HPresolve {
 
   void reinsertEquation(HighsInt row);
 
+  void clearLiftingOpportunities(HighsInt row) {
+    auto search = liftingOpportunities.find(row);
+    if (search != liftingOpportunities.end()) search->second.clear();
+  };
+
 #ifndef NDEBUG
   void debugPrintRow(HighsPostsolveStack& postsolve_stack, HighsInt row);
 #endif
@@ -209,6 +226,9 @@ class HPresolve {
   void toCSR(std::vector<double>& ARval, std::vector<HighsInt>& ARindex,
              std::vector<HighsInt>& ARstart);
 
+  void getRowPositions(HighsInt row,
+                       std::vector<HighsInt>& myrowpositions) const;
+
   void storeRow(HighsInt row);
 
   HighsTripletPositionSlice getStoredRow() const;
@@ -223,9 +243,11 @@ class HPresolve {
 
   void markColDeleted(HighsInt col);
 
-  void fixColToLower(HighsPostsolveStack& postsolve_stack, HighsInt col);
+  bool fixColToLowerOrUnbounded(HighsPostsolveStack& postsolve_stack,
+                                HighsInt col);
 
-  void fixColToUpper(HighsPostsolveStack& postsolve_stack, HighsInt col);
+  bool fixColToUpperOrUnbounded(HighsPostsolveStack& postsolve_stack,
+                                HighsInt col);
 
   void fixColToZero(HighsPostsolveStack& postsolve_stack, HighsInt col);
 
@@ -264,6 +286,10 @@ class HPresolve {
 
   Result presolve(HighsPostsolveStack& postsolve_stack);
 
+  Result removeSlacks(HighsPostsolveStack& postsolve_stack);
+
+  Result checkTimeLimit();
+
   Result checkLimits(HighsPostsolveStack& postsolve_stack);
 
   void storeCurrentProblemSize();
@@ -292,6 +318,8 @@ class HPresolve {
 
   Result runProbing(HighsPostsolveStack& postsolve_stack);
 
+  Result liftingForProbing(HighsPostsolveStack& postsolve_stack);
+
   Result dominatedColumns(HighsPostsolveStack& postsolve_stack);
 
   Result doubletonEq(HighsPostsolveStack& postsolve_stack, HighsInt row,
@@ -303,10 +331,16 @@ class HPresolve {
 
   Result singletonCol(HighsPostsolveStack& postsolve_stack, HighsInt col);
 
+  void substituteFreeCol(HighsPostsolveStack& postsolve_stack, HighsInt row,
+                         HighsInt col, bool relaxRowDualBounds = false);
+
   Result rowPresolve(HighsPostsolveStack& postsolve_stack, HighsInt row);
 
   Result colPresolve(HighsPostsolveStack& postsolve_stack, HighsInt col);
 
+  Result detectDominatedCol(HighsPostsolveStack& postsolve_stack, HighsInt col,
+                            bool handleSingletonRows = true);
+
   Result initialRowAndColPresolve(HighsPostsolveStack& postsolve_stack);
 
   HighsModelStatus run(HighsPostsolveStack& postsolve_stack);
@@ -338,12 +372,18 @@ class HPresolve {
 
   Result removeDoubletonEquations(HighsPostsolveStack& postsolve_stack);
 
-  HighsInt strengthenInequalities();
+  Result strengthenInequalities(HighsPostsolveStack& postsolve_stack,
+                                HighsInt& num_strenghtened);
 
   HighsInt detectImpliedIntegers();
 
   Result detectParallelRowsAndCols(HighsPostsolveStack& postsolve_stack);
 
+  template <typename RowStorageFormat>
+  Result equalityRowAddition(HighsPostsolveStack& postsolve_stack,
+                             HighsInt stayrow, HighsInt removerow, double scale,
+                             const HighsMatrixSlice<RowStorageFormat>& vector);
+
   Result sparsify(HighsPostsolveStack& postsolve_stack);
 
   void setRelaxedImpliedBounds();

casadi/include/highs/presolve/HPresolveAnalysis.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/presolve/HighsPostsolveStack.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -219,6 +216,16 @@ class HighsPostsolveStack {
     void transformToPresolvedSpace(std::vector<double>& primalSol) const;
   };
 
+  struct SlackColSubstitution {
+    double rhs;
+    HighsInt row;
+    HighsInt col;
+
+    void undo(const HighsOptions& options,
+              const std::vector<Nonzero>& rowValues, HighsSolution& solution,
+              HighsBasis& basis);
+  };
+
   /// tags for reduction
   enum class ReductionType : uint8_t {
     kLinearTransform,
@@ -234,6 +241,7 @@ class HighsPostsolveStack {
     kForcingColumnRemovedRow,
     kDuplicateRow,
     kDuplicateColumn,
+    kSlackColSubstitution,
   };
 
   HighsDataStack reductionValues;
@@ -323,6 +331,19 @@ class HighsPostsolveStack {
     reductionAdded(ReductionType::kFreeColSubstitution);
   }
 
+  template <typename RowStorageFormat>
+  void slackColSubstitution(HighsInt row, HighsInt col, double rhs,
+                            const HighsMatrixSlice<RowStorageFormat>& rowVec) {
+    rowValues.clear();
+    for (const HighsSliceNonzero& rowVal : rowVec)
+      rowValues.emplace_back(origColIndex[rowVal.index()], rowVal.value());
+
+    reductionValues.push(
+        SlackColSubstitution{rhs, origRowIndex[row], origColIndex[col]});
+    reductionValues.push(rowValues);
+    reductionAdded(ReductionType::kSlackColSubstitution);
+  }
+
   template <typename ColStorageFormat>
   void doubletonEquation(HighsInt row, HighsInt colSubst, HighsInt col,
                          double coefSubst, double coef, double rhs,
@@ -710,6 +731,13 @@ class HighsPostsolveStack {
           reduction.undo(options, solution, basis);
           break;
         }
+        case ReductionType::kSlackColSubstitution: {
+          SlackColSubstitution reduction;
+          reductionValues.pop(rowValues);
+          reductionValues.pop(reduction);
+          reduction.undo(options, rowValues, solution, basis);
+          break;
+        }
         default:
           printf("Reduction case %d not handled\n",
                  int(reductions[i - 1].first));
@@ -756,9 +784,7 @@ class HighsPostsolveStack {
   */
 
   // Only used for debugging
-  void undoUntil(const HighsOptions& options,
-                 const std::vector<HighsInt>& flagRow,
-                 const std::vector<HighsInt>& flagCol, HighsSolution& solution,
+  void undoUntil(const HighsOptions& options, HighsSolution& solution,
                  HighsBasis& basis, size_t numReductions) {
     reductionValues.resetPosition();
 
@@ -887,6 +913,13 @@ class HighsPostsolveStack {
           reductionValues.pop(reduction);
           reduction.undo(options, solution, basis);
         }
+        case ReductionType::kSlackColSubstitution: {
+          SlackColSubstitution reduction;
+          reductionValues.pop(rowValues);
+          reductionValues.pop(reduction);
+          reduction.undo(options, rowValues, solution, basis);
+          break;
+        }
       }
     }
 #ifdef DEBUG_EXTRA

casadi/include/highs/presolve/HighsSymmetry.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/presolve/ICrash.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/presolve/ICrashUtil.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -62,4 +59,4 @@ void updateResidualFast(const HighsLp& lp, const HighsSolution& sol,
 // Allows negative residuals
 void updateResidualIca(const HighsLp& lp, const HighsSolution& sol,
                        std::vector<double>& residual);
-#endif
+#endif

casadi/include/highs/presolve/ICrashX.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/presolve/PresolveComponent.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/qpsolver/a_asm.hpp

@@ -2,9 +2,9 @@
 #define __SRC_LIB_QPSOLVER_ASM_HPP__
 
 #include "qpsolver/instance.hpp"
-#include "qpsolver/statistics.hpp"
 #include "qpsolver/qpconst.hpp"
 #include "qpsolver/settings.hpp"
+#include "qpsolver/statistics.hpp"
 #include "util/HighsTimer.h"
 
 enum class QpAsmStatus {
@@ -24,7 +24,8 @@ struct QpSolution {
   std::vector<BasisStatus> status_var;
   std::vector<BasisStatus> status_con;
 
-  QpSolution(Instance& instance) : primal(QpVector(instance.num_var)),
+  QpSolution(Instance& instance)
+      : primal(QpVector(instance.num_var)),
         rowactivity(QpVector(instance.num_con)),
         dualvar(instance.num_var),
         dualcon(instance.num_con),
@@ -32,7 +33,6 @@ struct QpSolution {
         status_con(instance.num_con) {}
 };
 
-
 struct QpHotstartInformation {
   std::vector<HighsInt> active;
   std::vector<HighsInt> inactive;
@@ -44,24 +44,27 @@ struct QpHotstartInformation {
       : primal(QpVector(num_var)), rowact(QpVector(num_row)) {}
 };
 
-// the purpose of this is the pure algorithmic solution of a QP instance with given hotstart information.
-// scenarios: 
-// 1) start from a given phase1 solution
+// the purpose of this is the pure algorithmic solution of a QP instance with
+// given hotstart information. scenarios: 1) start from a given phase1 solution
 // 2) start from a user-given hotstart solution
-// 3) start from a qp solution that was attained from a scaled instance and cleanup
-// 4) start from a qp solution that was attained from a perturbed instance and cleanup
-// 5) start from a qp solution and cleanup after recomputing basis and reduced hessian factorization
+// 3) start from a qp solution that was attained from a scaled instance and
+// cleanup 4) start from a qp solution that was attained from a perturbed
+// instance and cleanup 5) start from a qp solution and cleanup after
+// recomputing basis and reduced hessian factorization
 
 std::string qpBasisStatusToString(const BasisStatus qp_basis_status);
 std::string qpModelStatusToString(const QpModelStatus qp_model_status);
-void assessQpPrimalFeasibility(const Instance& instance, const double primal_feasibility_tolerance,
-			       const std::vector<double>& var_value, const std::vector<double>& con_value,
-			       HighsInt& num_var_infeasibilities, double& max_var_infeasibility, double& sum_var_infeasibilities,
-			       HighsInt& num_con_infeasibilities, double& max_con_infeasibility, double& sum_con_infeasibilities,
-			       double& max_con_residual, double& sum_con_residuals);
-
-QpAsmStatus solveqp_actual(Instance& instance, Settings& settings, QpHotstartInformation& startinfo, Statistics& stats, QpModelStatus& status, QpSolution& solution, HighsTimer& qp_timer);
-
+void assessQpPrimalFeasibility(
+    const Instance& instance, const double primal_feasibility_tolerance,
+    const std::vector<double>& var_value, const std::vector<double>& con_value,
+    HighsInt& num_var_infeasibilities, double& max_var_infeasibility,
+    double& sum_var_infeasibilities, HighsInt& num_con_infeasibilities,
+    double& max_con_infeasibility, double& sum_con_infeasibilities,
+    double& max_con_residual, double& sum_con_residuals);
 
+QpAsmStatus solveqp_actual(Instance& instance, Settings& settings,
+                           QpHotstartInformation& startinfo, Statistics& stats,
+                           QpModelStatus& status, QpSolution& solution,
+                           HighsTimer& qp_timer);
 
 #endif

casadi/include/highs/qpsolver/a_quass.hpp

@@ -2,18 +2,14 @@
 #define __SRC_LIB_QPSOLVER_QUASS_HPP__
 
 #include "Highs.h"
+#include "qpsolver/a_asm.hpp"
 #include "qpsolver/instance.hpp"
 #include "qpsolver/qpconst.hpp"
-#include "qpsolver/a_asm.hpp"
 #include "qpsolver/settings.hpp"
 
-
-QpAsmStatus solveqp(Instance& instance,
-		    Settings& settings,
-		    Statistics& stats,
-		    HighsModelStatus& highs_model_status,
-		    HighsBasis& highs_basis,
-		    HighsSolution& highs_solution, 
-		    HighsTimer& timer);
+QpAsmStatus solveqp(Instance& instance, Settings& settings, Statistics& stats,
+                    HighsModelStatus& highs_model_status,
+                    HighsBasis& highs_basis, HighsSolution& highs_solution,
+                    HighsTimer& timer);
 
 #endif

casadi/include/highs/qpsolver/basis.hpp

@@ -85,9 +85,8 @@ class Basis {
   HVector col_aq;
 
   bool reinversion_hint = false;
- public:
-
 
+ public:
   Basis(Runtime& rt, std::vector<HighsInt> active,
         std::vector<BasisStatus> atlower, std::vector<HighsInt> inactive);
 
@@ -99,7 +98,9 @@ class Basis {
 
   HighsInt getnumactive() const { return active_constraint_index.size(); };
 
-  HighsInt getnuminactive() const { return non_active_constraint_index.size(); };
+  HighsInt getnuminactive() const {
+    return non_active_constraint_index.size();
+  };
 
   const std::vector<HighsInt>& getactive() const {
     return active_constraint_index;
@@ -121,28 +122,29 @@ class Basis {
   // Nullspace from now on)
   void deactivate(HighsInt conid);
 
-  QpSolverStatus activate(const Settings& settings, HighsInt conid, BasisStatus atlower,
-                          HighsInt nonactivetoremove, Pricing* pricing);
+  QpSolverStatus activate(const Settings& settings, HighsInt conid,
+                          BasisStatus atlower, HighsInt nonactivetoremove,
+                          Pricing* pricing);
 
-  void updatebasis(const Settings& settings, HighsInt newactivecon, HighsInt droppedcon,
-                   Pricing* pricing);
+  void updatebasis(const Settings& settings, HighsInt newactivecon,
+                   HighsInt droppedcon, Pricing* pricing);
 
   QpVector btran(const QpVector& rhs, bool buffer = false, HighsInt p = -1);
 
   QpVector ftran(const QpVector& rhs, bool buffer = false, HighsInt q = -1);
 
   QpVector& btran(const QpVector& rhs, QpVector& target, bool buffer = false,
-                HighsInt p = -1);
+                  HighsInt p = -1);
 
   QpVector& ftran(const QpVector& rhs, QpVector& target, bool buffer = false,
-                HighsInt q = -1);
+                  HighsInt q = -1);
 
   QpVector recomputex(const Instance& inst);
 
   void write(std::string filename);
 
   QpVector& Ztprod(const QpVector& rhs, QpVector& target, bool buffer = false,
-                 HighsInt q = -1);
+                   HighsInt q = -1);
 
   QpVector& Zprod(const QpVector& rhs, QpVector& target);
 };

casadi/include/highs/qpsolver/crashsolution.hpp

@@ -2,11 +2,12 @@
 #define __SRC_LIB_CRASHSOLUTION_HPP__
 
 #include <cstdlib>
+
 #include "runtime.hpp"
 
-inline
-bool isfreevar(Instance& instance, HighsInt idx) {
-  return instance.var_lo[idx] == -std::numeric_limits<double>::infinity() && instance.var_up[idx] == std::numeric_limits<double>::infinity();
+inline bool isfreevar(Instance& instance, HighsInt idx) {
+  return instance.var_lo[idx] == -std::numeric_limits<double>::infinity() &&
+         instance.var_up[idx] == std::numeric_limits<double>::infinity();
 }
 
 #endif

casadi/include/highs/qpsolver/dantzigpricing.hpp

@@ -52,8 +52,9 @@ class DantzigPricing : public Pricing {
 
  public:
   DantzigPricing(Runtime& rt, Basis& bas, ReducedCosts& rc)
-      : runtime(rt), basis(bas), redcosts(rc){};
-
+      // clang-format off
+      : runtime(rt), basis(bas), redcosts(rc) {};
+  // clang-format on
   HighsInt price(const QpVector& x, const QpVector& gradient) {
     HighsInt minidx = chooseconstrainttodrop(redcosts.getReducedCosts());
     return minidx;

casadi/include/highs/qpsolver/devexpricing.hpp

@@ -58,7 +58,9 @@ class DevexPricing : public Pricing {
       : runtime(rt),
         basis(bas),
         redcosts(rc),
-        weights(std::vector<double>(rt.instance.num_var, 1.0)){};
+        // clang-format off
+        weights(std::vector<double>(rt.instance.num_var, 1.0)) {};
+  // clang-format on
 
   // B lambda = g
   // lambda = inv(B)g

casadi/include/highs/qpsolver/factor.hpp

@@ -36,7 +36,7 @@ class CholeskyFactor {
     HighsInt min_k_max = min(new_k_max, current_k_max);
     for (HighsInt i = 0; i < min_k_max; i++) {
       for (HighsInt j = 0; j < min_k_max; j++) {
-	assert(i * (new_k_max) + j < l_size);
+        assert(i * (new_k_max) + j < l_size);
         L[i * (new_k_max) + j] = L_old[i * current_k_max + j];
       }
     }
@@ -52,7 +52,6 @@ class CholeskyFactor {
     L.resize(current_k_max * current_k_max);
   }
 
-
   void recompute() {
     std::vector<std::vector<double>> orig;
     HighsInt dim_ns = basis.getinactive().size();
@@ -97,7 +96,8 @@ class CholeskyFactor {
     uptodate = true;
   }
 
-  QpSolverStatus expand(const QpVector& yp, QpVector& gyp, QpVector& l, QpVector& m) {
+  QpSolverStatus expand(const QpVector& yp, QpVector& gyp, QpVector& l,
+                        QpVector& m) {
     if (!uptodate) {
       return QpSolverStatus::OK;
     }
@@ -124,14 +124,15 @@ class CholeskyFactor {
       // b*b -a*a = mu
       // k(b-a) = 1
       // b + a = k*mu
-  // Commented out unreachable code
+      // Commented out unreachable code
       //      const double tolerance = 0.001;
       //
       //      double beta = max(tolerance, sqrt(m.norm2() / L[0] + fabs(mu)));
       //      double k = 1 / (beta + sqrt(beta * beta - mu));
       //      double alpha = k * mu - beta;
       //
-      //      printf("k = %d, alpha = %lf, beta = %lf, k = %lf\n", (int)current_k, alpha,
+      //      printf("k = %d, alpha = %lf, beta = %lf, k = %lf\n",
+      //      (int)current_k, alpha,
       //             beta, k);
       //
       //      a.clear();