pygambit 16.2.2__tar.gz → 16.3.1__tar.gz

{pygambit-16.2.2/src/pygambit.egg-info → pygambit-16.3.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pygambit
-Version: 16.2.2
+Version: 16.3.1
 Summary: The package for computation in game theory
-Home-page: http://www.gambit-project.org
+Home-page: https://www.gambit-project.org
 Author: Theodore Turocy
 Author-email: ted.turocy@gmail.com
 License: GPL2+
@@ -13,17 +13,15 @@ Keywords: game theory Nash equilibrium
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 License-File: COPYING
 License-File: AUTHORS
-Requires-Dist: lxml
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: deprecated

{pygambit-16.2.2 → pygambit-16.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools", "wheel", "Cython"]
 [tool.ruff]
 line-length = 99
 indent-width = 4
-target-version = "py38"
+target-version = "py39"
 include = ["setup.py", "src/pygambit/**/*.py", "tests/**/*.py"]
 exclude = ["contrib/**.py"]
 

{pygambit-16.2.2 → pygambit-16.3.1}/setup.py

@@ -1,6 +1,6 @@
 #
 # This file is part of Gambit
-# Copyright (c) 1994-2025, The Gambit Project (http://www.gambit-project.org)
+# Copyright (c) 1994-2025, The Gambit Project (https://www.gambit-project.org)
 #
 # FILE: src/python/setup.py
 # Setuptools configuration file for Gambit Python extension
@@ -26,29 +26,67 @@ import platform
 import Cython.Build
 import setuptools
 
-# By compiling this separately as a C library, we avoid problems
-# with passing C++-specific flags when building the extension
-lrslib = ("lrslib", {"sources": glob.glob("src/solvers/lrs/*.c")})
+cppgambit_include_dirs = ["src"]
+cppgambit_cflags = (
+    ["-std=c++17"] if platform.system() == "Darwin"
+    else ["/std:c++17"] if platform.system() == "Windows"
+    else []
+)
+
+cppgambit_core = (
+    "cppgambit_core",
+    {
+        "sources": glob.glob("src/core/*.cc"),
+        "obj_deps": {"": glob.glob("src/core/*.h") + glob.glob("src/core/*.imp")},
+        "include_dirs": cppgambit_include_dirs,
+        "cflags": cppgambit_cflags,
+    }
+)
 
-cppgambit = (
-    "cppgambit",
+cppgambit_games = (
+    "cppgambit_games",
     {
-         "sources": (
-            glob.glob("src/core/*.cc") +
-            glob.glob("src/games/*.cc") +
-            glob.glob("src/games/agg/*.cc") +
-            [fn for fn in glob.glob("src/solvers/*/*.cc") if "enumpoly" not in fn]
-         ),
-         "include_dirs": ["src"],
-         "cflags": (
-             ["-std=c++17"] if platform.system() == "Darwin"
-             else ["/std:c++17"] if platform.system() == "Windows"
-             else []
-         )
+        "sources": glob.glob("src/games/*.cc") + glob.glob("src/games/agg/*.cc"),
+        "obj_deps": {
+            "": (
+                glob.glob("src/core/*.h") + glob.glob("src/core/*.imp") +
+                glob.glob("src/games/*.h") + glob.glob("src/games/*.imp") +
+                glob.glob("src/games/agg/*.h")
+            )
+        },
+        "include_dirs": cppgambit_include_dirs,
+        "cflags": cppgambit_cflags,
     }
 )
 
 
+def solver_library_config(library_name: str, paths: list) -> tuple:
+    return (
+        library_name,
+        {
+            "sources": [fn for solver in paths for fn in glob.glob(f"src/solvers/{solver}/*.cc")],
+            "obj_deps": {
+                "": (
+                    glob.glob("src/core/*.h") + glob.glob("src/games/*.h") +
+                    glob.glob("src/games/agg/*.h") +
+                    [fn for solver in paths for fn in glob.glob(f"src/solvers/{solver}/*.h")]
+                )
+            },
+            "include_dirs": cppgambit_include_dirs,
+            "cflags": cppgambit_cflags,
+        }
+    )
+
+
+cppgambit_bimatrix = solver_library_config("cppgambit_bimatrix",
+                                           ["linalg", "lp", "lcp", "enummixed"])
+cppgambit_liap = solver_library_config("cppgambit_liap", ["liap"])
+cppgambit_logit = solver_library_config("cppgambit_logit", ["logit"])
+cppgambit_gtracer = solver_library_config("cppgambit_gtracer", ["gtracer", "ipa", "gnm"])
+cppgambit_simpdiv = solver_library_config("cppgambit_simpdiv", ["simpdiv"])
+cppgambit_enumpoly = solver_library_config("cppgambit_enumpoly", ["nashsupport", "enumpoly"])
+
+
 libgambit = setuptools.Extension(
     "pygambit.gambit",
     sources=["src/pygambit/gambit.pyx"],
@@ -69,14 +107,13 @@ def readme():
 
 setuptools.setup(
     name="pygambit",
-    version="16.2.2",
+    version="16.3.1",
     description="The package for computation in game theory",
     long_description=readme(),
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Science/Research",
         "License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
@@ -88,20 +125,21 @@ setuptools.setup(
     license="GPL2+",
     author="Theodore Turocy",
     author_email="ted.turocy@gmail.com",
-    url="http://www.gambit-project.org",
+    url="https://www.gambit-project.org",
     project_urls={
         "Documentation": "https://gambitproject.readthedocs.io/",
         "Source": "https://github.com/gambitproject/gambit",
         "Tracker": "https://github.com/gambitproject/gambit/issues",
     },
-    python_requires=">=3.8",
+    python_requires=">=3.9",
     install_requires=[
-        "lxml",  # used for reading/writing GTE files
         "numpy",
         "scipy",
         "deprecated",
     ],
-    libraries=[cppgambit, lrslib],
+    libraries=[cppgambit_bimatrix, cppgambit_liap, cppgambit_logit, cppgambit_simpdiv,
+               cppgambit_gtracer, cppgambit_enumpoly,
+               cppgambit_games, cppgambit_core],
     package_dir={"": "src"},
     packages=["pygambit"],
     ext_modules=Cython.Build.cythonize(libgambit,

pygambit-16.3.1/src/core/array.h

@@ -0,0 +1,285 @@
+//
+// This file is part of Gambit
+// Copyright (c) 1994-2025, The Gambit Project (https://www.gambit-project.org)
+//
+// FILE: src/libgambit/array.h
+// A basic bounds-checked array type
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+
+#ifndef LIBGAMBIT_ARRAY_H
+#define LIBGAMBIT_ARRAY_H
+
+#include <vector>
+#include <iterator>
+
+namespace Gambit {
+
+/// \brief An extension of std::vector to have arbitrary offset index
+///
+/// This is a variation on std::vector, which allows for the index of the first
+/// element to be something other than zero.
+template <class T> class Array {
+protected:
+  int m_offset, m_length;
+  T *m_data;
+
+  int InsertAt(const T &t, int n)
+  {
+    if (this->m_offset > n || n > this->last_index() + 1) {
+      throw IndexException();
+    }
+
+    T *new_data = new T[++this->m_length] - this->m_offset;
+
+    int i;
+    for (i = this->m_offset; i <= n - 1; i++) {
+      new_data[i] = this->m_data[i];
+    }
+    new_data[i++] = t;
+    for (; i <= this->last_index(); i++) {
+      new_data[i] = this->m_data[i - 1];
+    }
+
+    if (this->m_data) {
+      delete[] (this->m_data + this->m_offset);
+    }
+    this->m_data = new_data;
+
+    return n;
+  }
+
+  T Remove(int n)
+  {
+    if (n < this->m_offset || n > this->last_index()) {
+      throw IndexException();
+    }
+
+    T ret(this->m_data[n]);
+    T *new_data = (--this->m_length > 0) ? new T[this->m_length] - this->m_offset : nullptr;
+
+    int i;
+    for (i = this->m_offset; i < n; i++) {
+      new_data[i] = this->m_data[i];
+    }
+    for (; i <= this->last_index(); i++) {
+      new_data[i] = this->m_data[i + 1];
+    }
+
+    delete[] (this->m_data + this->m_offset);
+    this->m_data = new_data;
+
+    return ret;
+  }
+
+public:
+  class iterator {
+    friend class Array;
+
+  private:
+    Array *m_array;
+    int m_index;
+
+  public:
+    using iterator_category = std::bidirectional_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = T;
+    using pointer = value_type *;
+    using reference = value_type &;
+
+    iterator(Array *p_array = 0, int p_index = 0) : m_array(p_array), m_index(p_index) {}
+    reference operator*() { return (*m_array)[m_index]; }
+    pointer operator->() { return &(*m_array)[m_index]; }
+    iterator &operator++()
+    {
+      m_index++;
+      return *this;
+    }
+    iterator &operator--()
+    {
+      m_index--;
+      return *this;
+    }
+    iterator operator++(int)
+    {
+      auto ret = *this;
+      m_index++;
+      return ret;
+    }
+    bool operator==(const iterator &it) const
+    {
+      return (m_array == it.m_array) && (m_index == it.m_index);
+    }
+    bool operator!=(const iterator &it) const { return !(*this == it); }
+  };
+
+  class const_iterator {
+    friend class Array;
+
+  private:
+    const Array *m_array;
+    int m_index;
+
+  public:
+    using iterator_category = std::bidirectional_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = T;
+    using pointer = value_type *;
+    using reference = value_type &;
+
+    const_iterator(const Array *p_array, int p_index) : m_array(p_array), m_index(p_index) {}
+    const T &operator*() const { return (*m_array)[m_index]; }
+    const T &operator->() const { return (*m_array)[m_index]; }
+    const_iterator &operator++()
+    {
+      m_index++;
+      return *this;
+    }
+    const_iterator &operator--()
+    {
+      m_index--;
+      return *this;
+    }
+    const_iterator operator++(int)
+    {
+      auto ret = *this;
+      m_index++;
+      return ret;
+    }
+    bool operator==(const const_iterator &it) const
+    {
+      return (m_array == it.m_array) && (m_index == it.m_index);
+    }
+    bool operator!=(const const_iterator &it) const { return !(*this == it); }
+  };
+
+  explicit Array(unsigned int len = 0)
+    : m_offset(1), m_length(len), m_data((len) ? new T[len] - 1 : nullptr)
+  {
+  }
+  Array(int lo, int hi) : m_offset(lo), m_length(hi - lo + 1)
+  {
+    if (m_length < 0) {
+      throw RangeException();
+    }
+    m_data = (m_length > 0) ? new T[m_length] - m_offset : nullptr;
+  }
+  Array(const Array<T> &a)
+    : m_offset(a.m_offset), m_length(a.m_length),
+      m_data((m_length > 0) ? new T[m_length] - m_offset : nullptr)
+  {
+    for (int i = m_offset; i <= last_index(); i++) {
+      m_data[i] = a.m_data[i];
+    }
+  }
+  virtual ~Array()
+  {
+    if (m_length > 0) {
+      delete[] (m_data + m_offset);
+    }
+  }
+
+  Array<T> &operator=(const Array<T> &a)
+  {
+    if (this != &a) {
+      // We only reallocate if necessary.
+      if (!m_data || (m_data && (m_offset != a.m_offset || m_length != a.m_length))) {
+        if (m_data) {
+          delete[] (m_data + m_offset);
+        }
+        m_offset = a.m_offset;
+        m_length = a.m_length;
+        m_data = (m_length > 0) ? new T[m_length] - m_offset : nullptr;
+      }
+
+      for (int i = m_offset; i <= last_index(); i++) {
+        m_data[i] = a.m_data[i];
+      }
+    }
+
+    return *this;
+  }
+
+  bool operator==(const Array<T> &a) const
+  {
+    if (m_offset != a.m_offset || m_length != a.m_length) {
+      return false;
+    }
+    for (int i = m_offset; i <= last_index(); i++) {
+      if ((*this)[i] != a[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool operator!=(const Array<T> &a) const { return !(*this == a); }
+
+  const T &operator[](int index) const
+  {
+    if (index < m_offset || index > last_index()) {
+      throw IndexException();
+    }
+    return m_data[index];
+  }
+
+  T &operator[](int index)
+  {
+    if (index < m_offset || index > last_index()) {
+      throw IndexException();
+    }
+    return m_data[index];
+  }
+  const T &front() const { return m_data[m_offset]; }
+  T &front() { return m_data[m_offset]; }
+  const T &back() const { return m_data[last_index()]; }
+  T &back() { return m_data[last_index()]; }
+
+  iterator begin() { return {this, m_offset}; }
+  const_iterator begin() const { return {this, m_offset}; }
+  iterator end() { return {this, m_offset + m_length}; }
+  const_iterator end() const { return {this, m_offset + m_length}; }
+  const_iterator cbegin() const { return {this, m_offset}; }
+  const_iterator cend() const { return {this, m_offset + m_length}; }
+
+  bool empty() const { return this->m_length == 0; }
+  size_t size() const { return m_length; }
+  int first_index() const { return m_offset; }
+  int last_index() const { return m_offset + m_length - 1; }
+
+  void clear()
+  {
+    if (m_length > 0) {
+      delete[] (m_data + m_offset);
+    }
+    m_data = nullptr;
+    m_length = 0;
+  }
+  void insert(const_iterator pos, const T &value) { InsertAt(value, pos.m_index); }
+  void erase(iterator pos) { Remove(pos.m_index); }
+  void push_back(const T &val) { InsertAt(val, this->last_index() + 1); }
+  void pop_back() { Remove(last_index()); }
+};
+
+/// Convenience function to erase the element at `p_index`
+template <class T> void erase_atindex(Array<T> &p_array, int p_index)
+{
+  p_array.erase(std::next(p_array.begin(), p_index - p_array.first_index()));
+}
+
+} // end namespace Gambit
+
+#endif // LIBGAMBIT_ARRAY_H

{pygambit-16.2.2 → pygambit-16.3.1}/src/core/function.cc

@@ -46,7 +46,7 @@ using namespace Gambit;
 void FunctionOnSimplices::Project(Vector<double> &x, const Array<int> &lengths) const
 {
   int index = 1;
-  for (int part = 1; part <= lengths.Length(); part++) {
+  for (int part = 1; part <= lengths.size(); part++) {
     double avg = 0.0;
     int j;
     for (j = 1; j <= lengths[part]; j++, index++) {
@@ -70,7 +70,7 @@ void FunctionOnSimplices::Project(Vector<double> &x, const Array<int> &lengths)
 
 void ConjugatePRMinimizer::AlphaXPlusY(double alpha, const Vector<double> &x, Vector<double> &y)
 {
-  for (int i = 1; i <= y.Length(); i++) {
+  for (int i = 1; i <= y.size(); i++) {
     y[i] += alpha * x[i];
   }
 }
@@ -330,7 +330,7 @@ bool ConjugatePRMinimizer::Iterate(const Function &fdf, Vector<double> &x, doubl
   x = x2;
 
   /* Choose a new conjugate direction for the next step */
-  iter = (iter + 1) % x.Length();
+  iter = (iter + 1) % x.size();
 
   if (iter == 0) {
     p = gradient;

pygambit-16.3.1/src/core/list.h

@@ -0,0 +1,132 @@
+//
+// This file is part of Gambit
+// Copyright (c) 1994-2025, The Gambit Project (https://www.gambit-project.org)
+//
+// FILE: src/libgambit/list.h
+// A generic linked-list container class
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+
+#ifndef LIBGAMBIT_LIST_H
+#define LIBGAMBIT_LIST_H
+
+#include <list>
+
+namespace Gambit {
+
+/// @brief A linked-list container
+///
+/// This is a lightweight wrapper around std::list.  It exists as a transitional
+/// class between Gambit's legacy linked-list implementation Gambit::List and
+/// STL's list.
+///
+/// Gambit's List container supported the index operator [], which is not defined
+/// on STL lists.  Therefore this class provides such an operator by wrapping
+/// an appropriate iterator-based operation.  This is very inefficient!  However,
+/// the [] operator and indexing is tightly embedded in the remaining uses of this
+/// class, so this operator provides a refactoring path while the remaining uses
+/// are rewritten.
+///
+/// Note importantly that the index operator [] is **1-based** - that is, the first
+/// element of the list is 1, not 0.
+template <class T> class List {
+private:
+  std::list<T> m_list;
+
+public:
+  using iterator = typename std::list<T>::iterator;
+  using const_iterator = typename std::list<T>::const_iterator;
+  using value_type = typename std::list<T>::value_type;
+  using size_type = typename std::list<T>::size_type;
+
+  List() = default;
+  List(const List<T> &) = default;
+  ~List() = default;
+
+  List<T> &operator=(const List<T> &) = default;
+
+  const T &operator[](size_type p_index) const
+  {
+    if (p_index < 1 || p_index > m_list.size()) {
+      throw IndexException();
+    }
+    return *std::next(m_list.cbegin(), p_index - 1);
+  }
+
+  T &operator[](size_type p_index)
+  {
+    if (p_index < 1 || p_index > m_list.size()) {
+      throw IndexException();
+    }
+    return *std::next(m_list.begin(), p_index - 1);
+  }
+
+  /// @name STL-style interface
+  ///
+  /// These operations forward STL-type operations to the underlying list.
+  /// This does not provide all operations on std::list, only ones used in
+  /// existing code.  Rather than adding new functions here, existing code
+  /// should be rewritten to use std::list directly.
+  ///@{
+  /// Return whether the list container is empty (has size 0).
+  bool empty() const { return m_list.empty(); }
+  /// Return the number of elements in the list container.
+  size_type size() const { return m_list.size(); }
+  /// Adds a new element at the beginning of the list container
+  void push_front(const T &val) { m_list.push_front(val); }
+  /// Adds a new element at the end of the list container, after its
+  /// current last element.
+  void push_back(const T &val) { m_list.push_back(val); }
+  /// Removes the last element
+  void pop_back() { m_list.pop_back(); }
+  /// Inserts the value at the specified position
+  void insert(iterator pos, const T &value) { m_list.insert(pos, value); }
+  /// Erases the element at the specified position
+  void erase(iterator pos) { m_list.erase(pos); }
+
+  /// Removes all elements from the list container (which are destroyed),
+  /// leaving the container with a size of 0.
+  void clear() { m_list.clear(); }
+  /// Returns a reference to the first element in the list container.
+  T &front() { return m_list.front(); }
+  /// Returns a reference to the first element in the list container.
+  const T &front() const { return m_list.front(); }
+  /// Returns a reference to the last element in the list container.
+  T &back() { return m_list.back(); }
+  /// Returns a reference to the last element in the list container.
+  const T &back() const { return m_list.back(); }
+
+  bool operator==(const List<T> &b) const { return m_list == b.m_list; }
+  bool operator!=(const List<T> &b) const { return m_list != b.m_list; }
+
+  /// Return a forward iterator starting at the beginning of the list
+  iterator begin() { return m_list.begin(); }
+  /// Return a forward iterator past the end of the list
+  iterator end() { return m_list.end(); }
+  /// Return a const forward iterator starting at the beginning of the list
+  const_iterator begin() const { return m_list.begin(); }
+  /// Return a const forward iterator past the end of the list
+  const_iterator end() const { return m_list.end(); }
+  /// Return a const forward iterator starting at the beginning of the list
+  const_iterator cbegin() const { return m_list.cbegin(); }
+  /// Return a const forward iterator past the end of the list
+  const_iterator cend() const { return m_list.cend(); }
+  ///@}
+};
+
+} // namespace Gambit
+
+#endif // LIBGAMBIT_LIST_H

{pygambit-16.2.2 → pygambit-16.3.1}/src/core/matrix.imp

@@ -169,7 +169,7 @@ template <class T> void Matrix<T>::CMultiply(const Vector<T> &in, Vector<T> &out
     T sum = (T)0;
 
     T *src1 = this->data[i] + this->mincol;
-    T *src2 = in.data + this->mincol;
+    auto src2 = in.begin();
     int j = this->maxcol - this->mincol + 1;
     while (j--) {
       sum += *(src1++) * *(src2++);
@@ -217,7 +217,7 @@ template <class T> void Matrix<T>::RMultiply(const Vector<T> &in, Vector<T> &out
     T k = in[i];
 
     T *src = this->data[i] + this->mincol;
-    T *dst = out.data + this->mincol;
+    auto dst = out.begin();
     int j = this->maxcol - this->mincol + 1;
     while (j--) {
       *(dst++) += *(src++) * k;

{pygambit-16.2.2 → pygambit-16.3.1}/src/core/rational.cc

@@ -401,6 +401,8 @@ Rational::Rational(long n) : num(n), den(&OneRep) {}
 
 Rational::Rational(int n) : num(n), den(&OneRep) {}
 
+Rational::Rational(size_t n) : num(int(n)), den(&OneRep) {}
+
 Rational::Rational(long n, long d) : num(n), den(d)
 {
   if (d == 0) {
@@ -437,8 +439,6 @@ bool Rational::operator>(const Rational &y) const { return compare(*this, y) > 0
 
 bool Rational::operator>=(const Rational &y) const { return compare(*this, y) >= 0; }
 
-int sign(const Rational &x) { return sign(x.num); }
-
 void Rational::negate() { num.negate(); }
 
 Rational &Rational::operator+=(const Rational &y)

{pygambit-16.2.2 → pygambit-16.3.1}/src/core/rational.h

@@ -44,6 +44,7 @@ public:
   Rational();
   explicit Rational(double);
   explicit Rational(int);
+  explicit Rational(size_t);
   explicit Rational(long n);
   Rational(int n, int d);
   Rational(long n, long d);
@@ -115,6 +116,8 @@ public:
 // Naming compatible with Boost's lexical_cast concept for potential future compatibility.
 template <> Rational lexical_cast(const std::string &);
 
+inline int sign(const Rational &x) { return sign(x.num); }
+
 } // end namespace Gambit
 
 #endif // LIBGAMBIT_RATIONAL_H