mipster 0.2.0__py3-none-win_amd64.whl

mipster-0.2.0.data/purelib/mipster/__init__.py

@@ -0,0 +1,231 @@
+"""mipster — pre-built MIPster MIP solver shared library.
+
+Resolves the appropriate libmipster shared library for the running CPU.
+
+Two variants ship per x86_64 and Linux aarch64 wheel:
+
+* Linux x86_64 / macOS x86_64 / Windows x86_64:
+    generic + AVX2 (Haswell 2013+, AMD Zen2 2019+)
+* Linux aarch64:
+    generic (ARMv8-A) + neon (ARMv8.2-A — Cortex-A55/A75 2017+, Graviton2)
+* macOS arm64:
+    single build, ARMv8.5-A (Apple M1+)
+
+By default, the most-optimised variant supported by the running CPU is
+selected.  Override with the ``MIPSTER_BUILD`` environment variable:
+
+    export MIPSTER_BUILD=generic   # force the baseline build
+    export MIPSTER_BUILD=avx2      # force AVX2 (x86_64 only; raises if absent)
+    export MIPSTER_BUILD=neon      # force ARMv8.2-A (Linux aarch64 only)
+    export MIPSTER_BUILD=haswell   # alias for avx2 on macOS x86_64
+    export MIPSTER_BUILD=debug     # debug+ASan build, when present
+
+Set ``MIPSTER_VERBOSE=1`` to print the selected variant on first use.
+"""
+
+import os
+import platform
+import subprocess
+from typing import Optional
+
+__version__ = "0.0.0.dev0"
+
+__all__ = [
+    "dist_dir",
+    "lib_dir",
+    "bin_path",
+    "include_dir",
+    "lib_path",
+    "selected_variant",
+]
+
+
+# ── CPU feature detection ────────────────────────────────────────────────────
+
+def _has_avx2() -> bool:
+    """Return True if the running CPU supports AVX2."""
+    if platform.machine().lower() not in ("x86_64", "amd64"):
+        return False
+    try:
+        if platform.system() == "Linux":
+            with open("/proc/cpuinfo") as f:
+                for line in f:
+                    if line.startswith("flags"):
+                        return "avx2" in line.split(":", 1)[1].split()
+        elif platform.system() == "Darwin":
+            r = subprocess.run(
+                ["sysctl", "-n", "hw.optional.avx2_0"],
+                capture_output=True, text=True,
+            )
+            return r.stdout.strip() == "1"
+        elif os.name == "nt":
+            import ctypes
+            # PF_AVX2_INSTRUCTIONS_AVAILABLE = 40
+            return bool(ctypes.windll.kernel32.IsProcessorFeaturePresent(40))
+    except Exception:
+        pass
+    return False
+
+
+def _has_armv8_2() -> bool:
+    """Return True on aarch64 CPUs implementing ARMv8.2-A or later.
+
+    Detected via the ``asimdrdm`` (FEAT_RDM, mandatory in ARMv8.1) and
+    ``lrcpc`` (FEAT_LRCPC, mandatory in ARMv8.3) HWCAP bits exposed by
+    the Linux kernel in /proc/cpuinfo.  We require ``asimdhp``
+    (FP16 — mandatory in ARMv8.2) which is the most reliable single
+    indicator that the CPU is at least ARMv8.2-A.
+    """
+    if platform.machine().lower() not in ("aarch64", "arm64"):
+        return False
+    if platform.system() != "Linux":
+        return False
+    try:
+        with open("/proc/cpuinfo") as f:
+            for line in f:
+                if line.startswith("Features"):
+                    feats = line.split(":", 1)[1].split()
+                    return "asimdhp" in feats
+    except Exception:
+        pass
+    return False
+
+
+# ── Path resolution ──────────────────────────────────────────────────────────
+
+_PKG_DIR = os.path.abspath(os.path.dirname(__file__))
+
+
+def _candidate_dirs() -> dict:
+    """Return {variant: absolute_path} for every dist directory present."""
+    candidates = {}
+    for entry in os.listdir(_PKG_DIR):
+        if entry.startswith("mipster_dist"):
+            full = os.path.join(_PKG_DIR, entry)
+            if not os.path.isdir(full):
+                continue
+            if entry == "mipster_dist":
+                candidates["generic"] = full
+            else:
+                # mipster_dist_avx2, _neon, _haswell, _debug, ...
+                variant = entry[len("mipster_dist_"):]
+                candidates[variant] = full
+    return candidates
+
+
+def _auto_select(variants: dict) -> str:
+    """Pick the best variant the current CPU supports.
+
+    Preference order on x86_64: avx2 / haswell > generic
+    Preference order on aarch64 (Linux): neon > generic
+    macOS arm64 / fallback: generic
+    """
+    machine = platform.machine().lower()
+    if machine in ("x86_64", "amd64") and _has_avx2():
+        for v in ("avx2", "haswell"):
+            if v in variants:
+                return v
+    if machine in ("aarch64", "arm64") and _has_armv8_2():
+        if "neon" in variants:
+            return "neon"
+    return "generic"
+
+
+_selected_variant: Optional[str] = None
+_selected_dir: Optional[str] = None
+
+
+def _resolve() -> str:
+    """Return the absolute path of the selected mipster_dist directory."""
+    global _selected_variant, _selected_dir
+    if _selected_dir is not None:
+        return _selected_dir
+
+    variants = _candidate_dirs()
+    if not variants:
+        raise RuntimeError(
+            f"No mipster_dist* directory found under {_PKG_DIR}. "
+            "The wheel appears to be incomplete; please reinstall."
+        )
+
+    override = os.environ.get("MIPSTER_BUILD", "").strip().lower()
+    if override:
+        if override not in variants:
+            raise RuntimeError(
+                f"MIPSTER_BUILD={override!r} requested but not present in this "
+                f"installation. Available variants: {sorted(variants)}."
+            )
+        chosen = override
+    elif "generic" in variants:
+        chosen = _auto_select(variants)
+        if chosen not in variants:
+            chosen = "generic"
+    else:
+        # No 'generic' (e.g. macOS arm64 ships a single un-suffixed dist
+        # directory called mipster_dist; this branch is defensive).
+        chosen = next(iter(variants))
+
+    _selected_variant = chosen
+    _selected_dir = variants[chosen]
+
+    if os.environ.get("MIPSTER_VERBOSE", "").strip() == "1":
+        print(
+            f"[mipster] variant={chosen}  dir={_selected_dir}",
+            flush=True,
+        )
+
+    return _selected_dir
+
+
+# ── Public API ───────────────────────────────────────────────────────────────
+
+def dist_dir() -> str:
+    """Absolute path of the selected ``mipster_dist*`` directory."""
+    return _resolve()
+
+
+def selected_variant() -> str:
+    """Variant name actually selected (``generic``, ``avx2``, ``neon``, …)."""
+    _resolve()
+    assert _selected_variant is not None
+    return _selected_variant
+
+
+def bin_path() -> str:
+    """Absolute path of the bundled ``mipster`` (or ``mipster.exe``) binary."""
+    exe = "mipster.exe" if os.name == "nt" else "mipster"
+    return os.path.join(dist_dir(), "bin", exe)
+
+
+def include_dir() -> str:
+    """Absolute path of the bundled C API headers (``mipster/Cbc_C_Interface.h``)."""
+    return os.path.join(dist_dir(), "include", "mipster")
+
+
+def lib_dir() -> str:
+    """Absolute path of the directory holding the runtime shared library.
+
+    Note: on Windows the DLL ships in ``bin/`` (libtool/MinGW convention),
+    so this returns ``bin/`` there.  On Linux/macOS it returns ``lib/``.
+    """
+    if os.name == "nt":
+        return os.path.join(dist_dir(), "bin")
+    return os.path.join(dist_dir(), "lib")
+
+
+def lib_path() -> str:
+    """Absolute path of the libmipster shared library file itself."""
+    d = lib_dir()
+    if os.name == "nt":
+        # Windows: MinGW libtool produces lib<name>-<N>.dll where N is the
+        # current ABI version. Pick the first match.
+        import glob
+        matches = sorted(glob.glob(os.path.join(d, "libmipster-*.dll")))
+        if not matches:
+            raise FileNotFoundError(
+                f"libmipster-*.dll not found in {d}; wheel may be corrupted."
+            )
+        return matches[0]
+    if platform.system() == "Darwin":
+        return os.path.join(d, "libmipster.dylib")
+    return os.path.join(d, "libmipster.so")

