allow string input for expected payoff tables in test_rsf

Author: rahulsavani

tests/games.py

@@ -1,21 +1,24 @@
 """A utility module to create/load games for the test suite."""
 import pathlib
 
+import numpy as np
+
 import pygambit as gbt
 
 
 def read_from_file(fn: str) -> gbt.Game:
     if fn.endswith(".efg"):
-        return gbt.read_efg(pathlib.Path("tests/test_games")/fn)
+        return gbt.read_efg(pathlib.Path("tests/test_games") / fn)
     elif fn.endswith(".nfg"):
-        return gbt.read_nfg(pathlib.Path("tests/test_games")/fn)
+        return gbt.read_nfg(pathlib.Path("tests/test_games") / fn)
     else:
         raise ValueError(f"Unknown file extension in {fn}")
 
 
 ################################################################################################
 # Normal-form (aka strategic-form) games (nfg)
 
+
 def create_2x2_zero_nfg() -> gbt.Game:
     """
     Returns
@@ -73,6 +76,7 @@ def create_coord_4x4_nfg(outcome_version: bool = False) -> gbt.Game:
 ################################################################################################
 # Extensive-form games (efg)
 
+
 def create_mixed_behav_game_efg() -> gbt.Game:
     """
     Returns
@@ -124,3 +128,76 @@ def create_selten_horse_game_efg() -> gbt.Game:
         5-player Selten's Horse Game
     """
     return read_from_file("e01.efg")
+
+
+def create_reduction_generic_payoffs_efg() -> gbt.Game:
+    # tree with only root
+    g = gbt.Game.new_tree(players=["1", "2"], title="TEST")
+
+    # add four children
+    g.append_move(g.root, "2", ["a", "b", "c", "d"])
+
+    # add L and R after a
+    g.append_move(g.root.children[0], "1", ["L", "R"])
+
+    # add C and D to single infoset after b and c
+    nodes = [g.root.children[1], g.root.children[2]]
+    g.append_move(nodes, "1", ["C", "D"])
+
+    # add s and t from single infoset after rightmost C and D
+    g.append_move(g.root.children[2].children, "2", ["s", "t"])
+
+    # add p and q
+    g.append_move(g.root.children[0].children[1], "2", ["p", "q"])
+
+    # add U and V in a single infoset after p and q
+    g.append_move(g.root.children[0].children[1].children, "1", ["U", "V"])
+
+    # Set outcomes
+
+    g.set_outcome(g.root.children[0].children[0], g.add_outcome([1, -1], label="aL"))
+    g.set_outcome(
+        g.root.children[0].children[1].children[0].children[0],
+        g.add_outcome([2, -2], label="aRpU"),
+    )
+    g.set_outcome(
+        g.root.children[0].children[1].children[0].children[1],
+        g.add_outcome([3, -3], label="aRpV"),
+    )
+    g.set_outcome(
+        g.root.children[0].children[1].children[1].children[0],
+        g.add_outcome([4, -4], label="aRqU"),
+    )
+    g.set_outcome(
+        g.root.children[0].children[1].children[1].children[1],
+        g.add_outcome([5, -5], label="aRqV"),
+    )
+
+    g.set_outcome(g.root.children[1].children[0], g.add_outcome([6, -6], label="bC"))
+    g.set_outcome(g.root.children[1].children[1], g.add_outcome([7, -7], label="bD"))
+
+    g.set_outcome(
+        g.root.children[2].children[0].children[0], g.add_outcome([8, -8], label="cCs")
+    )
+    g.set_outcome(
+        g.root.children[2].children[0].children[1], g.add_outcome([9, -9], label="cCt")
+    )
+    g.set_outcome(
+        g.root.children[2].children[1].children[0],
+        g.add_outcome([10, -10], label="cDs"),
+    )
+    g.set_outcome(
+        g.root.children[2].children[1].children[1],
+        g.add_outcome([11, -11], label="cDt"),
+    )
+
+    g.set_outcome(g.root.children[3], g.add_outcome([12, -12], label="d"))
+
+    return g
+
+
+def make_rational(input: str):
+    return gbt.Rational(input)
+
+
+vectorized_make_rational = np.vectorize(make_rational)

tests/test_rsf.py

@@ -126,8 +126,10 @@
         # 2-player (zero-sum) game with reduction for both players and generic payoffs
         # (
         # games.create_reduction_generic_payoffs_efg(),
-        # [["11*", "12*", "211", "221", "212", "222"],
-        # ["1*1", "1*2", "2**", "31*", "32*", "4**"] ],
+        # [
+        # ["11*", "12*", "211", "221", "212", "222"],
+        # ["1*1", "1*2", "2**", "31*", "32*", "4**"],
+        # ],
         # [
         # np.array(
         # [
@@ -148,7 +150,7 @@
         # ["1", "2", "3", "4", "5", "6"],
         # ["1", "2", "3", "4", "5", "6"],
         # ]
-        # )
+        # ),
         # ],
         # ),
     ],
@@ -167,5 +169,5 @@ def test_reduced_strategic_form(
     for i, player in enumerate(game.players):
         assert strategy_labels[i] == [s.label for s in player.strategies]
         # convert strings to rationals
-        exp_array = arrays[i].astype(gbt.Rational)
+        exp_array = games.vectorized_make_rational(np_arrays_of_rsf[i])
         assert (arrays[i] == exp_array).all()