casadi 3.6.4__cp311-none-manylinux2014_i686.whl → 3.6.6__cp311-none-manylinux2014_i686.whl

casadi/include/coin-or/IpSolveStatistics.hpp

@@ -0,0 +1,210 @@
+// Copyright (C) 2005, 2009 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Carl Laird, Andreas Waechter          IBM    2005-08-15
+
+#ifndef __IPSOLVESTATISTICS_HPP__
+#define __IPSOLVESTATISTICS_HPP__
+
+#include "IpReferenced.hpp"
+#include "IpSmartPtr.hpp"
+#include "IpUtils.hpp"
+
+namespace Ipopt
+{
+
+// forward declaration (to avoid inclusion of too many header files)
+class IpoptNLP;
+class IpoptData;
+class IpoptCalculatedQuantities;
+
+/** This class collects statistics about an optimization run, such
+ *  as iteration count, final infeasibilities etc.  It is meant to
+ *  provide such information to a user of Ipopt during the
+ *  finalize_solution call.
+ */
+class IPOPTLIB_EXPORT SolveStatistics : public ReferencedObject
+{
+public:
+   /**@name Constructors/Destructors */
+   ///@{
+   /** Default constructor.
+    *
+    *  It takes in those collecting Ipopt
+    *  objects that can provide the statistics information.  Those
+    *  statistics are retrieved at the time of the constructor
+    *  call.
+    */
+   SolveStatistics(
+      const SmartPtr<IpoptNLP>&                  ip_nlp,
+      const SmartPtr<IpoptData>&                 ip_data,
+      const SmartPtr<IpoptCalculatedQuantities>& ip_cq
+   );
+
+   /** Default destructor */
+   virtual ~SolveStatistics()
+   { }
+   ///@}
+
+   /** @name Accessor methods for retrieving different kind of solver statistics information */
+   ///@{
+   /** Iteration counts. */
+   virtual Index IterationCount() const;
+
+   /** Total CPU time, including function evaluations. */
+   virtual Number TotalCpuTime() const;
+
+   /** Total CPU time, including function evaluations.
+    *
+    * @deprecated Use TotalCpuTime() instead.
+    */
+   IPOPT_DEPRECATED
+   Number TotalCPUTime() const
+   {
+      return TotalCpuTime();
+   }
+
+   /** Total System time, including function evaluations. */
+   virtual Number TotalSysTime() const;
+
+   /** Total wall clock time, including function evaluations. */
+   virtual Number TotalWallclockTime() const;
+
+   /** Number of NLP function evaluations. */
+   virtual void NumberOfEvaluations(
+      Index& num_obj_evals,
+      Index& num_constr_evals,
+      Index& num_obj_grad_evals,
+      Index& num_constr_jac_evals,
+      Index& num_hess_evals
+   ) const;
+
+   /** Unscaled solution infeasibilities.
+    *
+    * @deprecated Use Infeasibilities() with 5 arguments instead.
+    */
+   IPOPT_DEPRECATED
+   virtual void Infeasibilities(
+      Number& dual_inf,
+      Number& constr_viol,
+      Number& complementarity,
+      Number& kkt_error
+   ) const;
+
+   /** Unscaled solution infeasibilities. */
+   virtual void Infeasibilities(
+      Number& dual_inf,        ///< dual infeasibility (Gradient of Lagrangian not zero)
+      Number& constr_viol,     ///< violation of constraints
+      Number& varbounds_viol,  ///< violation of variable bounds @since 3.14.0
+      Number& complementarity, ///< violation of complementarity
+      Number& kkt_error        ///< KKT error
+   ) const;
+
+   /** Scaled solution infeasibilities.
+    *
+    * @deprecated Use ScaledInfeasibilities() with 5 arguments instead.
+    */
+   IPOPT_DEPRECATED
+   virtual void ScaledInfeasibilities(
+      Number& scaled_dual_inf,
+      Number& scaled_constr_viol,
+      Number& scaled_complementarity,
+      Number& scaled_kkt_error
+   ) const;
+
+   /** Scaled solution infeasibilities.
+    *
+    * @deprecated Use ScaledInfeasibilities() with 5 arguments instead.
+    */
+   virtual void ScaledInfeasibilities(
+      Number& scaled_dual_inf,        ///< scaled dual infeasibility (Gradient of Lagrangian not zero)
+      Number& scaled_constr_viol,     ///< violation of scaled constraints
+      Number& scaled_varbounds_viol,  ///< violation of scaled variable bounds @since 3.14.0
+      Number& scaled_complementarity, ///< violation of scaled complementarity
+      Number& scaled_kkt_error        ///< scaled KKT error
+   ) const;
+
+   /** Final value of objective function */
+   virtual Number FinalObjective() const;
+
+   /** Final scaled value of objective function */
+   virtual Number FinalScaledObjective() const;
+   ///@}
+
+private:
+   /**@name Default Compiler Generated Methods
+    * (Hidden to avoid implicit creation/calling).
+    *
+    * These methods are not implemented and
+    * we do not want the compiler to implement
+    * them for us, so we declare them private
+    * and do not define them. This ensures that
+    * they will not be implicitly created/called.
+    */
+   ///@{
+   /** Default Constructor */
+   SolveStatistics();
+
+   /** Copy Constructor */
+   SolveStatistics(
+      const SolveStatistics&
+   );
+
+   /** Default Assignment Operator */
+   void operator=(
+      const SolveStatistics&
+   );
+   ///@}
+
+   /** @name Fields for storing the statistics data */
+   ///@{
+   /** Number of iterations. */
+   Index num_iters_;
+   /* Total CPU time */
+   Number total_cpu_time_;
+   /* Total system time */
+   Number total_sys_time_;
+   /* Total wall clock time */
+   Number total_wallclock_time_;
+   /** Number of objective function evaluations. */
+   Index num_obj_evals_;
+   /** Number of constraints evaluations (max of equality and inequality) */
+   Index num_constr_evals_;
+   /** Number of objective gradient evaluations. */
+   Index num_obj_grad_evals_;
+   /** Number of constraint Jacobian evaluations. */
+   Index num_constr_jac_evals_;
+   /** Number of Lagrangian Hessian evaluations. */
+   Index num_hess_evals_;
+
+   /** Final scaled value of objective function */
+   Number scaled_obj_val_;
+   /** Final unscaled value of objective function */
+   Number obj_val_;
+   /** Final scaled dual infeasibility (max-norm) */
+   Number scaled_dual_inf_;
+   /** Final unscaled dual infeasibility (max-norm) */
+   Number dual_inf_;
+   /** Final scaled constraint violation (max-norm) */
+   Number scaled_constr_viol_;
+   /** Final unscaled constraint violation (max-norm) */
+   Number constr_viol_;
+   /** Final scaled variable bound violation (max-norm) */
+   Number scaled_bound_viol_;
+   /** Final unscaled variable bound violation (max-norm) */
+   Number bound_viol_;
+   /** Final scaled complementarity error (max-norm) */
+   Number scaled_compl_;
+   /** Final unscaled complementarity error (max-norm) */
+   Number compl_;
+   /** Final overall scaled KKT error (max-norm) */
+   Number scaled_kkt_error_;
+   /** Final overall unscaled KKT error (max-norm) */
+   Number kkt_error_;
+   ///@}
+};
+
+} // namespace Ipopt
+
+#endif