mipster-0.2.0.data/purelib/mipster/__main__.py

@@ -0,0 +1,23 @@
+"""``python -m mipster`` — invoke the bundled MIPster CLI binary.
+
+Forwards all arguments verbatim and propagates the binary's exit code.
+"""
+
+import os
+import sys
+
+from . import bin_path
+
+
+def main() -> int:
+    exe = bin_path()
+    if os.name == "nt":
+        # On Windows os.execv replaces the current process but the exit
+        # code propagation is fragile; use subprocess instead.
+        import subprocess
+        return subprocess.call([exe, *sys.argv[1:]])
+    os.execv(exe, [exe, *sys.argv[1:]])
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mipster-0.2.0.data/purelib/mipster/mipster_dist/include/mipster/CbcBoundPropagation.hpp

@@ -0,0 +1,135 @@
+// Copyright (C) 2024 COIN-OR Foundation
+// Authors: Cbc development team
+// This code is licensed under the terms of the Eclipse Public License (EPL)
+
+#ifndef CbcBoundPropagation_hpp
+#define CbcBoundPropagation_hpp
+
+#include "CbcConfig.h"
+
+class OsiSolverInterface;
+class CoinMessageHandler;
+
+/*! \brief Bound propagation: singleton tightening + knapsack-based
+ *         bound propagation.
+ *
+ * This class orchestrates a two-phase bound propagation pipeline that runs
+ * before the initial LP relaxation solve:
+ *
+ *  1. **Singleton tightening** (via OsiSolverInterface::tightenBoundsFromSingletonRows)
+ *     — detects rows with a single binary/integer variable and fixes it when
+ *     the constraint forces a unique value. Very fast: O(rows + cols).
+ *
+ *  2. **CoinBoundPropagation** — knapsack-based bound propagation over all
+ *     ≤-type binary rows. Can cascade: after each round, newly fixed variables
+ *     tighten other rows, enabling further fixings.
+ *
+ * ### Usage
+ * \code
+ *   CbcBoundPropagation bp;
+ *   bool feasible = bp.run(solver, handler, logLevel,
+ *                          CbcBoundPropagation::MILPbt,
+ *                          100, timeLimit, startTime);
+ *   if (!feasible) {
+ *     // instance proved infeasible
+ *     int row = bp.infeasibleRow();   // -1 if unknown
+ *     int col = bp.infeasibleCol();   // -1 if unknown
+ *   }
+ *   // tightenings already applied to solver in place
+ *   std::cout << "Fixed " << bp.nFixed() << " variables\n";
+ * \endcode
+ */
+class CBCLIB_EXPORT CbcBoundPropagation {
+public:
+  /*! \brief Aggression level for bound propagation.
+   *
+   *  - Off:       nothing is done (caller should not call run()).
+   *  - Singletons: singleton rows only.
+   *  - MILPbt:   singletons then up to maxRounds of CoinBoundPropagation.
+   *  - Fixpoint:  singletons then CoinBoundPropagation until fixpoint
+   *               (ignores maxRounds).
+   */
+  enum Level {
+    Off = 0,
+    Singletons,
+    MILPbt,
+    Fixpoint
+  };
+
+  /*! \brief Reason why the bound propagation loop stopped. */
+  enum StopReason {
+    NotRun = 0,
+    ReachedFixpoint, ///< No new fixings in last round
+    HitMaxRounds, ///< Reached the maxRounds limit
+    HitTimeLimit, ///< Ran out of time budget
+    InfeasibleDetected ///< Proved infeasible
+  };
+
+  CbcBoundPropagation();
+
+  /*! \brief Run bound propagation.
+   *
+   * Tightenings are applied in-place to \p solver.
+   *
+   * \param solver     The (already-loaded) MIP solver interface.
+   * \param handler    Message handler for logging (may be null for silence).
+   * \param logLevel   CbcModel log level (0=silent, 1=normal, 2=verbose).
+   * \param level      Aggression level (must not be Off).
+   * \param maxRounds  Maximum MILPbt rounds (only used when level == MILPbt).
+   * \param timeLimit  Budget in seconds; use a large value to disable.
+   * \param startTime  Reference elapsed time measured before calling run().
+   *                   measured BEFORE calling run().
+   *
+   * \return true if the problem is (still) feasible, false if infeasibility
+   *         was proved during bound propagation.
+   */
+  bool run(OsiSolverInterface *solver,
+    CoinMessageHandler *handler,
+    int logLevel,
+    Level level,
+    int maxRounds,
+    double timeLimit,
+    double startTime);
+
+  /// Number of variables tightened (not fully fixed) by singleton step.
+  int nSingletonTightened() const { return nSingletonTightened_; }
+
+  /// Number of variables fully fixed by singleton step.
+  int nSingletonFixed() const { return nSingletonFixed_; }
+
+  /// Number of variables fixed by CoinBoundPropagation across all rounds.
+  int nBoundPropFixed() const { return nBoundPropFixed_; }
+
+  /// Total fixings from all phases.
+  int nFixed() const { return nSingletonFixed_ + nBoundPropFixed_; }
+
+  /// Total tightenings (singleton-tightened that were not fully fixed).
+  int nTightened() const { return nSingletonTightened_; }
+
+  /// Number of CoinBoundPropagation rounds executed.
+  int nRoundsRun() const { return nRoundsRun_; }
+
+  /// Reason the loop stopped (NotRun if run() was never called).
+  StopReason stopReason() const { return stopReason_; }
+
+  /// Elapsed/CPU time used by run() in seconds.
+  double timeUsed() const { return timeUsed_; }
+
+  /// Row index that caused infeasibility, or -1 if not available.
+  int infeasibleRow() const { return infeasibleRow_; }
+
+  /// Column index that caused infeasibility, or -1 if not applicable.
+  int infeasibleCol() const { return infeasibleCol_; }
+
+private:
+  int nSingletonTightened_;
+  int nSingletonFixed_;
+  int nBoundPropFixed_;
+  int nRoundsRun_;
+  StopReason stopReason_;
+  double timeUsed_;
+  int infeasibleRow_;
+  int infeasibleCol_;
+};
+
+#endif // CbcBoundPropagation_hpp

