mdpsolver 0.9.9__tar.gz → 0.9.10__tar.gz

{mdpsolver-0.9.9/src/mdpsolver.egg-info → mdpsolver-0.9.10}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: mdpsolver
-Version: 0.9.9
+Version: 0.9.10
 Summary: A fast solver for Markov Decision Processes
 Author-email: Anders Reenberg Andersen <andersra@live.dk>, Jesper Fink Andersen <jesperfinkandersen@gmail.com>
 Project-URL: Homepage, https://github.com/areenberg/MDPSolver
 Project-URL: Issues, https://github.com/areenberg/MDPSolver/issues
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
@@ -17,8 +17,6 @@ Dynamic: license-file
 
 # MDPSolver
 
-<img src="https://github.com/areenberg/MDPSolver/blob/anders_development/Images/MDPSolver_logo_3.png" alt="Logo" width="180">
-
 MDPSolver is a Python package for large Markov Decision Processes (MDPs) with infinite-horizons. 
 
 ## Features
@@ -40,11 +38,9 @@ Install directly from PyPI with:
 pip install mdpsolver
 ```
 
-MDPSolver works *out of the box* on Ubuntu 22 and newer.
-
 ### GLIBC not found
 
-Some users will encounter the `version 'GLIBC_2.32' not found` error when attempting to import MDPSolver in Python. In this case, it might help to manually compile and replace the SO-file for the optimization module in the MDPSolver package. See the steps on how to solve the issue in the [documentation](https://github.com/areenberg/MDPSolver/wiki#how-to-install).
+Some users will encounter the `version 'GLIBC_2.38' not found` error when attempting to import MDPSolver in Python. The issue can be resolved by manually compiling and replacing the SO-file for the optimization module in the MDPSolver package. See the steps on how to solve the issue in the [documentation](https://github.com/areenberg/MDPSolver/wiki#how-to-install).
 
 ## Windows
 

{mdpsolver-0.9.9 → mdpsolver-0.9.10}/README.md

@@ -1,7 +1,5 @@
 # MDPSolver
 
-<img src="https://github.com/areenberg/MDPSolver/blob/anders_development/Images/MDPSolver_logo_3.png" alt="Logo" width="180">
-
 MDPSolver is a Python package for large Markov Decision Processes (MDPs) with infinite-horizons. 
 
 ## Features
@@ -23,11 +21,9 @@ Install directly from PyPI with:
 pip install mdpsolver
 ```
 
-MDPSolver works *out of the box* on Ubuntu 22 and newer.
-
 ### GLIBC not found
 
