game-resolver-cpp 0.1.0__tar.gz → 0.1.1__tar.gz

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.21)
-project(game_resolver_cpp VERSION 0.1.0 LANGUAGES CXX)
+project(game_resolver_cpp VERSION 0.1.1 LANGUAGES CXX)
 
 option(GAME_RESOLVER_BUILD_TESTS "Build the test suite" ${PROJECT_IS_TOP_LEVEL})
 option(GAME_RESOLVER_BUILD_EXAMPLES "Build the example programs" ${PROJECT_IS_TOP_LEVEL})

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: game_resolver_cpp
-Version: 0.1.0
+Version: 0.1.1
 Summary: C++ backed game equilibrium solver with the game_resolver interface
 Keywords: game-theory,nash-equilibrium,bayesian-game
 Author: nishino-lab
@@ -78,7 +78,11 @@ All four ways of defining payoffs work, exactly as in `game_resolver`:
 
 Subclass `BayesianGame` and implement `posterior()`.
 
+A Bayesian battle of the sexes. Each player has a type `A` / `B`, observes their own type,
+and computes the expected payoff with the posterior over the other player's type.
+
 ```python
+import numpy as np
 from game_resolver_cpp.bayesian_game import BayesianGame
 from game_resolver_cpp.bayesian_nash_equilibrium import BayesianNashEquilibrium
 from game_resolver_cpp.bayesian_player import BayesianPlayer
@@ -97,14 +101,32 @@ class SampleGame(BayesianGame):
         other = type_tuple[(player_id + 1) % 2]
         return 1 / 4 if own == other else 3 / 4
 
-    # payoff functions take (own type, each player's action)
-    def male(self, type, male_action, female_action): ...
-    def female(self, type, male_action, female_action): ...
+    # payoff functions take (own type, each player's action), and must return a number
+    def male(self, type, male_action, female_action):
+        if male_action != female_action:
+            return 0.0
+        if type == "A":
+            return 2.0 if male_action == "Boxing" else 1.0
+        return 1.0 if male_action == "Boxing" else 2.0
+
+    def female(self, type, male_action, female_action):
+        if male_action != female_action:
+            return 0.0
+        if type == "A":
+            return 2.0 if female_action == "Boxing" else 1.0
+        return 1.0 if female_action == "Boxing" else 2.0
 
 
 nash = BayesianNashEquilibrium(SampleGame()).get_nash_equilibrium()
+print(nash["index"])       # [(0, 0), (1, 2), (2, 1), (3, 3)]
+print(nash["profile"][0])  # [{'A': 'Boxing', 'B': 'Boxing'}, {'A': 'Boxing', 'B': 'Boxing'}]
+print(nash["payoff"][0])   # [{'A': 2.0, 'B': 1.0}, {'A': 2.0, 'B': 1.0}]
 ```
 
+`profile` and `payoff` are indexed by `[equilibrium][player][type]`. The types and actions
+are handed back exactly as you passed them in, so with `np.array` they print as
+`np.str_('A')`; pass plain lists if you want plain strings.
+
 ## What gets faster
 
 Against the pure Python `game_resolver`, on an 11-core Apple M series machine.

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/README.md

@@ -235,6 +235,8 @@ class SampleGame : public BayesianGame {
 };
 ```
 
+The bodies left out here are in [examples/bayesian_battle_of_sex.cpp](examples/bayesian_battle_of_sex.cpp).
+
 ```cpp
 SampleGame game;
 BayesianNashEquilibrium equilibrium(game);

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/docs/README_for_pypi.md

@@ -48,7 +48,11 @@ All four ways of defining payoffs work, exactly as in `game_resolver`:
 
 Subclass `BayesianGame` and implement `posterior()`.
 
