pygambit 16.3.2__tar.gz → 16.4.1__tar.gz

{pygambit-16.3.2/src/pygambit.egg-info → pygambit-16.4.1}/PKG-INFO

@@ -1,42 +1,31 @@
 Metadata-Version: 2.4
 Name: pygambit
-Version: 16.3.2
+Version: 16.4.1
 Summary: The package for computation in game theory
-Home-page: https://www.gambit-project.org
-Author: Theodore Turocy
-Author-email: ted.turocy@gmail.com
-License: GPL2+
-Project-URL: Documentation, https://gambitproject.readthedocs.io/
-Project-URL: Source, https://github.com/gambitproject/gambit
-Project-URL: Tracker, https://github.com/gambitproject/gambit/issues
-Keywords: game theory Nash equilibrium
+Author-email: Theodore Turocy <ted.turocy@gmail.com>, Rahul Savani <rahul.savani@liverpool.ac.uk>
+License-Expression: GPL-2.0-or-later
+Project-URL: Homepage, https://www.gambit-project.org
+Project-URL: Documentation, https://gambitproject.readthedocs.io
+Project-URL: Repository, https://github.com/gambitproject/gambit.git
+Project-URL: Issues, https://github.com/gambitproject/gambit/issues
+Project-URL: Changelog, https://github.com/gambitproject/gambit/blob/master/ChangeLog
+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.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
 License-File: COPYING
 License-File: AUTHORS
 Requires-Dist: numpy
 Requires-Dist: scipy
-Requires-Dist: deprecated
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
 Dynamic: license-file
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 Gambit is a package for representing, manuipulating, and analysing
 finite noncooperative games in extensive and normal form.

{pygambit-16.3.2 → pygambit-16.4.1}/README.md

@@ -13,6 +13,9 @@
 
 **Gambit** is the package for doing computation in (non-cooperative) game theory.
 
