casadi 3.6.3__cp35-none-manylinux2010_x86_64.whl → 3.6.5__cp35-none-manylinux2010_x86_64.whl

casadi/include/coin/ClpParameters.hpp

@@ -0,0 +1,132 @@
+/* $Id$ */
+// Copyright (C) 2000, 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef _ClpParameters_H
+#define _ClpParameters_H
+
+/** This is where to put any useful stuff.
+
+*/
+enum ClpIntParam {
+  /** The maximum number of iterations Clp can execute in the simplex methods
+      */
+  ClpMaxNumIteration = 0,
+  /** The maximum number of iterations Clp can execute in hotstart before
+         terminating */
+  ClpMaxNumIterationHotStart,
+  /** The name discipline; specifies how the solver will handle row and
+         column names.
+       - 0: Auto names: Names cannot be set by the client. Names of the form
+        Rnnnnnnn or Cnnnnnnn are generated on demand when a name for a
+        specific row or column is requested; nnnnnnn is derived from the row
+        or column index. Requests for a vector of names return a vector with
+        zero entries.
+       - 1: Lazy names: Names supplied by the client are retained. Names of the
+        form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been
+        supplied by the client. Requests for a vector of names return a
+        vector sized to the largest index of a name supplied by the client;
+        some entries in the vector may be null strings.
+       - 2: Full names: Names supplied by the client are retained. Names of the
+        form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been
+        supplied by the client. Requests for a vector of names return a
+        vector sized to match the constraint system, and all entries will
+        contain either the name specified by the client or a generated name.
+     */
+  ClpNameDiscipline,
+  /** Just a marker, so that we can allocate a static sized array to store
+         parameters. */
+  ClpLastIntParam
+};
+
+enum ClpDblParam {
+  /** Set Dual objective limit. This is to be used as a termination criteria
+         in methods where the dual objective monotonically changes (dual
+         simplex). */
+  ClpDualObjectiveLimit,
+  /** Primal objective limit. This is to be used as a termination
+         criteria in methods where the primal objective monotonically changes
+         (e.g., primal simplex) */
+  ClpPrimalObjectiveLimit,
+  /** The maximum amount the dual constraints can be violated and still be
+         considered feasible. */
+  ClpDualTolerance,
+  /** The maximum amount the primal constraints can be violated and still be
+         considered feasible. */
+  ClpPrimalTolerance,
+  /** Objective function constant. This the value of the constant term in
+         the objective function. */
+  ClpObjOffset,
+  /// Maximum time in seconds - after, this action is as max iterations
+  ClpMaxSeconds,
+  /// Maximum wallclock running time in seconds - after, this action is as max iterations
+  ClpMaxWallSeconds,
+  /// Tolerance to use in presolve
+  ClpPresolveTolerance,
+  /** Just a marker, so that we can allocate a static sized array to store
+         parameters. */
+  ClpLastDblParam
+};
+
+enum ClpStrParam {
+  /** Name of the problem. This is the found on the Name card of
+         an mps file. */
+  ClpProbName = 0,
+  /** Just a marker, so that we can allocate a static sized array to store
+         parameters. */
+  ClpLastStrParam
+};
+
+/// Copy (I don't like complexity of Coin version)
+template < class T >
+inline void
+ClpDisjointCopyN(const T *array, const CoinBigIndex size, T *newArray)
+{
+  memcpy(reinterpret_cast< void * >(newArray), array, size * sizeof(T));
+}
+/// And set
+template < class T >
+inline void
+ClpFillN(T *array, const CoinBigIndex size, T value)
+{
+  CoinBigIndex i;
+  for (i = 0; i < size; i++)
+    array[i] = value;
+}
+/// This returns a non const array filled with input from scalar or actual array
+template < class T >
+inline T *
+ClpCopyOfArray(const T *array, const CoinBigIndex size, T value)
+{
+  T *arrayNew = new T[size];
+  if (array)
+    ClpDisjointCopyN(array, size, arrayNew);
+  else
+    ClpFillN(arrayNew, size, value);
+  return arrayNew;
+}
+
+/// This returns a non const array filled with actual array (or NULL)
+template < class T >
+inline T *
+ClpCopyOfArray(const T *array, const CoinBigIndex size)
+{
+  if (array) {
+    T *arrayNew = new T[size];
+    ClpDisjointCopyN(array, size, arrayNew);
+    return arrayNew;
+  } else {
+    return NULL;
+  }
+}
+/// For a structure to be used by trusted code
+typedef struct {
+  int typeStruct; // allocated as 1,2 etc
+  int typeCall;
+  void *data;
+} ClpTrustedData;
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpPdcoBase.hpp

@@ -0,0 +1,110 @@
+/* $Id$ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpPdcoBase_H
+#define ClpPdcoBase_H
+
+#include "CoinPragma.hpp"
+
+#include "CoinPackedMatrix.hpp"
+#include "CoinDenseVector.hpp"
+class ClpInterior;
+
+/** Abstract base class for tailoring everything for Pcdo
+
+    Since this class is abstract, no object of this type can be created.
+
+    If a derived class provides all methods then all ClpPcdo algorithms
+    should work.
+
+    Eventually we should be able to use ClpObjective and ClpMatrixBase.
+*/
+
+class ClpPdcoBase {
+
+public:
+  /**@name Virtual methods that the derived classes must provide */
+  //@{
+  virtual void matVecMult(ClpInterior *model, int mode, double *x, double *y) const = 0;
+
+  virtual void getGrad(ClpInterior *model, CoinDenseVector< double > &x, CoinDenseVector< double > &grad) const = 0;
+
+  virtual void getHessian(ClpInterior *model, CoinDenseVector< double > &x, CoinDenseVector< double > &H) const = 0;
+
+  virtual double getObj(ClpInterior *model, CoinDenseVector< double > &x) const = 0;
+
+  virtual void matPrecon(ClpInterior *model, double delta, double *x, double *y) const = 0;
+
+  //@}
+  //@{
+  ///@name Other
+  /// Clone
+  virtual ClpPdcoBase *clone() const = 0;
+  /// Returns type
+  inline int type() const
+  {
+    return type_;
+  };
+  /// Sets type
+  inline void setType(int type)
+  {
+    type_ = type;
+  };
+  /// Returns size of d1
+  inline int sizeD1() const
+  {
+    return 1;
+  };
+  /// Returns d1 as scalar
+  inline double getD1() const
+  {
+    return d1_;
+  };
+  /// Returns size of d2
+  inline int sizeD2() const
+  {
+    return 1;
+  };
+  /// Returns d2 as scalar
+  inline double getD2() const
+  {
+    return d2_;
+  };
+  //@}
+
+protected:
+  /**@name Constructors, destructor<br>
+        <strong>NOTE</strong>: All constructors are protected. There's no need
+        to expose them, after all, this is an abstract class. */
+  //@{
+  /** Default constructor. */
+  ClpPdcoBase();
+  /** Destructor (has to be public) */
+public:
+  virtual ~ClpPdcoBase();
+
+protected:
+  // Copy
+  ClpPdcoBase(const ClpPdcoBase &);
+  // Assignment
+  ClpPdcoBase &operator=(const ClpPdcoBase &);
+  //@}
+
+protected:
+  /**@name Data members
+        The data members are protected to allow access for derived classes. */
+  //@{
+  /// Should be dense vectors
+  double d1_;
+  double d2_;
+  /// type (may be useful)
+  int type_;
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/