-Some users will encounter the `version 'GLIBC_2.32' not found` error when attempting to import MDPSolver in Python. In this case, it might help to manually compile and replace the SO-file for the optimization module in the MDPSolver package. See the steps on how to solve the issue in the [documentation](https://github.com/areenberg/MDPSolver/wiki#how-to-install).
+Some users will encounter the `version 'GLIBC_2.38' not found` error when attempting to import MDPSolver in Python. The issue can be resolved by manually compiling and replacing the SO-file for the optimization module in the MDPSolver package. See the steps on how to solve the issue in the [documentation](https://github.com/areenberg/MDPSolver/wiki#how-to-install).
 
 ## Windows
 

{mdpsolver-0.9.9 → mdpsolver-0.9.10}/pyproject.toml

@@ -10,7 +10,7 @@ where = ["src"]
 
 [project]
 name = "mdpsolver"
-version = "0.9.9"
+version = "0.9.10"
 authors = [
   { name="Anders Reenberg Andersen", email="andersra@live.dk" },
   { name="Jesper Fink Andersen", email="jesperfinkandersen@gmail.com" },
@@ -19,7 +19,7 @@ description = "A fast solver for Markov Decision Processes"
 readme = "README.md"
 requires-python = ">=3.10"
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",
     "Operating System :: Microsoft :: Windows",

{mdpsolver-0.9.9 → mdpsolver-0.9.10}/src/mdpsolver/model.py

@@ -6,9 +6,9 @@ and solve Markov Decision Processes (MDPs). It provides methods to configure the
 solve it, and extract the resulting policy and value vectors.
 """
 
+import sys
 from mdpsolver import solvermodule
 
-
 class model:
     """
     Creates an MDPSolver object.
@@ -27,19 +27,19 @@ class model:
 
     def solve(
         self,
-        algorithm="mpi",
-        tolerance=1e-3,
-        update="standard",
-        criterion="discounted",
-        parIterLim=100,
-        SORrelaxation=1.0,
-        initPolicy=list(),
-        initValueVector=list(),
-        verbose=False,
-        postProcessing=True,
-        makeFinalCheck=True,
-        parallel=True,
-    ):
+        algorithm: str = "mpi",
+        tolerance: float = 1e-3,
+        update: str = "standard",
+        criterion: str = "discounted",
+        parIterLim: int = 100,
+        SORrelaxation: float = 1.0,
+        initPolicy: list = list(),
+        initValueVector: list = list(),
+        verbose: bool = False,
+        postProcessing: bool = True,
+        makeFinalCheck: bool = True,
+        parallel: bool = True,
+    ) -> None:
         """
         Derive an epsilon-optimal policy for the selected MDP model.
 
@@ -60,6 +60,20 @@ class model:
         Returns:
             None
         """
+        
+        if not (algorithm == "mpi" or algorithm == "pi" or algorithm == "vi"):
+            sys.exit("Error: Algorithm type not recognized. Select either: 'mpi', 'pi', or 'vi'.")
+        if tolerance <= 0.0:
+            sys.exit("Error: The tolerance needs to be a positive number.")
+        if not (update == "standard" or update == "gs" or update == "sor"):
+            sys.exit("Error: Update method not recognized. Select either: 'standard', 'gs', or 'sor'.")
+        if not (criterion == "discounted" or criterion == "average"):
+            sys.exit("Error: Optimality criterion not recognized. Select either: 'discounted' or 'average'.")
+        if parIterLim <= 0 and algorithm == "mpi":
+            sys.exit("Error: The partial evaluation limit needs to be a positive number.")
+        if (SORrelaxation <= 0.0 or SORrelaxation >= 2.0) and update == "sor":
+            sys.exit("Error: The relaxation parameter needs to be between 0.0 and 2.0 (i.e. 0 < SORrelaxation < 2).")
+        
         self.mdl.solve(
             algorithm=algorithm,
             tolerance=tolerance,
@@ -75,7 +89,7 @@ class model:
             parallel=parallel,
         )
 
-    def getRuntime(self):
+    def getRuntime(self) -> float:
         """
         Get the runtime of the last solver execution.
 
@@ -84,15 +98,15 @@ class model:
         """
         return self.mdl.getRuntime()
 
-    def printPolicy(self):
+    def printPolicy(self) -> None:
         """Print the entire policy to the terminal."""
         self.mdl.printPolicy()
 
-    def printValueVector(self):
+    def printValueVector(self) -> None:
         """Print the entire value vector to the terminal."""
         self.mdl.printValueVector()
 
-    def getAction(self, stateIndex=0):
+    def getAction(self, stateIndex: int = 0) -> int:
         """
         Get the action from the optimized policy for a specific state.
 
@@ -104,7 +118,7 @@ class model:
         """
         return self.mdl.getAction(stateIndex=stateIndex)
 
-    def getValue(self, stateIndex=0):
+    def getValue(self, stateIndex: int = 0) -> float:
         """
         Get the value from the optimized value vector for a specific state.
 
@@ -116,7 +130,7 @@ class model:
         """
         return self.mdl.getValue(stateIndex=stateIndex)
 
-    def getPolicy(self):
+    def getPolicy(self) -> list:
         """
         Get the entire optimized policy.
 
@@ -134,7 +148,7 @@ class model:
         """
         return self.mdl.getValueVector()
 
-    def saveToFile(self, fileName="result.csv", type="policy"):
+    def saveToFile(self, fileName: str = "result.csv", type: str = "policy") -> None:
         """
         Save the optimized policy or value vector to a file.
 
@@ -145,20 +159,24 @@ class model:
         Returns:
             None
         """
+        
+        if not (type == "policy" or type == "value"):
+            sys.exit("Error: Type not recognized. Select either: 'policy' or 'value'.")
+
         return self.mdl.saveToFile(fileName=fileName, type=type)
 
     def mdp(
         self,
-        discount=0.99,
-        rewards=list(),
-        rewardsElementwise=list(),
-        rewardsFromFile="rewards.csv",
-        tranMatWithZeros=list(),
-        tranMatElementwise=list(),
-        tranMatProbs=list(),
-        tranMatColumns=list(),
-        tranMatFromFile="transitions.csv",
-    ):
+        discount: float = 0.99,
+        rewards: list = list(),
+        rewardsElementwise: list = list(),
+        rewardsFromFile: str = "rewards.csv",
+        tranMatWithZeros: list = list(),
+        tranMatElementwise: list = list(),
+        tranMatProbs: list = list(),
+        tranMatColumns: list = list(),
+        tranMatFromFile: str = "transitions.csv",
+    ) -> None:
         """
         Define the generic MDP model.
 
@@ -176,6 +194,10 @@ class model:
         Returns:
             None
         """
+        
+        if discount <= 0.0 or discount >= 1.0:
+            sys.exit("Error: The discount needs to be in the interval between 0.0 and 1.0 (i.e. 0 < discount < 1).")
+        
         self.mdl.mdp(
             discount=discount,
             rewards=rewards,

{mdpsolver-0.9.9 → mdpsolver-0.9.10/src/mdpsolver.egg-info}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: mdpsolver
-Version: 0.9.9
+Version: 0.9.10
 Summary: A fast solver for Markov Decision Processes
 Author-email: Anders Reenberg Andersen <andersra@live.dk>, Jesper Fink Andersen <jesperfinkandersen@gmail.com>
 Project-URL: Homepage, https://github.com/areenberg/MDPSolver
 Project-URL: Issues, https://github.com/areenberg/MDPSolver/issues
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows
@@ -17,8 +17,6 @@ Dynamic: license-file
 
 # MDPSolver
 
-<img src="https://github.com/areenberg/MDPSolver/blob/anders_development/Images/MDPSolver_logo_3.png" alt="Logo" width="180">
-
 MDPSolver is a Python package for large Markov Decision Processes (MDPs) with infinite-horizons. 
 
 ## Features
@@ -40,11 +38,9 @@ Install directly from PyPI with:
 pip install mdpsolver
 ```
 
-MDPSolver works *out of the box* on Ubuntu 22 and newer.
-
 ### GLIBC not found
 
-Some users will encounter the `version 'GLIBC_2.32' not found` error when attempting to import MDPSolver in Python. In this case, it might help to manually compile and replace the SO-file for the optimization module in the MDPSolver package. See the steps on how to solve the issue in the [documentation](https://github.com/areenberg/MDPSolver/wiki#how-to-install).
+Some users will encounter the `version 'GLIBC_2.38' not found` error when attempting to import MDPSolver in Python. The issue can be resolved by manually compiling and replacing the SO-file for the optimization module in the MDPSolver package. See the steps on how to solve the issue in the [documentation](https://github.com/areenberg/MDPSolver/wiki#how-to-install).
 
 ## Windows
 

{mdpsolver-0.9.9 → mdpsolver-0.9.10}/src/mdpsolver.egg-info/SOURCES.txt

@@ -8,17 +8,23 @@ src/mdpsolver/solvermodule.cp310-win_amd64.pyd
 src/mdpsolver/solvermodule.cp311-win_amd64.pyd
 src/mdpsolver/solvermodule.cp312-win_amd64.pyd
 src/mdpsolver/solvermodule.cp313-win_amd64.pyd
+src/mdpsolver/solvermodule.cp314-win_amd64.pyd
 src/mdpsolver/solvermodule.cpython-310-x86_64-linux-gnu.so
 src/mdpsolver/solvermodule.cpython-311-x86_64-linux-gnu.so
 src/mdpsolver/solvermodule.cpython-312-x86_64-linux-gnu.so
 src/mdpsolver/solvermodule.cpython-313-x86_64-linux-gnu.so
+src/mdpsolver/solvermodule.cpython-314-x86_64-linux-gnu.so
 src/mdpsolver.egg-info/PKG-INFO
 src/mdpsolver.egg-info/SOURCES.txt
 src/mdpsolver.egg-info/dependency_links.txt
 src/mdpsolver.egg-info/top_level.txt
-src/mdpsolver/problems/cbmaux.py
-src/mdpsolver/problems/tbmaux.py
+src/mdpsolver/__pycache__/__init__.cpython-313.pyc
+src/mdpsolver/__pycache__/__init__.cpython-314.pyc
+src/mdpsolver/__pycache__/model.cpython-313.pyc
+src/mdpsolver/__pycache__/model.cpython-314.pyc
 src/mdpsolver/problems/__pycache__/cbmaux.cpython-310.pyc
 src/mdpsolver/problems/__pycache__/tbmaux.cpython-310.pyc
 tests/test1.py
-tests/test2.py
+tests/test1_pip.py
+tests/test2.py
+tests/test2_pip.py

mdpsolver-0.9.10/tests/test1.py

@@ -0,0 +1,717 @@
+import random
+import sys
+import os
+import numpy as np
+from random import randint
+project_root = os.path.dirname(os.path.abspath(__file__))
+src_path = os.path.join(project_root, "..", "src")
+sys.path.append(os.path.abspath(src_path))
+import mdpsolver
+
+# TEST 1
+# Simple MDP with 3 states and 2 actions in each state.
+
+# ---------------------------------------
+# CONFIGURATION 1
+# ---------------------------------------
+
+# rewards
+# 1st index: from (current) states
+# 2nd index: actions
+rewards = [[5, -1], [1, -2], [50, 0]]
+
+# transition probabilities
+# 1st index: from (current) states
+# 2nd index: actions
+# 3rd index: to (next) states
+tranMatWithZeros = [
+    [[0.9, 0.1, 0.0], [0.1, 0.9, 0.0]],
+    [[0.4, 0.5, 0.1], [0.3, 0.5, 0.2]],
+    [[0.2, 0.2, 0.6], [0.5, 0.5, 0.0]],
+]
+
+# initial policy
+random.seed(10)
+initPolicy = [randint(0, 1) for p in range(0, 3)]
+
+# Model 1a (discounted reward, parallel)
+mdl1a = mdpsolver.model()
+mdl1a.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl1a.solve(algorithm="mpi", update="standard", parallel=True, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1a.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 1a failed!")
+
+# Model 2a (discounted reward, parallel)
+mdl2a = mdpsolver.model()
+mdl2a.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl2a.solve(algorithm="pi", update="standard", parallel=True, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2a.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 2a failed!")
+
+# Model 3a (discounted reward, parallel)
+mdl3a = mdpsolver.model()
+mdl3a.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl3a.solve(algorithm="vi", update="standard", parallel=True)
+if not np.array_equal(np.array(mdl3a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3a.getValueVector()), 3),
+    np.round(np.array([200.0013199959708, 212.86689665815788, 298.709197760198]), 3),
+):
+    sys.exit("Model 3a failed!")
+
+# Model 1b (discounted reward, unparallel)
+mdl1b = mdpsolver.model()
+mdl1b.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl1b.solve(algorithm="mpi", update="standard", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1b.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 1b failed!")
+
+# Model 2b (discounted reward, unparallel)
+mdl2b = mdpsolver.model()
+mdl2b.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl2b.solve(algorithm="pi", update="standard", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2b.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 2b failed!")
+
+# Model 3b (discounted reward, unparallel)
+mdl3b = mdpsolver.model()
+mdl3b.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl3b.solve(algorithm="vi", update="standard", parallel=False)
+if not np.array_equal(np.array(mdl3b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3b.getValueVector()), 3),
+    np.round(np.array([200.0013199959708, 212.86689665815788, 298.709197760198]), 3),
+):
+    sys.exit("Model 3b failed!")
+
+# Model 1a (average reward, parallel)
+mdl1a = mdpsolver.model()
+mdl1a.mdp(rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl1a.solve(
+    algorithm="mpi",
+    update="standard",
+    criterion="average",
+    parallel=True,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl1a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1a.getValueVector()), 3),
+    np.round(np.array([354.2101307157537, 368.21018917357264, 457.21037278800077]), 3),
+):
+    sys.exit("Model 1a failed!")
+
+# Model 2a (average reward, parallel)
+mdl2a = mdpsolver.model()
+mdl2a.mdp(rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl2a.solve(
+    algorithm="pi",
+    update="standard",
+    criterion="average",
+    parallel=True,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl2a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2a.getValueVector()), 3),
+    np.round(np.array([354.2101307157537, 368.21018917357264, 457.21037278800077]), 3),
+):
+    sys.exit("Model 2a failed!")
+
+# Model 3a (average reward, parallel)
+mdl3a = mdpsolver.model()
+mdl3a.mdp(rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl3a.solve(algorithm="vi", update="standard", criterion="average", parallel=True)
+if not np.array_equal(np.array(mdl3a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3a.getValueVector()), 3),
+    np.round(np.array([158.23345351808334, 172.23340169038516, 261.233237936489]), 3),
+):
+    sys.exit("Model 3a failed!")
+
+# Model 1b (average reward, unparallel)
+mdl1b = mdpsolver.model()
+mdl1b.mdp(rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl1b.solve(
+    algorithm="mpi",
+    update="standard",
+    criterion="average",
+    parallel=False,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl1b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1b.getValueVector()), 3),
+    np.round(np.array([354.2101307157537, 368.21018917357264, 457.21037278800077]), 3),
+):
+    sys.exit("Model 1b failed!")
+
+# Model 2b (average reward, unparallel)
+mdl2b = mdpsolver.model()
+mdl2b.mdp(rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl2b.solve(
+    algorithm="pi",
+    update="standard",
+    criterion="average",
+    parallel=False,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl2b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2b.getValueVector()), 3),
+    np.round(np.array([354.2101307157537, 368.21018917357264, 457.21037278800077]), 3),
+):
+    sys.exit("Model 2b failed!")
+
+# Model 3b (average reward, unparallel)
+mdl3b = mdpsolver.model()
+mdl3b.mdp(rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl3b.solve(algorithm="vi", update="standard", criterion="average", parallel=False)
+if not np.array_equal(np.array(mdl3b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3b.getValueVector()), 3),
+    np.round(np.array([158.23345351808334, 172.23340169038516, 261.233237936489]), 3),
+):
+    sys.exit("Model 3b failed!")
+
+# Model 1c (discounted, Gauss-Seidel)
+mdl1c = mdpsolver.model()
+mdl1c.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl1c.solve(algorithm="mpi", update="gs", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1c.getValueVector()), 3),
+    np.round(np.array([200.0012771893156, 212.86686671568802, 298.7091798650016]), 3),
+):
+    sys.exit("Model 1c failed!")
+
+# Model 2c (Gauss-Seidel)
+initPolicy = [1, 1, 1]
+mdl2c = mdpsolver.model()
+mdl2c.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl2c.solve(algorithm="pi", update="gs", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2c.getValueVector()), 3),
+    np.round(np.array([200.0012771893156, 212.86686671568802, 298.7091798650016]), 3),
+):
+    sys.exit("Model 2c failed!")
+
+# Model 3c (Gauss-Seidel)
+mdl3c = mdpsolver.model()
+mdl3c.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl3c.solve(algorithm="vi", update="gs", parallel=False)
+if not np.array_equal(np.array(mdl3c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3c.getValueVector()), 3),
+    np.round(np.array([200.0010604606014, 212.86664512773723, 298.7089561808565]), 3),
+):
+    sys.exit("Model 3c failed!")
+
+# Model 1d (SOR)
+mdl1d = mdpsolver.model()
+mdl1d.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl1d.solve(
+    algorithm="mpi",
+    update="sor",
+    SORrelaxation=1.01,
+    parallel=False,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl1d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1d.getValueVector()), 3),
+    np.round(np.array([200.00127021272166, 212.86686059325598, 298.70917425463125]), 3),
+):
+    sys.exit("Model 1d failed!")
+
+# Model 2d (SOR)
+mdl2d = mdpsolver.model()
+mdl2d.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl2d.solve(
+    algorithm="pi",
+    update="sor",
+    SORrelaxation=1.01,
+    parallel=False,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl2d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2d.getValueVector()), 3),
+    np.round(np.array([200.00127021272166, 212.86686059325598, 298.70917425463125]), 3),
+):
+    sys.exit("Model 2d failed!")
+
+# Model 3d (SOR)
+mdl3d = mdpsolver.model()
+mdl3d.mdp(discount=0.95, rewards=rewards, tranMatWithZeros=tranMatWithZeros)
+mdl3d.solve(algorithm="vi", update="sor", SORrelaxation=1.01, parallel=False)
+if not np.array_equal(np.array(mdl3d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3d.getValueVector()), 3),
+    np.round(np.array([206.69740452375487, 222.30968454932525, 305.91165352015094]), 3),
+):
+    sys.exit("Model 3d failed!")
+
+# ---------------------------------------
+# CONFIGURATION 2
+# ---------------------------------------
+
+# rewards
+# 1st index: from (current) states
+# 2nd index: actions
+rewards = [[5, -1], [1, -2], [50, 0]]
+
+# transition probabilities
+# [from_state,action,to_state,probability]
+tranMatElementwise = [
+    [0, 0, 0, 0.9],
+    [0, 0, 1, 0.1],
+    [0, 1, 0, 0.1],
+    [0, 1, 1, 0.9],
+    [1, 0, 0, 0.4],
+    [1, 0, 1, 0.5],
+    [1, 0, 2, 0.1],
+    [1, 1, 0, 0.3],
+    [1, 1, 1, 0.5],
+    [1, 1, 2, 0.2],
+    [2, 0, 0, 0.2],
+    [2, 0, 1, 0.2],
+    [2, 0, 2, 0.6],
+    [2, 1, 0, 0.5],
+    [2, 1, 1, 0.5],
+]
+
+# initial policy
+random.seed(10)
+initPolicy = [randint(0, 1) for p in range(0, 3)]
+
+# Model 1a
+mdl1a = mdpsolver.model()
+mdl1a.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl1a.solve(algorithm="mpi", update="standard", parallel=True, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1a.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 1a failed!")
+
+# Model 2a
+mdl2a = mdpsolver.model()
+mdl2a.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl2a.solve(algorithm="pi", update="standard", parallel=True, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2a.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 2a failed!")
+
+# Model 3a
+mdl3a = mdpsolver.model()
+mdl3a.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl3a.solve(algorithm="vi", update="standard", parallel=True)
+if not np.array_equal(np.array(mdl3a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3a.getValueVector()), 3),
+    np.round(np.array([200.0013199959708, 212.86689665815788, 298.709197760198]), 3),
+):
+    sys.exit("Model 3a failed!")
+
+# Model 1b
+mdl1b = mdpsolver.model()
+mdl1b.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl1b.solve(algorithm="mpi", update="standard", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1b.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 1b failed!")
+
+# Model 2b
+mdl2b = mdpsolver.model()
+mdl2b.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl2b.solve(algorithm="pi", update="standard", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2b.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 2b failed!")
+
+# Model 3b
+mdl3b = mdpsolver.model()
+mdl3b.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl3b.solve(algorithm="vi", update="standard", parallel=False)
+if not np.array_equal(np.array(mdl3b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3b.getValueVector()), 3),
+    np.round(np.array([200.0013199959708, 212.86689665815788, 298.709197760198]), 3),
+):
+    sys.exit("Model 3b failed!")
+
+# Model 1c
+mdl1c = mdpsolver.model()
+mdl1c.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl1c.solve(algorithm="mpi", update="gs", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1c.getValueVector()), 3),
+    np.round(np.array([200.0012771893156, 212.86686671568802, 298.7091798650016]), 3),
+):
+    sys.exit("Model 1c failed!")
+
+# Model 2c
+mdl2c = mdpsolver.model()
+mdl2c.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl2c.solve(algorithm="pi", update="gs", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2c.getValueVector()), 3),
+    np.round(np.array([200.0012771893156, 212.86686671568802, 298.7091798650016]), 3),
+):
+    sys.exit("Model 2c failed!")
+
+# Model 3c
+mdl3c = mdpsolver.model()
+mdl3c.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl3c.solve(algorithm="vi", update="gs", parallel=False)
+if not np.array_equal(np.array(mdl3c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3c.getValueVector()), 3),
+    np.round(np.array([200.0010604606014, 212.86664512773723, 298.7089561808565]), 3),
+):
+    sys.exit("Model 3c failed!")
+
+# Model 1d
+mdl1d = mdpsolver.model()
+mdl1d.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl1d.solve(
+    algorithm="mpi",
+    update="sor",
+    SORrelaxation=1.01,
+    parallel=False,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl1d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1d.getValueVector()), 3),
+    np.round(np.array([200.00127021272166, 212.86686059325598, 298.70917425463125]), 3),
+):
+    sys.exit("Model 1d failed!")
+
+# Model 2d
+mdl2d = mdpsolver.model()
+mdl2d.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl2d.solve(
+    algorithm="pi",
+    update="sor",
+    SORrelaxation=1.01,
+    parallel=False,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl2d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2d.getValueVector()), 3),
+    np.round(np.array([200.00127021272166, 212.86686059325598, 298.70917425463125]), 3),
+):
+    sys.exit("Model 2d failed!")
+
+# Model 3d
+mdl3d = mdpsolver.model()
+mdl3d.mdp(discount=0.95, rewards=rewards, tranMatElementwise=tranMatElementwise)
+mdl3d.solve(algorithm="vi", update="sor", SORrelaxation=1.01, parallel=False)
+if not np.array_equal(np.array(mdl3d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3d.getValueVector()), 3),
+    np.round(np.array([206.69740452375487, 222.30968454932525, 305.91165352015094]), 3),
+):
+    sys.exit("Model 3d failed!")
+
+# ---------------------------------------
+# CONFIGURATION 3
+# ---------------------------------------
+
+# rewards
+# 1st index: from (current) states
+# 2nd index: actions
+rewards = [[5, -1], [1, -2], [50, 0]]
+
+# transition probabilities
+tranMatProbs = [
+    [[0.9, 0.1], [0.1, 0.9]],
+    [[0.4, 0.5, 0.1], [0.3, 0.5, 0.2]],
+    [[0.2, 0.2, 0.6], [0.5, 0.5]],
+]
+
+tranMatColumns = [[[0, 1], [0, 1]], [[0, 1, 2], [0, 1, 2]], [[0, 1, 2], [0, 1]]]
+
+# initial policy
+random.seed(10)
+initPolicy = [randint(0, 1) for p in range(0, 3)]
+
+# Model 1a
+mdl1a = mdpsolver.model()
+mdl1a.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl1a.solve(algorithm="mpi", update="standard", parallel=True, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1a.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 1a failed!")
+
+# Model 2a
+mdl2a = mdpsolver.model()
+mdl2a.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl2a.solve(algorithm="pi", update="standard", parallel=True, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2a.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 2a failed!")
+
+# Model 3a
+mdl3a = mdpsolver.model()
+mdl3a.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl3a.solve(algorithm="vi", update="standard", parallel=True)
+if not np.array_equal(np.array(mdl3a.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3a failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3a.getValueVector()), 3),
+    np.round(np.array([200.0013199959708, 212.86689665815788, 298.709197760198]), 3),
+):
+    sys.exit("Model 3a failed!")
+
+# Model 1b
+mdl1b = mdpsolver.model()
+mdl1b.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl1b.solve(algorithm="mpi", update="standard", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1b.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 1b failed!")
+
+# Model 2b
+mdl2b = mdpsolver.model()
+mdl2b.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl2b.solve(algorithm="pi", update="standard", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2b.getValueVector()), 3),
+    np.round(np.array([200.00114718191236, 212.86672887958622, 298.7090458676583]), 3),
+):
+    sys.exit("Model 2b failed!")
+
+# Model 3b
+mdl3b = mdpsolver.model()
+mdl3b.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl3b.solve(algorithm="vi", update="standard", parallel=False)
+if not np.array_equal(np.array(mdl3b.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3b failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3b.getValueVector()), 3),
+    np.round(np.array([200.0013199959708, 212.86689665815788, 298.709197760198]), 3),
+):
+    sys.exit("Model 3b failed!")
+
+# Model 1c
+mdl1c = mdpsolver.model()
+mdl1c.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl1c.solve(algorithm="mpi", update="gs", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl1c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1c.getValueVector()), 3),
+    np.round(np.array([200.0012771893156, 212.86686671568802, 298.7091798650016]), 3),
+):
+    sys.exit("Model 1c failed!")
+
+# Model 2c
+mdl2c = mdpsolver.model()
+mdl2c.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl2c.solve(algorithm="pi", update="gs", parallel=False, initPolicy=initPolicy)
+if not np.array_equal(np.array(mdl2c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2c.getValueVector()), 3),
+    np.round(np.array([200.0012771893156, 212.86686671568802, 298.7091798650016]), 3),
+):
+    sys.exit("Model 2c failed!")
+
+# Model 3c
+mdl3c = mdpsolver.model()
+mdl3c.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl3c.solve(algorithm="vi", update="gs", parallel=False)
+if not np.array_equal(np.array(mdl3c.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3c failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3c.getValueVector()), 3),
+    np.round(np.array([200.0010604606014, 212.86664512773723, 298.7089561808565]), 3),
+):
+    sys.exit("Model 3c failed!")
+
+# Model 1d
+mdl1d = mdpsolver.model()
+mdl1d.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl1d.solve(
+    algorithm="mpi",
+    update="sor",
+    SORrelaxation=1.01,
+    parallel=False,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl1d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 1d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl1d.getValueVector()), 3),
+    np.round(np.array([200.00127021272166, 212.86686059325598, 298.70917425463125]), 3),
+):
+    sys.exit("Model 1d failed!")
+
+# Model 2d
+mdl2d = mdpsolver.model()
+mdl2d.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl2d.solve(
+    algorithm="pi",
+    update="sor",
+    SORrelaxation=1.01,
+    parallel=False,
+    initPolicy=initPolicy,
+)
+if not np.array_equal(np.array(mdl2d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 2d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl2d.getValueVector()), 3),
+    np.round(np.array([200.00127021272166, 212.86686059325598, 298.70917425463125]), 3),
+):
+    sys.exit("Model 2d failed!")
+
+# Model 3d
+mdl3d = mdpsolver.model()
+mdl3d.mdp(
+    discount=0.95,
+    rewards=rewards,
+    tranMatProbs=tranMatProbs,
+    tranMatColumns=tranMatColumns,
+)
+mdl3d.solve(algorithm="vi", update="sor", SORrelaxation=1.01, parallel=False)
+if not np.array_equal(np.array(mdl3d.getPolicy()), np.array([1, 1, 0])):
+    sys.exit("Model 3d failed!")
+if not np.array_equal(
+    np.round(np.array(mdl3d.getValueVector()), 3),
+    np.round(np.array([206.69740452375487, 222.30968454932525, 305.91165352015094]), 3),
+):
+    sys.exit("Model 3d failed!")
+
+print("Test 1 succesfully reproduced output!")

mdpsolver-0.9.10/tests/test2.py

@@ -0,0 +1,91 @@
+import example_model
+import sys
+import os
+import numpy as np
+project_root = os.path.dirname(os.path.abspath(__file__))
+src_path = os.path.join(project_root, "..", "src")
+sys.path.append(os.path.abspath(src_path))
+import mdpsolver
+
+# TEST 2
+# In this test, we load the rewards and transition probabilities
+# from two CSV-files (rewards_example.csv and transitions.csv).
+# In addition, we test three optimization algorithms and compare
+# the runtimes.
+
+# PROBLEM DESCRIPTION: We derive the policy for a decision problem
+# involving a queueing system with finite capacity and two customer
+# types. The system is observed whenever a new customer arrives.
+# Customers are not allowed to wait and can only be accepted if there
+# are idle servers. Thus, with each arrival, we must choose whether
+# to accept or reject the customer. We receive a low reward for
+# accepting the first, more common type, and a high reward for
+# accepting the second, rarer type.
+
+# ---------------------------------------
+# CREATE PARAMETERS
+# ---------------------------------------
+
+# rewards
+capacity = 100
+rewardCust1 = 1
+rewardCust2 = 1000
+example_model.rewards(capacity, rewardCust1, rewardCust2, "rewards_example2.csv")
+
+# transitions
+arrRate1 = 50
+arrRate2 = 10
+serRate = 3 / 4
+example_model.tranMat(arrRate1, arrRate2, serRate, capacity, "transitions_example2.csv")
+
+# ---------------------------------------
+# VALUE ITERATION
+# ---------------------------------------
+
+mdl1 = mdpsolver.model()
+
+mdl1.mdp(
+    discount=0.99,
+    rewardsFromFile="rewards_example2.csv",
+    tranMatFromFile="transitions_example2.csv",
+)
+
+mdl1.solve(algorithm="vi")
+if not np.round(np.mean(mdl1.getValueVector()), 0) == 17075.0:
+    sys.exit("Model 1 failed!")
+
+# ---------------------------------------
+# POLICY ITERATION
+# ---------------------------------------
+
+mdl2 = mdpsolver.model()
+
+mdl2.mdp(
+    discount=0.99,
+    rewardsFromFile="rewards_example2.csv",
+    tranMatFromFile="transitions_example2.csv",
+)
+
+mdl2.solve(algorithm="pi")
+
+if not np.round(np.mean(mdl2.getValueVector()), 0) == 17075.0:
+    sys.exit("Model 2 failed!")
+
+# ---------------------------------------
+# MODIFIED POLICY ITERATION
+# ---------------------------------------
+
+mdl3 = mdpsolver.model()
+
+mdl3.mdp(
+    discount=0.99,
+    rewardsFromFile="rewards_example2.csv",
+    tranMatFromFile="transitions_example2.csv",
+)
+
+mdl3.solve(algorithm="mpi")
+
+if not np.round(np.mean(mdl3.getValueVector()), 0) == 17075.0:
+    sys.exit("Model 3 failed!")
+
+print("Test 2 succesfully reproduced output!")

mdpsolver-0.9.9/src/mdpsolver/problems/cbmaux.py

@@ -1,40 +0,0 @@
-import math
-
-# Condition-based maintenance problem
-
-# Note: The class is only used for retrieving/converting information
-# (i.e. returning an action of the policy). The policy is optimized
-# in the 'model' (model.py) class.
-
-
-class cbmaux:
-
-    def __init__(self, components, stages):
-        self.components = components
-        self.stages = stages
-
-    def compToState(self, compStates):
-        # input: list containing the stage of each component
-        # output: the associated state index
-        prod = self.components * [1]
-        if self.components > 1:
-            for i in range(self.components - 2, -1, -1):
-                prod[i] = prod[i + 1] * self.stages
-        stateIndex = 0
-        for i in range(self.components):
-            stateIndex += compStates[i] * prod[i]
-        return stateIndex
-
-    def actionToReplace(self, actionIndex):
-        # input: action index from the optimized policy
-        # output: list of bools indicating which comps to replace
-        prod = self.components * [1]
-        if self.components > 1:
-            for i in range(self.components - 2, -1, -1):
-                prod[i] = prod[i + 1] * 2
-        replace = self.components * [False]
-        for i in range(self.components):
-            if math.floor(actionIndex / prod[i]) > 0:
-                replace[i] = True
-                actionIndex -= prod[i]
-        return replace

mdpsolver-0.9.9/src/mdpsolver/problems/tbmaux.py

@@ -1,40 +0,0 @@
-import math
-
-# Time-based maintenance problem
-
-# Note: The class is only used for retrieving/converting information
-# (i.e. returning an action of the policy). The policy is optimized
-# in the 'model' (model.py) class.
-
-
-class tbmaux:
-
-    def __init__(self, components, stages):
-        self.components = components
-        self.stages = stages
-
-    def compToState(self, compStates):
-        # input: list containing the stage of each component
-        # output: the associated state index
-        prod = self.components * [1]
-        if self.components > 1:
-            for i in range(self.components - 2, -1, -1):
-                prod[i] = prod[i + 1] * self.stages
-        stateIndex = 0
-        for i in range(self.components):
-            stateIndex += compStates[i] * prod[i]
-        return stateIndex
-
-    def actionToReplace(self, actionIndex):
-        # input: action index from the optimized policy
-        # output: list of bools indicating which comps to replace
-        prod = self.components * [1]
-        if self.components > 1:
-            for i in range(self.components - 2, -1, -1):
-                prod[i] = prod[i + 1] * 2
-        replace = self.components * [False]
-        for i in range(self.components):
-            if math.floor(actionIndex / prod[i]) > 0:
-                replace[i] = True
-                actionIndex -= prod[i]
-        return replace

mdpsolver-0.9.9/tests/test1.py → mdpsolver-0.9.10/tests/test1_pip.py

@@ -1,8 +1,8 @@
-import mdpsolver
 import random
 import sys
 import numpy as np
 from random import randint
+import mdpsolver
 
 # TEST 1
 # Simple MDP with 3 states and 2 actions in each state.

mdpsolver-0.9.9/tests/test2.py → mdpsolver-0.9.10/tests/test2_pip.py

@@ -1,7 +1,7 @@
-import mdpsolver
 import example_model
 import sys
 import numpy as np
+import mdpsolver
 
 # TEST 2
 # In this test, we load the rewards and transition probabilities