mdpsolver 0.11.0__cp315-cp315-win_amd64.whl

mdpsolver/__init__.py

@@ -0,0 +1,12 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_13_0():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'mdpsolver.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_0()
+del _delvewheel_patch_1_13_0
+# end delvewheel patch
+
+from mdpsolver.model import model, ConvergenceWarning

mdpsolver/model.py

@@ -0,0 +1,398 @@
+"""
+MDPSolver
+
+This file defines a `model` class that wraps around the `solvermodule` to create
+and solve Markov Decision Processes (MDPs). It provides methods to configure the model,
+solve it, and extract the resulting policy and value vectors.
+"""
+
+import numbers
+import warnings
+from mdpsolver import solvermodule
+
+
+class ConvergenceWarning(UserWarning):
+    """
+    Issued by solve() when a run has not converged.
+    """
+
+def _openError(fileName, mode="r"):
+    """The OSError raised when the file is opened in the given mode, or None if it can be opened."""
+    try:
+        with open(fileName, mode):
+            pass
+    except OSError as error:
+        return error
+    return None
+
+
+class model:
+    """
+    Creates an MDPSolver object.
+
+    This class provides methods to initialize, solve, and return results
+    from an MDP model.
+    """
+
+    def __init__(self):
+        """Initialize the model by creating a solver module object."""
+        self.initialize()
+
+    def initialize(self):
+        """Create and initialize the solver module object."""
+        self.mdl = solvermodule.Model()
+        # A model object contains only one model
+        self._modelDefined = False
+        self._solved = False
+
+    def _requireSolution(self, method):
+        """
+        Raise RuntimeError unless solve() has run on this model object.
+        """
+        if not self._modelDefined:
+            raise RuntimeError("No model has been defined and solved for this model object, so %s() has no solution to use. Call mdp() and then solve() first." % method)
+        if not self._solved:
+            raise RuntimeError("The model has not been solved yet, so %s() has no solution to use. Call solve() first." % method)
+
+    def solve(
+        self,
+        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.
+
+        Args:
+            algorithm (str): Algorithm to use.
+            tolerance (float): Convergence threshold for the algorithm (0 < tolerance < 1).
+            update (str): The value-update method ('standard', 'gs' or 'sor'; only 'standard' with the average reward criterion).
+            criterion (str): The optimality criterion.
+            parIterLim (int): The partial evaluation limit employed in the modified policy iteration algorithm.
+            SORrelaxation (float): Relaxation parameter for the Successive Over-Relaxation method.
+            initPolicy (list): A 1D-list defining the initial policy, one valid action index per state. This option can be used for "warm starting" the optimization procedure.
+            initValueVector (list): A 1D-list defining the initial value vector, one value per state. This option can be used for "warm starting" the optimization procedure.
+            verbose (bool): If True, prints solver progress to console.
+            postProcessing (bool): If True, performs post-processing after solving.
+            makeFinalCheck (bool): If True, makes a final check of the value vector. This process checks if the resulting values are reasonable.
+            parallel (bool): If True, enables parallel computation for faster solving. This option is only available for the custom MDP model with standard updates.
+
+        Call mdp() to define the model first. Solving the same model object
+        again starts from the policy and the value vector of the previous run,
+        unless initPolicy or initValueVector replace them. Create a new model
+        object to start over.
+
+        Returns:
+            None
+        """
+        
+        if not self._modelDefined:
+            raise RuntimeError("No model has been defined for this model object. Call mdp() before solve().")
+        if not (algorithm == "mpi" or algorithm == "pi" or algorithm == "vi"):
+            raise ValueError("Algorithm type not recognized. Select either: 'mpi', 'pi', or 'vi'.")
+        if tolerance <= 0.0 or tolerance >= 1.0:
+            raise ValueError("The tolerance needs to be between 0.0 and 1.0 (i.e. 0 < tolerance < 1).")
+        if not (update == "standard" or update == "gs" or update == "sor"):
+            raise ValueError("Update method not recognized. Select either: 'standard', 'gs', or 'sor'.")
+        if not (criterion == "discounted" or criterion == "average"):
+            raise ValueError("Optimality criterion not recognized. Select either: 'discounted' or 'average'.")
+        if criterion == "average" and (update == "gs" or update == "sor"):
+            raise ValueError("Gauss-Seidel and SOR updates are not available with the average reward criterion. Select update='standard'.")
+        if parIterLim <= 0 and algorithm == "mpi":
+            raise ValueError("The partial evaluation limit needs to be a positive number.")
+        if (SORrelaxation <= 0.0 or SORrelaxation >= 2.0) and update == "sor":
+            raise ValueError("The relaxation parameter needs to be between 0.0 and 2.0 (i.e. 0 < SORrelaxation < 2).")
+        if len(initPolicy) > 0 or len(initValueVector) > 0:
+            numberOfStates = self.mdl.getNumberOfStates()
+            if numberOfStates >= 0 and len(initPolicy) > 0 and len(initPolicy) != numberOfStates:
+                raise ValueError("The initial policy needs one action index per state (the model has %d states, initPolicy has %d elements)." % (numberOfStates, len(initPolicy)))
+            if numberOfStates >= 0 and len(initValueVector) > 0 and len(initValueVector) != numberOfStates:
+                raise ValueError("The initial value vector needs one value per state (the model has %d states, initValueVector has %d elements)." % (numberOfStates, len(initValueVector)))
+            for stateIndex, value in enumerate(initValueVector):
+                if not isinstance(value, numbers.Real):
+                    raise TypeError("The initial value vector needs a number for every state (state %d has %r)." % (stateIndex, value))
+            if numberOfStates >= 0 and len(initPolicy) > 0:
+                for stateIndex, action in enumerate(initPolicy):
+                    if not isinstance(action, numbers.Integral):
+                        raise TypeError("The initial policy needs an integer action index for every state (state %d has %r)." % (stateIndex, action))
+                    numberOfActions = self.mdl.getNumberOfActions(stateIndex=stateIndex)
+                    if not 0 <= action < numberOfActions:
+                        raise ValueError("The initial policy assigns action %s to state %d, which has %d actions (indices 0 to %d)." % (action, stateIndex, numberOfActions, numberOfActions - 1))
+
+        # The solver keeps the policy and the value vector of the previous run,
+        # unless initPolicy or initValueVector replace them.
+
+        if self._solved:
+            # Value iteration never uses the policy it starts from
+            reusesPolicy = len(initPolicy) == 0 and algorithm != "vi"
+            reusesValueVector = len(initValueVector) == 0
+            if reusesPolicy or reusesValueVector:
+                print("Note: This model has been solved before. Create a new model object to run solver with initial values.", flush=True)
+
+        self.mdl.solve(
+            algorithm=algorithm,
+            tolerance=tolerance,
+            update=update,
+            criterion=criterion,
+            parIterLim=parIterLim,
+            SORrelaxation=SORrelaxation,
+            initPolicy=initPolicy,
+            initValueVector=initValueVector,
+            verbose=verbose,
+            postProcessing=postProcessing,
+            makeFinalCheck=makeFinalCheck,
+            parallel=parallel,
+        )
+        # Set after the run, so that a run that did not finish leaves the
+        # object without a solution
+        self._solved = True
+
+        convergence = self.mdl.getConvergence()
+        hint = " Under the average reward criterion, this happens with periodic models." if criterion == "average" else ""
+        if convergence["iterationLimitReached"]:
+            warnings.warn("solve() stopped at the iteration limit of %d iterations before reaching the tolerance, so the results have not converged.%s" % (convergence["iterationLimit"], hint), ConvergenceWarning, stacklevel=2)
+        elif convergence["evaluationLimitReached"]:
+            warnings.warn("A policy evaluation of policy iteration stopped at its limit of %d iterations before reaching the tolerance, so the results have not converged.%s" % (convergence["iterationLimit"], hint), ConvergenceWarning, stacklevel=2)
+        if convergence["valuesOutOfRange"] and not postProcessing and update == "standard":
+            # The values are left uncorrected, and may lie outside the range
+            # even when the policy is right
+            warnings.warn("The final check found the value %r in state %d, outside the range that the rewards and the discount allow. With postProcessing=False, the values are not corrected and may lie outside it; use postProcessing=True for correct values, or makeFinalCheck=False to skip the check." % (convergence["outOfRangeValue"], convergence["outOfRangeState"]), ConvergenceWarning, stacklevel=2)
+        elif convergence["valuesOutOfRange"]:
+            warnings.warn("The final check found the value %r in state %d, outside the range that the rewards and the discount allow, so the results are wrong. checkModel() can look for errors in the model." % (convergence["outOfRangeValue"], convergence["outOfRangeState"]), ConvergenceWarning, stacklevel=2)
+        elif convergence["diverged"]:
+            warnings.warn("solve() stopped because the values became infinite or NaN, so the results are wrong. checkModel() can look for errors in the model.", ConvergenceWarning, stacklevel=2)
+
+    def hasConverged(self) -> bool:
+        """
+        Whether the last run of solve() converged.
+
+        Returns:
+            bool: True if the last run converged.
+        """
+        self._requireSolution("hasConverged")
+        return bool(self.mdl.getConvergence()["converged"])
+
+    def checkModel(self, tolerance: float = 1e-9) -> list:
+        """
+        Check the model defined by mdp() for errors, and describe each kind of
+        problem found. The check reads the whole model, so it is never run by
+        mdp() or solve(); call it when the results look wrong or the model may
+        be malformed.
+
+        Args:
+            tolerance (float): How far the probabilities of a state-action pair may sum from 1.
+
+        Returns:
+            list: One message per kind of problem, with how many were found and the first examples. Empty if none was found.
+        """
+        if not self._modelDefined:
+            raise RuntimeError("No model has been defined for this model object. Call mdp() before checkModel().")
+        if not isinstance(tolerance, numbers.Real) or not tolerance >= 0.0:
+            raise ValueError("The tolerance of checkModel() needs to be zero or a positive number.")
+        return list(self.mdl.checkModel(tolerance=tolerance))
+
+    def getRuntime(self) -> float:
+        """
+        Get the runtime of the last solver execution.
+
+        Returns:
+            float: Runtime in milliseconds.
+        """
+        self._requireSolution("getRuntime")
+        return self.mdl.getRuntime()
+
+    def getIterations(self) -> int:
+        """
+        Get the number of iterations of the last solver execution.
+        An iteration is one policy improvement step, i.e. one update that
+        chooses the best action in every state.
+
+        Returns:
+            int: Number of iterations.
+        """
+        self._requireSolution("getIterations")
+        return self.mdl.getIterations()
+
+    def printPolicy(self) -> None:
+        """Print the entire policy to the terminal."""
+        self._requireSolution("printPolicy")
+        self.mdl.printPolicy()
+
+    def printValueVector(self) -> None:
+        """Print the entire value vector to the terminal."""
+        self._requireSolution("printValueVector")
+        self.mdl.printValueVector()
+
+    def getAction(self, stateIndex: int = 0) -> int:
+        """
+        Get the action from the optimized policy for a specific state.
+
+        Args:
+            stateIndex (int): Index of the state.
+
+        Returns:
+            int: Action for the given state.
+
+        Raises IndexError for a state outside the model.
+        """
+        self._requireSolution("getAction")
+        return self.mdl.getAction(stateIndex=stateIndex)
+
+    def getValue(self, stateIndex: int = 0) -> float:
+        """
+        Get the value from the optimized value vector for a specific state.
+
+        Args:
+            stateIndex (int): Index of the state.
+
+        Returns:
+            float: Value for the given state.
+
+        Raises IndexError for a state outside the model.
+        """
+        self._requireSolution("getValue")
+        return self.mdl.getValue(stateIndex=stateIndex)
+
+    def getPolicy(self) -> list:
+        """
+        Get the entire optimized policy.
+
+        Returns:
+            list: Optimized policy.
+        """
+        self._requireSolution("getPolicy")
+        return self.mdl.getPolicy()
+
+    def getValueVector(self):
+        """
+        Get the entire optimized value vector.
+
+        Returns:
+            list: Optimized value vector.
+        """
+        self._requireSolution("getValueVector")
+        return self.mdl.getValueVector()
+
+    def saveToFile(self, fileName: str = "result.csv", type: str = "policy") -> None:
+        """
+        Save the optimized policy or value vector to a file.
+
+        Args:
+            fileName (str): Name of the output file.
+            type (str): Type of result to save ('policy' or 'value').
+
+        Returns:
+            None
+        """
+        
+        self._requireSolution("saveToFile")
+        if not (type == "policy" or type == "value"):
+            raise ValueError("Type not recognized. Select either: 'policy' or 'value'.")
+        error = _openError(fileName, "w")
+        if error is not None:
+            # (the argument type hides the built-in type())
+            raise error.__class__("The file %s could not be opened for writing (%s)." % (fileName, error.strerror or error))
+
+        return self.mdl.saveToFile(fileName=fileName, type=type)
+
+    def mdp(
+        self,
+        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.
+
+        Args:
+            discount (float): Discount factor.
+            rewards (list): A 2D-list containing the reward (float) of a particular action in a particular state.
+            rewardsElementwise (list): Alternative reward format. A 2D-list where each row corresponds to a combination of a state and an action.
+            rewardsFromFile (str): Load the rewards from a comma-separated (,) file.
+            tranMatWithZeros (list): A 3D-list containing the transition probabilities.
+            tranMatElementwise (list): Sparse transition probabilities (option 1). A 2D-list where each row corresponds to a combination of a current state, an action, and a next state.
+            tranMatProbs (list): Sparse transition probabilities (option 2, part 1). A 3D-list containing the non-zero transition probabilities.
+            tranMatColumns (list): Sparse transition probabilities (option 2, part 2). A 3D-list containing the columns of the non-zero transition probabilities.
+            tranMatFromFile (str): Load the transition probabilities from a comma-separated (,) file.
+
+        Give the rewards in one format and the transition probabilities in one
+        format. When no list is given for either, it is read from the file
+        named by rewardsFromFile or tranMatFromFile, by default rewards.csv or
+        transitions.csv in the working directory.
+
+        A model object holds one model, so mdp() can be called only once per
+        model object. Create a new model object to define another model.
+
+        Returns:
+            None
+        """
+        
+        if self._modelDefined:
+            raise RuntimeError("A model has already been defined for this model object, and mdp() can only be called once per model object. Create a new model object (e.g. mdl = mdpsolver.model()) to define another model.")
+        if discount <= 0.0 or discount >= 1.0:
+            raise ValueError("The discount needs to be in the interval between 0.0 and 1.0 (i.e. 0 < discount < 1).")
+        
+        # The formats given. A file name other than the default counts as
+        # given; the default file is read only when no list is given.
+        if (len(tranMatProbs) > 0) != (len(tranMatColumns) > 0):
+            given, missing = ("tranMatProbs", "tranMatColumns") if len(tranMatProbs) > 0 else ("tranMatColumns", "tranMatProbs")
+            raise ValueError("%s was given without %s. This format needs both: the non-zero transition probabilities in tranMatProbs and their next states in tranMatColumns." % (given, missing))
+        rewardFormats = [name for name, isGiven in (
+            ("rewards", len(rewards) > 0),
+            ("rewardsElementwise", len(rewardsElementwise) > 0),
+            ("rewardsFromFile", rewardsFromFile != "rewards.csv")) if isGiven]
+        tranMatFormats = [name for name, isGiven in (
+            ("tranMatWithZeros", len(tranMatWithZeros) > 0),
+            ("tranMatElementwise", len(tranMatElementwise) > 0),
+            ("tranMatProbs and tranMatColumns", len(tranMatProbs) > 0),
+            ("tranMatFromFile", tranMatFromFile != "transitions.csv")) if isGiven]
+        if len(rewardFormats) > 1:
+            raise ValueError("The rewards were given in more than one format (%s). Give them in one format only." % ", ".join(rewardFormats))
+        if len(tranMatFormats) > 1:
+            raise ValueError("The transition probabilities were given in more than one format (%s). Give them in one format only." % ", ".join(tranMatFormats))
+
+        # A file that cannot be opened would leave the model without rewards
+        # or transition probabilities
+        # (raised as the OSError that opening the file gave, e.g. FileNotFoundError)
+        if rewardFormats in ([], ["rewardsFromFile"]):
+            error = _openError(rewardsFromFile)
+            if error is not None and rewardFormats:
+                raise type(error)("The rewards file %s could not be opened (%s)." % (rewardsFromFile, error.strerror or error))
+            if error is not None:
+                raise type(error)("No rewards were given, and the file %s, which is read when none are given, could not be opened (%s). Give the rewards with rewards, rewardsElementwise or rewardsFromFile." % (rewardsFromFile, error.strerror or error))
+        if tranMatFormats in ([], ["tranMatFromFile"]):
+            error = _openError(tranMatFromFile)
+            if error is not None and tranMatFormats:
+                raise type(error)("The transition probabilities file %s could not be opened (%s)." % (tranMatFromFile, error.strerror or error))
+            if error is not None:
+                raise type(error)("No transition probabilities were given, and the file %s, which is read when none are given, could not be opened (%s). Give the transition probabilities with tranMatWithZeros, tranMatElementwise, tranMatProbs and tranMatColumns, or tranMatFromFile." % (tranMatFromFile, error.strerror or error))
+
+        # Set before loading, so that a load that fails halfway cannot be
+        # followed by another into the same object
+        self._modelDefined = True
+        self.mdl.mdp(
+            discount=discount,
+            rewards=rewards,
+            rewardsElementwise=rewardsElementwise,
+            rewardsFromFile=rewardsFromFile,
+            tranMatWithZeros=tranMatWithZeros,
+            tranMatElementwise=tranMatElementwise,
+            tranMatProbs=tranMatProbs,
+            tranMatColumns=tranMatColumns,
+            tranMatFromFile=tranMatFromFile,
+        )

mdpsolver-0.11.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.0
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-95fte76u\\cp315-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-95fte76u\\cp315-win_amd64\\repaired_wheel', '-v', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-95fte76u\\cp315-win_amd64\\built_wheel\\mdpsolver-0.11.0-cp315-cp315-win_amd64.whl']