mipster-0.2.0.data/purelib/mipster/mipster_dist/include/mipster/CbcBranchActual.hpp

@@ -0,0 +1,25 @@
+// 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 CbcBranchActual_H
+#define CbcBranchActual_H
+
+#include "CbcBranchBase.hpp"
+#include "CoinPackedMatrix.hpp"
+#include "CbcClique.hpp"
+#include "CbcSOS.hpp"
+#include "CbcSimpleInteger.hpp"
+#include "CbcNWay.hpp"
+#include "CbcSimpleIntegerPseudoCost.hpp"
+#include "CbcBranchDefaultDecision.hpp"
+#include "CbcFollowOn.hpp"
+#include "CbcFixVariable.hpp"
+#include "CbcDummyBranchingObject.hpp"
+#include "CbcGeneral.hpp"
+#include "CbcGeneralDepth.hpp"
+#include "CbcSubProblem.hpp"
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

mipster-0.2.0.data/purelib/mipster/mipster_dist/include/mipster/CbcBranchAllDifferent.hpp

@@ -0,0 +1,60 @@
+// 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).
+
+// Edwin 11/13/2009-- carved out of CbcBranchCut
+
+#ifndef CbcBranchAllDifferent_H
+#define CbcBranchAllDifferent_H
+
+#include "CbcBranchBase.hpp"
+#include "OsiRowCut.hpp"
+#include "CoinPackedMatrix.hpp"
+#include "CbcBranchCut.hpp"
+
+/** Define a branch class that branches so that it is only satsified if all
+    members have different values
+    So cut is x <= y-1 or x >= y+1
+*/
+
+class CBCLIB_EXPORT CbcBranchAllDifferent : public CbcBranchCut {
+
+public:
+  // Default Constructor
+  CbcBranchAllDifferent();
+
+  /** Useful constructor - passed set of integer variables which must all be different
+    */
+  CbcBranchAllDifferent(CbcModel *model, int number, const int *which);
+
+  // Copy constructor
+  CbcBranchAllDifferent(const CbcBranchAllDifferent &);
+
+  /// Clone
+  virtual CbcObject *clone() const;
+
+  // Assignment operator
+  CbcBranchAllDifferent &operator=(const CbcBranchAllDifferent &rhs);
+
+  // Destructor
+  ~CbcBranchAllDifferent();
+
+  /// Infeasibility - large is 0.5
+  virtual double infeasibility(const OsiBranchingInformation *info,
+    int &preferredWay) const;
+
+  /// Creates a branching object
+  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way);
+
+protected:
+  /// data
+
+  /// Number of entries
+  int numberInSet_;
+  /// Which variables
+  int *which_;
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