+A Bayesian battle of the sexes. Each player has a type `A` / `B`, observes their own type,
+and computes the expected payoff with the posterior over the other player's type.
+
 ```python
+import numpy as np
 from game_resolver_cpp.bayesian_game import BayesianGame
 from game_resolver_cpp.bayesian_nash_equilibrium import BayesianNashEquilibrium
 from game_resolver_cpp.bayesian_player import BayesianPlayer
@@ -67,14 +71,32 @@ class SampleGame(BayesianGame):
         other = type_tuple[(player_id + 1) % 2]
         return 1 / 4 if own == other else 3 / 4
 
-    # payoff functions take (own type, each player's action)
-    def male(self, type, male_action, female_action): ...
-    def female(self, type, male_action, female_action): ...
+    # payoff functions take (own type, each player's action), and must return a number
+    def male(self, type, male_action, female_action):
+        if male_action != female_action:
+            return 0.0
+        if type == "A":
+            return 2.0 if male_action == "Boxing" else 1.0
+        return 1.0 if male_action == "Boxing" else 2.0
+
+    def female(self, type, male_action, female_action):
+        if male_action != female_action:
+            return 0.0
+        if type == "A":
+            return 2.0 if female_action == "Boxing" else 1.0
+        return 1.0 if female_action == "Boxing" else 2.0
 
 
 nash = BayesianNashEquilibrium(SampleGame()).get_nash_equilibrium()
+print(nash["index"])       # [(0, 0), (1, 2), (2, 1), (3, 3)]
+print(nash["profile"][0])  # [{'A': 'Boxing', 'B': 'Boxing'}, {'A': 'Boxing', 'B': 'Boxing'}]
+print(nash["payoff"][0])   # [{'A': 2.0, 'B': 1.0}, {'A': 2.0, 'B': 1.0}]
 ```
 
+`profile` and `payoff` are indexed by `[equilibrium][player][type]`. The types and actions
+are handed back exactly as you passed them in, so with `np.array` they print as
+`np.str_('A')`; pass plain lists if you want plain strings.
+
 ## What gets faster
 
 Against the pure Python `game_resolver`, on an 11-core Apple M series machine.

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "game_resolver_cpp"
-version = "0.1.0"
+version = "0.1.1"
 description = "C++ backed game equilibrium solver with the game_resolver interface"
 readme = "docs/README_for_pypi.md"
 requires-python = ">=3.9"

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/python/game_resolver_cpp/bayesian_nash_equilibrium.py

@@ -24,7 +24,22 @@ class _CoreBayesianGame(_core.BayesianGame):
         self._game = game
 
     def posterior(self, player_id: int, type_profile) -> float:
-        return float(self._game.posterior(player_id, tuple(type_profile)))
+        types = tuple(type_profile)
+        value = self._game.posterior(player_id, types)
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            # 素の float() のエラーはどの呼び出しで起きたか言わない。return の書き忘れが多い。
+            what = (
+                "何も返しませんでした (None)"
+                if value is None
+                else f"数値でない値 {value!r} を返しました"
+            )
+            raise TypeError(
+                f"{type(self._game).__name__}.posterior() が{what}。"
+                f"引数は (player_id={player_id}, type_tuple={types}) でした。"
+                "事後確率は実数を返してください"
+            ) from None
 
 
 class BayesianNashEquilibrium:

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/python/src/binding.cpp

@@ -94,6 +94,42 @@ PayoffTable to_payoff_table(const py::dict& mapping) {
   return table;
 }
 
+/// 呼び出し可能オブジェクトを、エラーメッセージ用の名前にする。
+std::string describe_callable(const py::handle& function) {
+  if (py::hasattr(function, "__qualname__")) {
+    return py::str(function.attr("__qualname__")).cast<std::string>() + "()";
+  }
+  return py::repr(function).cast<std::string>();
+}
+
+std::string describe_arguments(const py::tuple& arguments) {
+  std::string text;
+  for (std::size_t i = 0; i < arguments.size(); ++i) {
+    if (i != 0) {
+      text += ", ";
+    }
+    text += py::repr(arguments[i]).cast<std::string>();
+  }
+  return text;
+}
+
+/// Python が返した値を利得の実数にする。
+///
+/// pybind11 の素の cast エラーは「NoneType を C++ の型 '?' に変換できません」としか言わず、
+/// どの関数がどの引数で失敗したのか分からない。戻り値の書き忘れが一番多いので、ここで拾う。
+double to_payoff_value(const py::object& result, const py::handle& function,
+                       const py::tuple& arguments) {
+  try {
+    return result.cast<double>();
+  } catch (const py::cast_error&) {
+    const std::string what =
+        result.is_none() ? "何も返しませんでした (None)"
+                         : "数値でない値 " + py::repr(result).cast<std::string>() + " を返しました";
+    throw py::type_error(describe_callable(function) + " が" + what + "。引数は (" +
+                         describe_arguments(arguments) + ") でした。利得関数は実数を返してください");
+  }
+}
+
 /// Python の関数を 1 セルごとに呼ぶ利得関数。
 ///
 /// 1 回の呼び出しにつき Python の呼び出しと引数変換が発生するので、セル数が多いゲームでは