+- See our [documentation](https://gambitproject.readthedocs.io/)
+- Check our [project website](https://www.gambit-project.org/)
+
 Gambit provides:
 
 - Structures to represent games in extensive and strategic form

pygambit-16.4.1/pyproject.toml

@@ -0,0 +1,85 @@
+[build-system]
+requires = ["setuptools", "wheel", "Cython"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pygambit"
+version = "16.4.1"
+description = "The package for computation in game theory"
+readme = "src/README.rst"
+requires-python = ">=3.9"
+license = "GPL-2.0-or-later"
+authors = [
+    {name = "Theodore Turocy", email = "ted.turocy@gmail.com"},
+    {name = "Rahul Savani", email = "rahul.savani@liverpool.ac.uk"}
+]
+keywords = ["game theory", "Nash equilibrium"]
+classifiers=[
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Scientific/Engineering :: Mathematics"
+]
+dependencies = [
+    "numpy",
+    "scipy",
+]
+
+[project.urls]
+Homepage = "https://www.gambit-project.org"
+Documentation = "https://gambitproject.readthedocs.io"
+Repository = "https://github.com/gambitproject/gambit.git"
+Issues = "https://github.com/gambitproject/gambit/issues"
+Changelog = "https://github.com/gambitproject/gambit/blob/master/ChangeLog"
+
+
+[tool.ruff]
+line-length = 99
+indent-width = 4
+target-version = "py39"
+include = ["setup.py", "src/pygambit/**/*.py", "tests/**/*.py"]
+exclude = ["contrib/**.py"]
+
+[tool.ruff.lint]
+select = [
+    "E", # pycodestyle
+    "F", # pyflakes
+    "UP", # pyupgrade
+    "B", # flake8-bugbear
+    "SIM", # flake8-simplify
+    "I", # isort
+    "Q", # prefer double quotes
+]
+ignore = []
+
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+
+[tool.cython-lint]
+max-line-length = 99
+
+
+[tool.pytest.ini_options]
+addopts = "--strict-markers"
+markers = [
+    "nash_enummixed_strategy: tests of enummixed_solve in strategies",
+    "nash_lcp_strategy: tests of lcp_solve in strategies",
+    "nash_lcp_behavior: tests of lcp_solve in behaviors",
+    "nash_lp_strategy: tests of lp_solve in strategies",
+    "nash_lp_behavior: tests of lp_solve in behaviors",
+    "nash: all tests of Nash equilibrium solvers",
+    "slow: all time-consuming tests",
+]

{pygambit-16.3.2 → pygambit-16.4.1}/setup.py

@@ -99,44 +99,7 @@ libgambit = setuptools.Extension(
     )
 )
 
-
-def readme():
-    with open("src/README.rst") as f:
-        return f.read()
-
-
 setuptools.setup(
-    name="pygambit",
-    version="16.3.2",
-    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.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
-        "Programming Language :: Python :: Implementation :: CPython",
-        "Topic :: Scientific/Engineering :: Mathematics"
-    ],
-    keywords="game theory Nash equilibrium",
-    license="GPL2+",
-    author="Theodore Turocy",
-    author_email="ted.turocy@gmail.com",
-    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.9",
-    install_requires=[
-        "numpy",
-        "scipy",
-        "deprecated",
-    ],
     libraries=[cppgambit_bimatrix, cppgambit_liap, cppgambit_logit, cppgambit_simpdiv,
                cppgambit_gtracer, cppgambit_enumpoly,
                cppgambit_games, cppgambit_core],

pygambit-16.4.1/src/core/array.h

@@ -0,0 +1,106 @@
+//
+// This file is part of Gambit
+// Copyright (c) 1994-2025, The Gambit Project (https://www.gambit-project.org)
+//
+// FILE: src/core/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 GAMBIT_CORE_ARRAY_H
+#define GAMBIT_CORE_ARRAY_H
+
+#include <vector>
+#include <iterator>
+
+#include "util.h"
+
+namespace Gambit {
+
+/// An extension of std::vector with an 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;
+  std::vector<T> m_data;
+
+public:
+  using iterator = typename std::vector<T>::iterator;
+  using const_iterator = typename std::vector<T>::const_iterator;
+  using reference = typename std::vector<T>::reference;
+  using const_reference = typename std::vector<T>::const_reference;
+
+  explicit Array(size_t len = 0) : m_offset(1), m_data(len) {}
+  Array(int lo, int hi) : m_offset(lo), m_data(hi - lo + 1) {}
+  Array(const Array<T> &) = default;
+  ~Array() = default;
+
+  Array<T> &operator=(const Array<T> &) = default;
+
+  bool operator==(const Array<T> &a) const { return m_offset == a.m_offset && m_data == a.m_data; }
+
+  bool operator!=(const Array<T> &a) const { return m_offset != a.m_offset || m_data != a.m_data; }
+
+  const_reference operator[](int index) const
+  {
+    if (index < m_offset || index > back_index()) {
+      throw std::out_of_range("Index out of range in Array");
+    }
+    return m_data.at(index - m_offset);
+  }
+
+  reference operator[](int index)
+  {
+    if (index < m_offset || index > back_index()) {
+      throw std::out_of_range("Index out of range in Array");
+    }
+    return m_data[index - m_offset];
+  }
+  const T &front() const { return m_data.front(); }
+  T &front() { return m_data.front(); }
+  const T &back() const { return m_data.back(); }
+  T &back() { return m_data.back(); }
+
+  iterator begin() { return m_data.begin(); }
+  const_iterator begin() const { return m_data.begin(); }
+  iterator end() { return m_data.end(); }
+  const_iterator end() const { return m_data.end(); }
+  const_iterator cbegin() const { return m_data.cbegin(); }
+  const_iterator cend() const { return m_data.cend(); }
+
+  bool empty() const { return m_data.empty(); }
+  size_t size() const { return m_data.size(); }
+  int front_index() const { return m_offset; }
+  int back_index() const { return m_offset + m_data.size() - 1; }
+
+  void clear() { m_data.clear(); }
+  void insert(const_iterator pos, const T &value) { m_data.insert(pos, value); }
+  void erase(iterator pos) { m_data.erase(pos); }
+  void push_back(const T &value) { m_data.push_back(value); }
+  void pop_back() { m_data.pop_back(); }
+};
+
+/// 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.front_index()));
+}
+
+} // end namespace Gambit
+
+#endif // GAMBIT_CORE_ARRAY_H

pygambit-16.4.1/src/core/core.h

@@ -0,0 +1,34 @@
+//
+// This file is part of Gambit
+// Copyright (c) 1994-2025, The Gambit Project (https://www.gambit-project.org)
+//
+// FILE: src/core/core.h
+// Core (game theory-independent) declarations and utilities for Gambit
+//
+// 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 GAMBIT_CORE_CORE_H
+#define GAMBIT_CORE_CORE_H
+
+#include "util.h"
+#include "array.h"
+#include "list.h"
+#include "recarray.h"
+#include "vector.h"
+#include "matrix.h"
+#include "rational.h"
+
+#endif // GAMBIT_CORE_CORE_H