mdpsolver-0.11.0.dist-info/METADATA

@@ -0,0 +1,194 @@
+Metadata-Version: 2.2
+Name: mdpsolver
+Version: 0.11.0
+Summary: A fast Python solver for Markov Decision Processes
+Author-Email: Anders Reenberg Andersen <andersra@live.dk>, Jesper Fink Andersen <jesperfinkandersen@gmail.com>
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Project-URL: Homepage, https://github.com/areenberg/MDPSolver
+Project-URL: Issues, https://github.com/areenberg/MDPSolver/issues
+Requires-Python: >=3.10
+Provides-Extra: test
+Requires-Dist: numpy; extra == "test"
+Description-Content-Type: text/markdown
+
+# MDPSolver
+
+<img src="https://raw.githubusercontent.com/areenberg/MDPSolver/master/Images/MDPSolver_logo_3.png" alt="Logo" width="180">
+
+[![PyPI](https://img.shields.io/pypi/v/mdpsolver)](https://pypi.org/project/mdpsolver/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/areenberg/MDPSolver/blob/master/LICENSE)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.07544/status.svg)](https://doi.org/10.21105/joss.07544)
+
+MDPSolver is a Python package for large Markov Decision Processes (MDPs) with infinite-horizons. 
+
+## Features
+
+* Fast solver: Our C++-based solver is substantially faster than other CPU-based MDP packages available for Python. See details in the documentation.
+* Two optimality criteria: *Discounted* and *Average* reward.
+* Three optimization algorithms: *Value iteration*, *Policy iteration*, and *Modified policy iteration*.
+* Three value-update methods: *Standard*, *Gauss–Seidel*, and *Successive over-relaxation*.
+* Supports sparse matrices.
+* Employs parallel computing.
+
+# Installation
+
+Install directly from PyPI with:
+
+```
+pip install mdpsolver
+```
+
+# Quick start guide
+
+The following shows how to get quickly started with `mdpsolver`.
+
+## Usage
+
+Start by specifying the reward function and transition probabilities as lists. The following is an example of a simple MDP containing **three states** and **two actions in each state**.
+
+```python
+#Import packages
+import mdpsolver
+
+#Rewards (3 states x 2 actions)
+#e.g. choosing second action in first state gives reward=-1
+rewards = [[5,-1],
+           [1,-2],
+           [50,0]]
+
+#Transition probabilities (3 from_states x 2 actions x 3 to_states)
+#e.g. choosing first action in third state gives a probability of 0.6 of staying in third state
+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]]]
+```
+
+Now, create the model object and insert the problem parameters.
+
+```python
+#Create model object
+mdl = mdpsolver.model()
+
+#Insert the problem parameters
+mdl.mdp(discount=0.8,
+        rewards=rewards,
+        tranMatWithZeros=tranMatWithZeros)
+```
+
+We can now optimize the policy.
+
+```python
+mdl.solve()
+```
+
+The optimized policy can be returned in a variety of ways. Here, we return the policy as a list and print directly in the terminal. 
+
+```python
+print(mdl.getPolicy())
+#[1, 1, 0]
+```
+
+## Sparse transition matrix?
+
+`mdpsolver` has three alternative formats for large and highly sparse transition probability matrices.
+
+**(1) Elementwise representation (excluding elements containing zeros):**
+
+```python
+#[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]]
+
+mdl = mdpsolver.model()
+mdl.mdp(discount=0.8,
+        rewards=rewards,
+        tranMatElementwise=tranMatElementwise)
+```
+
+**(2) Probabilities and column (to_state) indices in separate lists:**
+
+```python
+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]]]
+
+mdl = mdpsolver.model()
+mdl.mdp(discount=0.8,
+        rewards=rewards,
+        tranMatProbs=tranMatProbs,
+        tranMatColumns=tranMatColumns)
+
+```
+
+**(3) Load the elementwise representation from a file:**
+
+**transitions.csv**
+```
+stateFrom,action,stateTo,probability
+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
+```
+
+```python
+mdl = mdpsolver.model()
+mdl.mdp(discount=0.8,
+        rewards=rewards,
+        tranMatFromFile="transitions.csv")
+```
+
+# Documentation
+
+The documentation can be found in the [wiki for MDPSolver](https://github.com/areenberg/MDPSolver/wiki).
+
+# How to cite
+
+*Andersen et al., (2025). MDPSolver: An Efficient Solver for Markov Decision Processes. Journal of Open Source Software, 10(109), 7544, https://doi.org/10.21105/joss.07544*
+
+**BibTeX**
+```
+@article{Andersen2025,
+        doi = {10.21105/joss.07544},
+        url = {https://doi.org/10.21105/joss.07544},
+        year = {2025}, publisher = {The Open Journal},
+        volume = {10},
+        number = {109},
+        pages = {7544},
+        author = {Anders Reenberg Andersen and Jesper Fink Andersen},
+        title = {MDPSolver: An Efficient Solver for Markov Decision Processes},
+        journal = {Journal of Open Source Software} }
+```

mdpsolver-0.11.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+mdpsolver/model.py,sha256=srVyrp3Yfy-PZaxw_n3OLrMjDwzcqMqlRHF2mfawqNk,20932
+mdpsolver/solvermodule.cp315-win_amd64.pyd,sha256=S7Iwj8ML2AVAzahnlohIEM2ai-CJ58kfZusAm87LqHY,368128
+mdpsolver/__init__.py,sha256=hqapLUmvBsbefEfsyiHfapV5v8XFKNJGTOLtD_xmoyA,386
+mdpsolver-0.11.0.dist-info/DELVEWHEEL,sha256=CHkyZcssx9iHzmk9F_NIItKg8ZKgzjPfueLzTkFNWOU,409
+mdpsolver-0.11.0.dist-info/METADATA,sha256=wFcoi4bBVzlyPYX-BE1Ry9-qrkZPsRJ1wdH-u8mOmIo,5723
+mdpsolver-0.11.0.dist-info/RECORD,,
+mdpsolver-0.11.0.dist-info/WHEEL,sha256=m_QT_bq-mMsHZpYGIpEBVccZC7Hu7h_-ha-581a-KNs,105
+mdpsolver-0.11.0.dist-info/licenses/LICENSE,sha256=4H3KqQWsxPS05-NFzPZWIh5d1dAADF2Oud2OdjUubrA,1127
+mdpsolver.libs/libomp140.x86_64-4a20c1e5c115c29771a12324513eb109.dll,sha256=SiDB5cEVwpdxoSMkUT6xCbraxyGA95SBUnrXnZlv-zM,661856
+mdpsolver.libs/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056

mdpsolver-0.11.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.1.2
+Root-Is-Purelib: false
+Tag: cp315-cp315-win_amd64
+

mdpsolver-0.11.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anders Reenberg Andersen and Jesper Fink Andersen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.