@@ -105,7 +141,7 @@ PayoffFunction to_payoff_function(py::function function) {
     for (std::size_t i = 0; i < profile.size(); ++i) {
       arguments[i] = from_action(profile[i]);
     }
-    return function(*arguments).cast<double>();
+    return to_payoff_value(function(*arguments), function, arguments);
   };
 }
 
@@ -130,7 +166,7 @@ BayesianPayoffFunction to_bayesian_payoff_function(py::function function) {
     for (std::size_t i = 0; i < profile.size(); ++i) {
       arguments[i + 1] = from_action(profile[i]);
     }
-    return function(*arguments).cast<double>();
+    return to_payoff_value(function(*arguments), function, arguments);
   };
 }
 
@@ -149,7 +185,19 @@ class PyBayesianGame : public BayesianGame {
     if (!override) {
       throw py::value_error("posterior() が実装されていません");
     }
-    return override(player_id, types).cast<double>();
+    const py::object result = override(player_id, types);
+    try {
+      return result.cast<double>();
+    } catch (const py::cast_error&) {
+      const std::string what = result.is_none()
+                                   ? "何も返しませんでした (None)"
+                                   : "数値でない値 " + py::repr(result).cast<std::string>() +
+                                         " を返しました";
+      throw py::type_error("posterior() が" + what + "。引数は (player_id=" +
+                           std::to_string(player_id) + ", type_profile=" +
+                           py::repr(types).cast<std::string>() +
+                           ") でした。事後確率は実数を返してください");
+    }
   }
 };
 

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/python/tests/test_compat.py

@@ -237,6 +237,38 @@ def test_initialize_payoff_matrices_is_idempotent():
     assert len(equilibrium.get_nash_equilibrium()["index"]) == 4
 
 
+def test_reports_payoff_function_returning_none():
+    """return を書き忘れた利得関数は、どの関数のどの呼び出しかを言って落ちる。"""
+
+    class ForgotToReturn(SampleGame):
+        def male(self, type, male_action, female_action):
+            pass
+
+    with pytest.raises(TypeError, match="ForgotToReturn.male"):
+        BayesianNashEquilibrium(ForgotToReturn()).get_nash_equilibrium()
+
+
+def test_reports_posterior_returning_none():
+    class ForgotToReturn(SampleGame):
+        def posterior(self, player_id, type_tuple):
+            pass
+
+    with pytest.raises(TypeError, match="posterior"):
+        BayesianNashEquilibrium(ForgotToReturn()).get_nash_equilibrium()
+
+
+def test_core_reports_payoff_callable_returning_none():
+    """C++ から呼び戻す経路（_core.Player に関数を渡す）でも同じように言う。"""
+    from game_resolver_cpp import _core
+
+    game = _core.Game()
+    actions = ["C", "D"]
+    game.add(_core.Player(0, actions, lambda a, b: None))
+    game.add(_core.Player(1, actions, np.array([[3.0, 5.0], [0.0, 1.0]])))
+    with pytest.raises(TypeError, match="None"):
+        _core.NashEquilibrium(game)
+
+
 # ---------------------------------------------------------------- その他
 
 

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/src/version.cpp

@@ -3,7 +3,7 @@
 namespace game_resolver {
 
 std::string_view version() noexcept {
-  return "0.1.0";
+  return "0.1.1";
 }
 
 }  // namespace game_resolver

{game_resolver_cpp-0.1.0 → game_resolver_cpp-0.1.1}/tests/smoke_test.cpp

@@ -3,5 +3,5 @@
 #include "game_resolver/version.hpp"
 
 TEST(Smoke, VersionIsReported) {
-  EXPECT_EQ(game_resolver::version(), "0.1.0");
+  EXPECT_EQ(game_resolver::version(), "0.1.1");
 }