casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CoinStructuredModel.hpp

@@ -0,0 +1,270 @@
+/* $Id$ */
+// Copyright (C) 2008, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CoinStructuredModel_H
+#define CoinStructuredModel_H
+
+#include "CoinModel.hpp"
+#include <vector>
+
+/** 
+    This is a model which is made up of Coin(Structured)Model blocks.
+*/
+typedef struct CoinModelInfo2 {
+  int rowBlock; // Which row block
+  int columnBlock; // Which column block
+  char matrix; // nonzero if matrix exists
+  char rhs; // nonzero if non default rhs exists
+  char rowName; // nonzero if row names exists
+  char integer; // nonzero if integer information exists
+  char bounds; // nonzero if non default bounds/objective exists
+  char columnName; // nonzero if column names exists
+  CoinModelInfo2()
+    : rowBlock(0)
+    , columnBlock(0)
+    , matrix(0)
+    , rhs(0)
+    , rowName(0)
+    , integer(0)
+    , bounds(0)
+    , columnName(0)
+  {
+  }
+} CoinModelBlockInfo;
+
+class CoinStructuredModel : public CoinBaseModel {
+
+public:
+  /**@name Useful methods for building model */
+  //@{
+  /** add a block from a CoinModel using names given as parameters 
+      returns number of errors (e.g. both have objectives but not same)
+   */
+  int addBlock(const std::string &rowBlock,
+    const std::string &columnBlock,
+    const CoinBaseModel &block);
+  /** add a block from a CoinModel with names in model
+      returns number of errors (e.g. both have objectives but not same)
+ */
+  int addBlock(const CoinBaseModel &block);
+  /** add a block from a CoinModel using names given as parameters 
+      returns number of errors (e.g. both have objectives but not same)
+      This passes in block - structured model takes ownership
+   */
+  int addBlock(const std::string &rowBlock,
+    const std::string &columnBlock,
+    CoinBaseModel *block);
+  /** add a block using names 
+   */
+  int addBlock(const std::string &rowBlock,
+    const std::string &columnBlock,
+    const CoinPackedMatrix &matrix,
+    const double *rowLower, const double *rowUpper,
+    const double *columnLower, const double *columnUpper,
+    const double *objective);
+
+  /** Write the problem in MPS format to a file with the given filename.
+      
+  \param compression can be set to three values to indicate what kind
+  of file should be written
+  <ul>
+  <li> 0: plain text (default)
+  <li> 1: gzip compressed (.gz is appended to \c filename)
+  <li> 2: bzip2 compressed (.bz2 is appended to \c filename) (TODO)
+  </ul>
+  If the library was not compiled with the requested compression then
+  writeMps falls back to writing a plain text file.
+  
+  \param formatType specifies the precision to used for values in the
+  MPS file
+  <ul>
+  <li> 0: normal precision (default)
+  <li> 1: extra accuracy
+  <li> 2: IEEE hex
+  </ul>
+  
+  \param numberAcross specifies whether 1 or 2 (default) values should be
+  specified on every data line in the MPS file.
+  
+  not const as may change model e.g. fill in default bounds
+  */
+  int writeMps(const char *filename, int compression = 0,
+    int formatType = 0, int numberAcross = 2, bool keepStrings = false);
+  /// Read SMPS model
+  int readSmps(const char *filename,
+    bool keepNames = false,
+    bool ignoreErrors = false);
+
+  /** Decompose a CoinModel
+      1 - try D-W
+      2 - try Benders
+      3 - try Staircase
+      Returns number of blocks or zero if no structure
+  */
+  int decompose(const CoinModel &model, int type,
+    int maxBlocks = 50, const char **starts = NULL);
+  /** Decompose a model specified as arrays + CoinPackedMatrix
+      1 - try D-W
+      2 - try Benders
+      3 - try Staircase
+      Returns number of blocks or zero if no structure
+  */
+  int decompose(const CoinPackedMatrix &matrix,
+    const double *rowLower, const double *rowUpper,
+    const double *columnLower, const double *columnUpper,
+    const double *objective, int type, int maxBlocks = 50,
+    int *starts = NULL,
+    double objectiveOffset = 0.0);
+
+  //@}
+
+  /**@name For getting information */
+  //@{
+  /// Return number of row blocks
+  inline int numberRowBlocks() const
+  {
+    return numberRowBlocks_;
+  }
+  /// Return number of column blocks
+  inline int numberColumnBlocks() const
+  {
+    return numberColumnBlocks_;
+  }
+  /// Return number of elementBlocks
+  inline int numberElementBlocks() const
+  {
+    return numberElementBlocks_;
+  }
+  /// Return number of elements
+  CoinBigIndex numberElements() const;
+  /// Return the i'th row block name
+  inline const std::string &getRowBlock(int i) const
+  {
+    return rowBlockNames_[i];
+  }
+  /// Set i'th row block name
+  inline void setRowBlock(int i, const std::string &name)
+  {
+    rowBlockNames_[i] = name;
+  }
+  /// Add or check a row block name and number of rows
+  int addRowBlock(int numberRows, const std::string &name);
+  /// Return a row block index given a row block name
+  int rowBlock(const std::string &name) const;
+  /// Return i'th the column block name
+  inline const std::string &getColumnBlock(int i) const
+  {
+    return columnBlockNames_[i];
+  }
+  /// Set i'th column block name
+  inline void setColumnBlock(int i, const std::string &name)
+  {
+    columnBlockNames_[i] = name;
+  }
+  /// Add or check a column block name and number of columns
+  int addColumnBlock(int numberColumns, const std::string &name);
+  /// Return a column block index given a column block name
+  int columnBlock(const std::string &name) const;
+  /// Return i'th block type
+  inline const CoinModelBlockInfo &blockType(int i) const
+  {
+    return blockType_[i];
+  }
+  /// Return i'th block
+  inline CoinBaseModel *block(int i) const
+  {
+    return blocks_[i];
+  }
+  /// Return block corresponding to row and column
+  const CoinBaseModel *block(int row, int column) const;
+  /// Return i'th block as CoinModel (or NULL)
+  CoinModel *coinBlock(int i) const;
+  /// Return block corresponding to row and column as CoinModel
+  const CoinBaseModel *coinBlock(int row, int column) const;
+  /// Return block number corresponding to row and column
+  int blockIndex(int row, int column) const;
+  /** Return model as a CoinModel block
+      and fill in info structure and update counts
+      */
+  CoinModel *coinModelBlock(CoinModelBlockInfo &info);
+  /// Sets given block into coinModelBlocks_
+  void setCoinModel(CoinModel *block, int iBlock);
+  /// Refresh info in blockType_
+  void refresh(int iBlock);
+  /** Fill pointers corresponding to row and column */
+
+  CoinModelBlockInfo block(int row, int column,
+    const double *&rowLower, const double *&rowUpper,
+    const double *&columnLower, const double *&columnUpper,
+    const double *&objective) const;
+  /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  inline double optimizationDirection() const
+  {
+    return optimizationDirection_;
+  }
+  /// Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  inline void setOptimizationDirection(double value)
+  {
+    optimizationDirection_ = value;
+  }
+  //@}
+
+  /**@name Constructors, destructor */
+  //@{
+  /** Default constructor. */
+  CoinStructuredModel();
+  /** Read a problem in MPS format from the given filename.
+      May try and decompose
+   */
+  CoinStructuredModel(const char *fileName, int decompose = 0,
+    int maxBlocks = 50);
+  /** Destructor */
+  virtual ~CoinStructuredModel();
+  //@}
+
+  /**@name Copy method */
+  //@{
+  /** The copy constructor. */
+  CoinStructuredModel(const CoinStructuredModel &);
+  /// =
+  CoinStructuredModel &operator=(const CoinStructuredModel &);
+  /// Clone
+  virtual CoinBaseModel *clone() const;
+  //@}
+
+private:
+  /** Fill in info structure and update counts
+      Returns number of inconsistencies on border
+  */
+  int fillInfo(CoinModelBlockInfo &info, const CoinModel *block);
+  /** Fill in info structure and update counts
+  */
+  void fillInfo(CoinModelBlockInfo &info, const CoinStructuredModel *block);
+  /**@name Data members */
+  //@{
+  /// Current number of row blocks
+  int numberRowBlocks_;
+  /// Current number of column blocks
+  int numberColumnBlocks_;
+  /// Current number of element blocks
+  int numberElementBlocks_;
+  /// Maximum number of element blocks
+  int maximumElementBlocks_;
+  /// Rowblock name
+  std::vector< std::string > rowBlockNames_;
+  /// Columnblock name
+  std::vector< std::string > columnBlockNames_;
+  /// Blocks
+  CoinBaseModel **blocks_;
+  /// CoinModel copies of blocks or NULL if original CoinModel
+  CoinModel **coinModelBlocks_;
+  /// Which parts of model are set in block
+  CoinModelBlockInfo *blockType_;
+  //@}
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinTime.hpp

@@ -0,0 +1,350 @@
+/* $Id$ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef _CoinTime_hpp
+#define _CoinTime_hpp
+
+// Uncomment the next three lines for thorough memory initialisation.
+// #ifndef ZEROFAULT
+// # define ZEROFAULT
+// #endif
+
+//#############################################################################
+
+#include <ctime>
+#if defined(_MSC_VER)
+// Turn off compiler warning about long names
+#pragma warning(disable : 4786)
+#else
+// MacOS-X and FreeBSD needs sys/time.h
+#if defined(__MACH__) || defined(__FreeBSD__)
+#include <sys/time.h>
+#endif
+#if !defined(__MSVCRT__)
+#include <sys/resource.h>
+#endif
+#endif
+
+//#############################################################################
+
+#if defined(_MSC_VER)
+
+#if 0 // change this to 1 if want to use the win32 API
+#include <windows.h>
+#ifdef small
+/* for some unfathomable reason (to me) rpcndr.h (pulled in by windows.h) does a
+   '#define small char' */
+#undef small
+#endif
+#define TWO_TO_THE_THIRTYTWO 4294967296.0
+#define DELTA_EPOCH_IN_SECS 11644473600.0
+inline double CoinGetTimeOfDay()
+{
+  FILETIME ft;
+ 
+  GetSystemTimeAsFileTime(&ft);
+  double t = ft.dwHighDateTime * TWO_TO_THE_THIRTYTWO + ft.dwLowDateTime;
+  t = t/10000000.0 - DELTA_EPOCH_IN_SECS;
+  return t;
+}
+#else
+#include <sys/types.h>
+#include <sys/timeb.h>
+inline double CoinGetTimeOfDay()
+{
+  struct _timeb timebuffer;
+#pragma warning(disable : 4996)
+  _ftime(&timebuffer); // C4996
+#pragma warning(default : 4996)
+  return timebuffer.time + timebuffer.millitm / 1000.0;
+}
+#endif
+
+#else
+
+#include <sys/time.h>
+
+inline double CoinGetTimeOfDay()
+{
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return static_cast< double >(tv.tv_sec) + static_cast< int >(tv.tv_usec) / 1000000.0;
+}
+
+#endif // _MSC_VER
+
+/**
+   Query the elapsed wallclock time since the first call to this function. If
+   a positive argument is passed to the function then the time of the first
+   call is set to that value (this kind of argument is allowed only at the
+   first call!). If a negative argument is passed to the function then it
+   returns the time when it was set.
+*/
+
+inline double CoinWallclockTime(double callType = 0)
+{
+  double callTime = CoinGetTimeOfDay();
+  static const double firstCall = callType > 0 ? callType : callTime;
+  return callType < 0 ? firstCall : callTime - firstCall;
+}
+
+//#############################################################################
+
+//#define HAVE_SDK // if SDK under Win32 is installed, for CPU instead of elapsed time under Win
+#ifdef HAVE_SDK
+#include <windows.h>
+#ifdef small
+/* for some unfathomable reason (to me) rpcndr.h (pulled in by windows.h) does a
+   '#define small char' */
+#undef small
+#endif
+#define TWO_TO_THE_THIRTYTWO 4294967296.0
+#endif
+
+static inline double CoinCpuTime()
+{
+#ifdef COIN_DOING_DIFFS
+  // when trying to see differences between runs it can be helpful
+  return 0.0;
+#endif
+  double cpu_temp;
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+#ifdef HAVE_SDK
+  FILETIME creation;
+  FILETIME exit;
+  FILETIME kernel;
+  FILETIME user;
+  GetProcessTimes(GetCurrentProcess(), &creation, &exit, &kernel, &user);
+  double t = user.dwHighDateTime * TWO_TO_THE_THIRTYTWO + user.dwLowDateTime;
+  return t / 10000000.0;
+#else
+  unsigned int ticksnow; /* clock_t is same as int */
+  ticksnow = (unsigned int)clock();
+  cpu_temp = (double)((double)ticksnow / CLOCKS_PER_SEC);
+#endif
+
+#else
+  struct rusage usage;
+#ifdef ZEROFAULT
+  usage.ru_utime.tv_sec = 0;
+  usage.ru_utime.tv_usec = 0;
+#endif
+  getrusage(RUSAGE_SELF, &usage);
+  cpu_temp = static_cast< double >(usage.ru_utime.tv_sec);
+  cpu_temp += 1.0e-6 * (static_cast< double >(usage.ru_utime.tv_usec));
+#endif
+  return cpu_temp;
+}
+
+//#############################################################################
+
+static inline double CoinSysTime()
+{
+  double sys_temp;
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+  sys_temp = 0.0;
+#else
+  struct rusage usage;
+#ifdef ZEROFAULT
+  usage.ru_utime.tv_sec = 0;
+  usage.ru_utime.tv_usec = 0;
+#endif
+  getrusage(RUSAGE_SELF, &usage);
+  sys_temp = static_cast< double >(usage.ru_stime.tv_sec);
+  sys_temp += 1.0e-6 * (static_cast< double >(usage.ru_stime.tv_usec));
+#endif
+  return sys_temp;
+}
+
+//#############################################################################
+// On most systems SELF seems to include children threads, This is for when it doesn't
+static inline double CoinCpuTimeJustChildren()
+{
+  double cpu_temp;
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+  cpu_temp = 0.0;
+#else
+  struct rusage usage;
+#ifdef ZEROFAULT
+  usage.ru_utime.tv_sec = 0;
+  usage.ru_utime.tv_usec = 0;
+#endif
+  getrusage(RUSAGE_CHILDREN, &usage);
+  cpu_temp = static_cast< double >(usage.ru_utime.tv_sec);
+  cpu_temp += 1.0e-6 * (static_cast< double >(usage.ru_utime.tv_usec));
+#endif
+  return cpu_temp;
+}
+//#############################################################################
+
+#include <fstream>
+
+/**
+ This class implements a timer that also implements a tracing functionality.
+
+ The timer stores the start time of the timer, for how much time it was set to
+ and when does it expire (start + limit = end). Queries can be made that tell
+ whether the timer is expired, is past an absolute time, is past a percentage
+ of the length of the timer. All times are given in seconds, but as double
+ numbers, so there can be fractional values.
+
+ The timer can also be initialized with a stream and a specification whether
+ to write to or read from the stream. In the former case the result of every
+ query is written into the stream, in the latter case timing is not tested at
+ all, rather the supposed result is read out from the stream. This makes it
+ possible to exactly retrace time sensitive program execution.
+*/
+class CoinTimer {
+private:
+  /// When the timer was initialized/reset/restarted
+  double start;
+  ///
+  double limit;
+  double end;
+#ifdef COIN_COMPILE_WITH_TRACING
+  std::fstream *stream;
+  bool write_stream;
+#endif
+
+private:
+#ifdef COIN_COMPILE_WITH_TRACING
+  inline bool evaluate(bool b_tmp) const
+  {
+    int i_tmp = b_tmp;
+    if (stream) {
+      if (write_stream)
+        (*stream) << i_tmp << "\n";
+      else
+        (*stream) >> i_tmp;
+    }
+    return i_tmp;
+  }
+  inline double evaluate(double d_tmp) const
+  {
+    if (stream) {
+      if (write_stream)
+        (*stream) << d_tmp << "\n";
+      else
+        (*stream) >> d_tmp;
+    }
+    return d_tmp;
+  }
+#else
+  inline bool evaluate(const bool b_tmp) const
+  {
+    return b_tmp;
+  }
+  inline double evaluate(const double d_tmp) const
+  {
+    return d_tmp;
+  }
+#endif
+
+public:
+  /// Default constructor creates a timer with no time limit and no tracing
+  CoinTimer()
+    : start(0)
+    , limit(1e100)
+    , end(1e100)
+#ifdef COIN_COMPILE_WITH_TRACING
+    , stream(0)
+    , write_stream(true)
+#endif
+  {
+  }
+
+  /// Create a timer with the given time limit and with no tracing
+  CoinTimer(double lim)
+    : start(CoinCpuTime())
+    , limit(lim)
+    , end(start + lim)
+#ifdef COIN_COMPILE_WITH_TRACING
+    , stream(0)
+    , write_stream(true)
+#endif
+  {
+  }
+
+#ifdef COIN_COMPILE_WITH_TRACING
+  /** Create a timer with no time limit and with writing/reading the trace
+       to/from the given stream, depending on the argument \c write. */
+  CoinTimer(std::fstream *s, bool write)
+    : start(0)
+    , limit(1e100)
+    , end(1e100)
+    , stream(s)
+    , write_stream(write)
+  {
+  }
+
+  /** Create a timer with the given time limit and with writing/reading the
+       trace to/from the given stream, depending on the argument \c write. */
+  CoinTimer(double lim, std::fstream *s, bool w)
+    : start(CoinCpuTime())
+    , limit(lim)
+    , end(start + lim)
+    , stream(s)
+    , write_stream(w)
+  {
+  }
+#endif
+
+  /// Restart the timer (keeping the same time limit)
+  inline void restart()
+  {
+    start = CoinCpuTime();
+    end = start + limit;
+  }
+  /// An alternate name for \c restart()
+  inline void reset() { restart(); }
+  /// Reset (and restart) the timer and change its time limit
+  inline void reset(double lim)
+  {
+    limit = lim;
+    restart();
+  }
+
+  /** Return whether the given percentage of the time limit has elapsed since
+       the timer was started */
+  inline bool isPastPercent(double pct) const
+  {
+    return evaluate(start + limit * pct < CoinCpuTime());
+  }
+  /** Return whether the given amount of time has elapsed since the timer was
+       started */
+  inline bool isPast(double lim) const
+  {
+    return evaluate(start + lim < CoinCpuTime());
+  }
+  /** Return whether the originally specified time limit has passed since the
+       timer was started */
+  inline bool isExpired() const
+  {
+    return evaluate(end < CoinCpuTime());
+  }
+
+  /** Return how much time is left on the timer */
+  inline double timeLeft() const
+  {
+    return evaluate(end - CoinCpuTime());
+  }
+
+  /** Return how much time has elapsed */
+  inline double timeElapsed() const
+  {
+    return evaluate(CoinCpuTime() - start);
+  }
+
+  inline void setLimit(double l)
+  {
+    limit = l;
+    return;
+  }
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinTypes.hpp

@@ -0,0 +1,67 @@
+/* $Id$ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef _CoinTypes_hpp
+#define _CoinTypes_hpp
+
+#include "CoinUtilsConfig.h"
+/* On some systems, we require stdint.h to have the 64bit integer type defined. */
+#ifdef COINUTILS_HAS_STDINT_H
+#include <stdint.h>
+#endif
+#ifdef COINUTILS_HAS_CSTDINT
+#include <cstdint>
+#endif
+
+#define CoinInt64 COIN_INT64_T
+#define CoinUInt64 COIN_UINT64_T
+#define CoinIntPtr COIN_INTPTR_T
+
+//=============================================================================
+#ifndef COIN_BIG_INDEX
+#define COIN_BIG_INDEX 0
+#endif
+
+#if COIN_BIG_INDEX == 0
+typedef int CoinBigIndex;
+#elif COIN_BIG_INDEX == 1
+typedef long CoinBigIndex;
+#else
+typedef long long CoinBigIndex;
+#endif
+
+//=============================================================================
+#ifndef COIN_BIG_DOUBLE
+#define COIN_BIG_DOUBLE 0
+#endif
+
+// See if we want the ability to have long double work arrays
+#if COIN_BIG_DOUBLE == 2
+#undef COIN_BIG_DOUBLE
+#define COIN_BIG_DOUBLE 0
+#define COIN_LONG_WORK 1
+typedef long double CoinWorkDouble;
+#elif COIN_BIG_DOUBLE == 3
+#undef COIN_BIG_DOUBLE
+#define COIN_BIG_DOUBLE 1
+#define COIN_LONG_WORK 1
+typedef long double CoinWorkDouble;
+#else
+#define COIN_LONG_WORK 0
+typedef double CoinWorkDouble;
+#endif
+
+#if COIN_BIG_DOUBLE == 0
+typedef double CoinFactorizationDouble;
+#elif COIN_BIG_DOUBLE == 1
+typedef long double CoinFactorizationDouble;
+#else
+typedef double CoinFactorizationDouble;
+#endif
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinUtility.hpp

@@ -0,0 +1,26 @@
+/* $Id$ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CoinUtility_h_
+#define CoinUtility_h_
+
+#include "CoinSort.hpp"
+
+template < typename S, typename T >
+CoinPair< S, T > CoinMakePair(const S &s, const T &t)
+{
+  return CoinPair< S, T >(s, t);
+}
+
+template < typename S, typename T, typename U >
+CoinTriple< S, T, U > CoinMakeTriple(const S &s, const T &t, const U &u)
+{
+  return CoinTriple< S, T, U >(s, t, u);
+}
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/