{pygambit-16.3.2 → pygambit-16.4.1}/src/core/function.cc

@@ -2,7 +2,7 @@
 // This file is part of Gambit
 // Copyright (c) 1994-2025, The Gambit Project (https://www.gambit-project.org)
 //
-// FILE: src/libgambit/function.cc
+// FILE: src/core/function.cc
 // Implementation of function and function minimization routines
 //
 // These routines derive from the N-dimensional function minimization
@@ -28,7 +28,7 @@
 //
 
 #include <cmath>
-#include "gambit.h"
+
 #include "function.h"
 
 using namespace Gambit;
@@ -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.size(); part++) {
+  for (size_t 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.size(); i++) {
+  for (size_t i = 1; i <= y.size(); i++) {
     y[i] += alpha * x[i];
   }
 }
@@ -96,7 +96,7 @@ void ConjugatePRMinimizer::IntermediatePoint(const Function &fdf, const Vector<d
   double stepb, fb;
 
 trial:
-  double u = fabs(pg * lambda * stepc);
+  const double u = fabs(pg * lambda * stepc);
   if ((fc - fa) + u == 0) {
     // TLT: Added this check 2002/08/31 due to floating point exceptions
     // under MSW.  Not really sure how to handle this correctly.
@@ -160,12 +160,12 @@ mid_trial:
     return; /* MAX ITERATIONS */
   }
 
-  double dw = w - u;
-  double dv = v - u;
+  const double dw = w - u;
+  const double dv = v - u;
   double du = 0.0;
 
-  double e1 = ((fv - fu) * dw * dw + (fu - fw) * dv * dv);
-  double e2 = 2.0 * ((fv - fu) * dw + (fu - fw) * dv);
+  const double e1 = ((fv - fu) * dw * dw + (fu - fw) * dv * dv);
+  const double e2 = 2.0 * ((fv - fu) * dw + (fu - fw) * dv);
 
   if (e2 != 0.0) {
     du = e1 / e2;
@@ -272,7 +272,7 @@ void ConjugatePRMinimizer::Set(const Function &fdf, const Vector<double> &x, dou
   p = gradient;
   g0 = gradient;
 
-  double gnorm = std::sqrt(gradient.NormSquared());
+  const double gnorm = std::sqrt(gradient.NormSquared());
   pnorm = gnorm;
   g0norm = gnorm;
 }
@@ -282,9 +282,12 @@ void ConjugatePRMinimizer::Restart() { iter = 0; }
 bool ConjugatePRMinimizer::Iterate(const Function &fdf, Vector<double> &x, double &f,
                                    Vector<double> &gradient, Vector<double> &dx)
 {
-  double fa = f, fb, fc;
+  const double fa = f;
+  double fb, fc;
   double dir;
-  double stepa = 0.0, stepb, stepc = step, tol = m_tol;
+  const double stepa = 0.0;
+  double stepb;
+  const double stepc = step, tol = m_tol;
 
   double g1norm;
   double pg;

{pygambit-16.3.2 → pygambit-16.4.1}/src/core/function.h

@@ -2,7 +2,7 @@
 // This file is part of Gambit
 // Copyright (c) 1994-2025, The Gambit Project (https://www.gambit-project.org)
 //
-// FILE: src/libgambit/function.h
+// FILE: src/core/function.h
 // Interface to function and function minimization routines
 //
 // This program is free software; you can redistribute it and/or modify
@@ -20,10 +20,10 @@
 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 //
 
-#ifndef LIBGAMBIT_FUNCTION_H
-#define LIBGAMBIT_FUNCTION_H
+#ifndef GAMBIT_CORE_FUNCTION_H
+#define GAMBIT_CORE_FUNCTION_H
 
-#include "core/vector.h"
+#include "vector.h"
 
 namespace Gambit {
 
@@ -45,10 +45,10 @@ protected:
   void Project(Vector<double> &x, const Array<int> &lengths) const;
 };
 
-class FunctionMinimizerError : public Exception {
+class FunctionMinimizerError : public std::runtime_error {
 public:
+  FunctionMinimizerError() : std::runtime_error("Internal error in function minimization") {}
   ~FunctionMinimizerError() noexcept override = default;
-  const char *what() const noexcept override { return "Internal error in function minimization"; }
 };
 
 // An abstract base class for function minimization
@@ -106,4 +106,4 @@ private:
 
 } // end namespace Gambit
 
-#endif // LIBGAMBIT_FUNCTION_H
+#endif // GAMBIT_CORE_FUNCTION_H