casadi/include/coin-or/IpSparseSymLinearSolverInterface.hpp

@@ -0,0 +1,260 @@
+// Copyright (C) 2004, 2007 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-03-17
+
+#ifndef __IPSPARSESYMLINEARSOLVERINTERFACE_HPP__
+#define __IPSPARSESYMLINEARSOLVERINTERFACE_HPP__
+
+#include "IpUtils.hpp"
+#include "IpAlgStrategy.hpp"
+#include "IpSymLinearSolver.hpp"
+
+namespace Ipopt
+{
+
+/** Base class for interfaces to symmetric indefinite linear solvers
+ *  for sparse matrices.
+ *
+ *  This defines the general interface to linear solvers for sparse
+ *  symmetric indefinite matrices.  The matrices can be provided
+ *  either in "triplet format" for the lower triangular part
+ *  (like for Harwell's MA27 solver), or in compressed sparse row
+ *  (CSR) format for the upper triangular part of the symmetric matrix.
+ *  The latter may equivalently (or better) be referred as compressed
+ *  sparse column (CSC) format for the lower triangular part.
+ *
+ *  The solver should be able to compute the inertia of the matrix,
+ *  or more specifically, the number of negative eigenvalues in the
+ *  factorized matrix.
+ *
+ *  This interface is used by the calling objective in the following
+ *  way:
+ *
+ *  1. The InitializeImpl method is called at the very beginning
+ *  (for every optimization run), which allows the linear solver
+ *  object to retrieve options given in the OptionsList (such as
+ *  pivot tolerances etc).  At this point, some internal data can
+ *  also be initialized.
+ *
+ *  2. The calling class calls MatrixFormat to find out which matrix
+ *  representation the linear solver requires.  The possible options
+ *  are Triplet_Format, as well as CSR_Format_0_Offset and
+ *  CSR_Format_1_Offset.  The difference between the last two is
+ *  that for CSR_Format_0_Offset the counting of the element position
+ *  in the ia and ja arrays starts are 0 (C-style numbering),
+ *  whereas for the other one it starts at 1 (Fortran-style
+ *  numbering).
+ *
+ *  3. After this, the InitializeStructure method is called (once).
+ *  Here, the structure of the matrix is provided.  If the linear
+ *  solver requires a symbolic preprocessing phase that can be done
+ *  without knowledge of the matrix element values, it can be done
+ *  here.
+ *
+ *  4. The calling class will request an array for storing the
+ *  actual values for a matrix using the GetValuesArrayPtr method.
+ *  This array must be at least as large as the number of nonzeros
+ *  in the matrix (as given to this class by the InitializeStructure
+ *  method call).  After a call of this method, the calling class
+ *  will fill this array with the actual values of the matrix.
+ *
+ *  5. Every time later on, when actual solves of a linear system is
+ *  requested, the calling class will call the MultiSolve to request
+ *  the solve, possibly for multiple right-hand sides.  The flag
+ *  new_matrix then indicates if the values of the matrix have
+ *  changed and if a factorization is required, or if an old
+ *  factorization can be used to do the solve.
+ *
+ *  Note that the GetValuesArrayPtr method will be called before
+ *  every call of MultiSolve with new_matrix=true, or before a
+ *  renewed call of MultiSolve if the most previous return value was
+ *  SYMSOLV_CALL_AGAIN.
+ *
+ *  6. The calling class might request with NumberOfNegEVals the
+ *  number of the negative eigenvalues for the original matrix that
+ *  were detected during the most recently performed factorization.
+ *
+ *  7. The calling class might ask the linear solver to increase the
+ *  quality of the solution.  For example, if the linear solver uses
+ *  a pivot tolerance, a larger value should be used for the next
+ *  solve (which might require a refactorization).
+ *
+ *  8. Finally, when the destructor is called, the internal storage,
+ *  also in the linear solver, should be released.
+ *
+ *  Note, if the matrix is given in triplet format, entries might be
+ *  listed multiple times, in which case the corresponding elements
+ *  have to be added.
+ *
+ *  A note for warm starts: If the option
+ *  "warm_start_same_structure" is specified with "yes", the
+ *  algorithm assumes that a problem with the same sparsity
+ *  structure is solved for a repeated time.  In that case, the
+ *  linear solver might reuse information from the previous
+ *  optimization.  See Ma27TSolverInterface for an example.
+ */
+class SparseSymLinearSolverInterface: public AlgorithmStrategyObject
+{
+public:
+   /** Enum to specify sparse matrix format. */
+   enum EMatrixFormat
+   {
+      /** Triplet (MA27) format for lower triangular part */
+      Triplet_Format,
+      /** Compressed sparse row format for upper triangular part, with 0 offset */
+      CSR_Format_0_Offset,
+      /** Compressed sparse row format for upper triangular part, with 1 offset */
+      CSR_Format_1_Offset,
+      /** Compressed sparse row format for both lower and upper parts, with 0 offset */
+      CSR_Full_Format_0_Offset,
+      /** Compressed sparse row format for both lower and upper parts, with 1 offset */
+      CSR_Full_Format_1_Offset
+   };
+
+   /** @name Constructor/Destructor */
+   ///@{
+   SparseSymLinearSolverInterface()
+   { }
+
+   virtual ~SparseSymLinearSolverInterface()
+   { }
+   ///@}
+
+   virtual bool InitializeImpl(
+      const OptionsList& options,
+      const std::string& prefix
+   ) = 0;
+
+   /** @name Methods for requesting solution of the linear system. */
+   ///@{
+   /** Method for initializing internal structures.
+    *
+    *  Here, ndim gives the number of rows and columns of the matrix,
+    *  nonzeros give the number of nonzero elements, and ia and ja give
+    *  the positions of the nonzero elements, given in the matrix format
+    *  determined by MatrixFormat.
+    */
+   virtual ESymSolverStatus InitializeStructure(
+      Index        dim,
+      Index        nonzeros,
+      const Index* ia,
+      const Index* ja
+   ) = 0;
+
+   /** Method returning an internal array into which the nonzero
+    *  elements (in the same order as ja) will be stored by the
+    *  calling routine before a call to MultiSolve with a
+    *  new_matrix=true (or after a return of MultiSolve with
+    *  SYMSOLV_CALL_AGAIN).
+    *
+    *  The returned array must have space for at
+    *  least nonzero elements.
+    */
+   virtual Number* GetValuesArrayPtr() = 0;
+
+   /** Solve operation for multiple right hand sides.
+    *
+    *  Solves the linear system A * x = b with multiple right hand sides,
+    *  where A is the symmetric indefinite matrix. Here, ia and ja give
+    *  the positions of the values (in the required matrix data format).
+    *  The actual values of the matrix will have been given to this
+    *  object by copying them into the array provided by
+    *  GetValuesArrayPtr. ia and ja are identical to the ones given
+    *  to InitializeStructure.  The flag new_matrix is set to true,
+    *  if the values of the matrix has changed, and a refactorization
+    *  is required.
+    *
+    *  @return SYMSOLV_SUCCESS if the factorization and
+    *  solves were successful, SYMSOLV_SINGULAR if the linear system
+    *  is singular, and SYMSOLV_WRONG_INERTIA if check_NegEVals is
+    *  true and the number of negative eigenvalues in the matrix does
+    *  not match numberOfNegEVals.  If SYMSOLV_CALL_AGAIN is
+    *  returned, then the calling function will request the pointer
+    *  for the array for storing a again (with GetValuesPtr), write
+    *  the values of the nonzero elements into it, and call this
+    *  MultiSolve method again with the same right-hand sides.  (This
+    *  can be done, for example, if the linear solver realized it
+    *  does not have sufficient memory and needs to redo the
+    *  factorization; e.g., for MA27.)
+    *
+    *  The number of right-hand sides is given by nrhs, the values of
+    *  the right-hand sides are given in rhs_vals (one full right-hand
+    *  side stored immediately after the other), and solutions are
+    *  to be returned in the same array.
+    *
+    *  check_NegEVals will not be chosen true, if ProvidesInertia()
+    *  returns false.
+    */
+   virtual ESymSolverStatus MultiSolve(
+      bool         new_matrix,
+      const Index* ia,
+      const Index* ja,
+      Index        nrhs,
+      Number*      rhs_vals,
+      bool         check_NegEVals,
+      Index        numberOfNegEVals
+   ) = 0;
+
+   /** Number of negative eigenvalues detected during last factorization.
+    *
+    *  @return the number of negative eigenvalues of the most recent factorized matrix.
+    *
+    *  This must not be called if the linear solver does not compute this quantities
+    *  (see ProvidesInertia).
+    */
+   virtual Index NumberOfNegEVals() const = 0;
+   ///@}
+
+   //* @name Options of Linear solver */
+   ///@{
+   /** Request to increase quality of solution for next solve.
+    *
+    *  The calling class asks linear solver to increase quality of
+    *  solution for the next solve (e.g. increase pivot tolerance).
+    *
+    *  @return false, if this is not possible (e.g. maximal pivot
+    *  tolerance already used.)
+    */
+   virtual bool IncreaseQuality() = 0;
+
+   /** Query whether inertia is computed by linear solver.
+    *
+    *  @return true, if linear solver provides inertia
+    */
+   virtual bool ProvidesInertia() const = 0;
+
+   /** Query of requested matrix type that the linear solver
+    *  understands.
+    */
+   virtual EMatrixFormat MatrixFormat() const = 0;
+   ///@}
+
+   /** @name Methods related to the detection of linearly dependent
+    *  rows in a matrix */
+   ///@{
+   /** Query whether the indices of linearly dependent rows/columns
+    *  can be determined by this linear solver.
+    */
+   virtual bool ProvidesDegeneracyDetection() const
+   {
+      return false;
+   }
+
+   /** This method determines the list of row indices of the linearly
+    *  dependent rows.
+    */
+   virtual ESymSolverStatus DetermineDependentRows(
+      const Index*      /*ia*/,
+      const Index*      /*ja*/,
+      std::list<Index>& /*c_deps*/
+   )
+   {
+      return SYMSOLVER_FATAL_ERROR;
+   }
+};
+
+} // namespace Ipopt
+
+#endif