mipster-0.2.0.data/purelib/mipster/mipster_dist/include/mipster/CbcBranchBase.hpp

@@ -0,0 +1,79 @@
+// 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 CbcBranchBase_H
+#define CbcBranchBase_H
+
+#include <string>
+#include <vector>
+#include "OsiBranchingObject.hpp"
+
+enum CbcRangeCompare {
+  CbcRangeSame,
+  CbcRangeDisjoint,
+  CbcRangeSubset,
+  CbcRangeSuperset,
+  CbcRangeOverlap
+};
+
+#include "CbcConfig.h"
+#include "CbcObject.hpp"
+#include "CbcBranchingObject.hpp"
+#include "CbcBranchDecision.hpp"
+#include "CbcConsequence.hpp"
+#include "CbcObjectUpdateData.hpp"
+
+//##############################################################################
+
+/** Compare two ranges. The two bounds arrays are both of size two and
+    describe closed intervals. Return the appropriate CbcRangeCompare value
+    (first argument being the sub/superset if that's the case). In case of
+    overlap (and if \c replaceIfOverlap is true) replace the content of thisBd
+    with the intersection of the ranges.
+*/
+static inline CbcRangeCompare
+CbcCompareRanges(double *thisBd, const double *otherBd,
+  const bool replaceIfOverlap)
+{
+  const double lbDiff = thisBd[0] - otherBd[0];
+  if (lbDiff < 0) { // lb of this < lb of other
+    if (thisBd[1] >= otherBd[1]) { // ub of this >= ub of other
+      return CbcRangeSuperset;
+    } else if (thisBd[1] < otherBd[0]) {
+      return CbcRangeDisjoint;
+    } else {
+      // overlap
+      if (replaceIfOverlap) {
+        thisBd[0] = otherBd[0];
+      }
+      return CbcRangeOverlap;
+    }
+  } else if (lbDiff > 0) { // lb of this > lb of other
+    if (thisBd[1] <= otherBd[1]) { // ub of this <= ub of other
+      return CbcRangeSubset;
+    } else if (thisBd[0] > otherBd[1]) {
+      return CbcRangeDisjoint;
+    } else {
+      // overlap
+      if (replaceIfOverlap) {
+        thisBd[1] = otherBd[1];
+      }
+      return CbcRangeOverlap;
+    }
+  } else { // lb of this == lb of other
+    if (thisBd[1] == otherBd[1]) {
+      return CbcRangeSame;
+    }
+    return thisBd[1] < otherBd[1] ? CbcRangeSubset : CbcRangeSuperset;
+  }
+
+  return CbcRangeSame; // fake return
+}
+
+//#############################################################################
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/