jmarkov 0.0.1__py3-none-any.whl

jmarkov/ctmc.py

@@ -0,0 +1,199 @@
+import numpy as np
+from scipy import linalg
+from scipy import sparse
+from .markov_chain import markov_chain
+
+class ctmc(markov_chain):
+    """
+    Implements a finite continuous-time Markov chain (CTMC) 
+    
+    The chain is defined by its number of states, states, and a 
+    generator matrix. The class provides methods to compute both
+    stationary and transient metrics, as well as to check the 
+    chain properties (ergodicity). 
+    """
+
+    # number of states in string array form
+    n_states:int=1
+
+    # states in string array form
+    states:np.array = np.array([1])
+
+    # generator matrix as 2d numpy array
+    generator:np.array
+    
+    # empty initializer 
+    # chain with a single state
+    def __init__(self):
+        self.n_states = 1
+        self.generator = np.array([0])
+
+    # initializer with only the number of states
+    def __init__(self,n:int):
+        self.n_states = n
+        self.generator = np.zeros((n,n), dtype=float)
+
+    # initializer with a generator matrix
+    def __init__(self,generator:np.array):
+        """
+        Creates a continuous-time Markov chain from its generator matrix
+        """
+        if not self._check_generator_matrix(generator):#Lets check if transition matrix is logical (i.e the rows sum 0)
+            raise ValueError("the rows of generator matrix do not sum 0 or the diagonal has non negative values")
+        self.n_states=generator.shape[0]
+        self.generator = generator
+
+
+    def _check_generator_matrix(self,M:np.ndarray):
+        """
+        Checks that a matrix is a Markov chain generator
+         
+        Checks that all row sums are equal to zero, diagonal entries are non-positive, and 
+        non-diagonal entries are non-negative
+        """
+        #
+        vector = np.isclose(np.sum(M, axis = 1),0,1e-5) == True
+        # Check if a given transition matrix has all diagonal elements non positive
+        if vector.all() and np.all(np.diag(M)<0):
+            return True
+        else:
+            return False
+
+
+    def steady_state(self) -> np.ndarray:
+        """
+        Computes the steady state distribution of the continuous-time Markov chain
+
+        Computes the steady state probability distribution by replacing one of the 
+        matrix equations with a normalizing equation that ensures the result is a 
+        probability distribution. 
+
+        Returns the stationary probability distribution in array form
+        """
+
+        # 
+        if self.generator.any():
+            # sets A to be Q and replace first column with ones for the normalizing equation
+            A = self.generator.copy()
+            A[:, 0] =  1
+            # sets b as the right hand vector with a 1 for the normalizing equation
+            b = np.zeros(self.n_states, dtype=float)
+            b[0] = 1
+            # solves transposed system as pi is a row vector
+            res = linalg.solve(A,b,transposed=True)
+            return res
+        else:    
+            print("Empty generator matrix")
+        return 0
+    
+
+    def transient_probabilities(self,t:float,alpha:np.ndarray) -> np.ndarray:
+        """
+        Computes the transient distribution at time t with initial state alpha
+
+        Computes alpha*exp(Q*t)*ones to obtain the probability distribution
+        at time t given the initial probability distribution alpha
+        """
+        shape=alpha.shape#lets get the shape of alpha vector
+        if shape[0]!=self.n_states:
+            raise ValueError("The dimensions of alpha vector are incorrect. It must be a vector 1xn_states")
+        P=linalg.expm(self.generator*t)#exponentiate the diferential generator following the method of Mohy et al (https://eprints.maths.manchester.ac.uk/1300/1/alhi09a.pdf)
+        probs=alpha@P
+        return probs
+
+
+    def first_passage_time(self, target:str):
+        """
+        Computes the expected first passage time to a target state from a start state.
+
+        This method calculates the expected number of steps required for the Markov chain to reach
+        the specified target state from the start state by creating a sub-matrix of the generator matrix with the target removed.
+
+        Returns the expected steps to reach the target state from any start state (except target) in array form        
+        """
+        #The transition matrix and the number of states are brought
+        e=self.n_states 
+        q=self.generator.copy()
+        
+        # Matrix of ones with n-1 rows is created
+        u=np.full([e-1,1],1)
+
+        #The column and row corresponding to the target state are eliminated from the transition matrix 
+        m=np.delete(q,target, axis=0)
+        m=np.delete(m,target, axis=1)
+
+
+        t=np.matmul(np.linalg.inv(-m),u)
+        return t
+
+    def occupation_time(self,T,Epsilon=0.00001):
+        n=self.n_states
+        m=self.generator.copy()
+        def P_from_R(n,m):            
+            # Inicializamos el valor máximo con el primer elemento de la diagonal
+            Vector_ri=np.diagonal(m)   
+            #Hallamos la r como el máximo de las r_i
+            r=max(-Vector_ri)
+            return r 
+        def creacion_P(n,m):
+            r= P_from_R(n,m)
+            #Hallamos la matriz P^        
+            h=np.zeros((n,n))
+            for i in range(n):
+                for j in range(n):
+                    if i==j:
+                        h[i][j]=1+(m[i][j]/r)
+                    else:
+                        h[i][j]=m[i][j]/r
+            return h 
+        r=P_from_R(n,m)
+        P=creacion_P(n,m)
+        i=np.identity(n)
+        A=P
+        k=0
+        yek=np.exp(-r*T)
+        ygk=1-yek
+        suma=ygk
+        B=ygk*i
+        while suma/r < T-Epsilon:
+            k=k+1
+            yek=yek*(r*T)/k
+            ygk=ygk-yek
+            B=B+ygk*A
+            A=A@P
+            suma=suma+ygk
+        return (B/r)
+    
+
+    def is_irreducible(self):
+        """
+        Checks if the given continous-time Markov Chain is irreducible.
+        
+        This method determines if the continous-time Markov Chain is irreducible by checking if, starting in
+        any state, it is possible to reach any other state in a sequence of transitions.
+
+        Returns a boolean
+        """
+        # the finite case:
+
+        # We bring the generator matrix and replace all the diagonal elements for 0
+        Q = np.copy(self.generator)
+        np.fill_diagonal(Q,0)
+        # We check if all the components in the chain are strongly connected
+        if sparse.csgraph.connected_components(Q, directed=True,connection='strong',return_labels=False)==1:
+            return True
+        else:
+            return False
+
+    def is_ergodic(self):
+        """
+        Checks if a given continous-time Markov Chain is ergodic.
+        
+        Given that a finite continous-time Markov Chain is ergodic if it is irreducible, this
+        method checks if it is irreducible to determine if the provided chain is ergodic or not.
+        """
+        # We check if the chain is irreducible
+        if self.is_irreducible()==True:
+            return True
+        else:
+            return False

jmarkov/dtmc.py

@@ -0,0 +1,216 @@
+import numpy as np
+from scipy import linalg
+from scipy import sparse
+from .markov_chain import markov_chain
+import math
+
+class dtmc(markov_chain):
+    """
+    Implements a finite discrete-time Markov chain (CTMC) 
+    
+    The chain is defined by its number of states, states, and a 
+    transition matrix. The class provides methods to compute both
+    stationary and transient metrics, as well as to check the 
+    chain properties (aperiodicity and ergodicity). 
+    """
+
+    # number of states in string array form
+    n_states:int=1
+
+    # states in string array form   
+    states:np.array = np.array([1])
+
+    # transition matrix as 2d numpy array
+    transition_matrix:np.array
+    
+    # empty initializer 
+    # chain with a single state
+    def __init__(self):
+        """
+        Creates a continuous-time Markov chain from its transition matrix
+        """
+        self.n_states = 1
+        self.transition_matrix = np.array([1])
+
+    # initializer with only the number of states
+    def __init__(self,n:int):
+        self.n_states = n
+        self.transition_matrix = np.eye(n, dtype=float)
+
+    # initializer with a transition matrix
+    def __init__(self,transition_matrix:np.array):
+        if not self._check_transition_matrix(transition_matrix):#Lets check if transition matrix is logical (i.e the rows sum 1)
+            raise ValueError("the rows of transition matrix do not sum 1 or has non positive values")
+        self.n_states=transition_matrix.shape[0]
+        self.transition_matrix = transition_matrix
+
+    def _check_transition_matrix(self, M:np.array):
+        """
+        Checks that a matrix is a Markov chain transition matrix
+         
+        Checks that all entries are non-negative and all row sums are equal to one
+        """
+        #Check if a given transition matrix has the condition that for every row the sum of all elements is equal to 1
+        #Check if a given transition matrix has the condition that every element of the matrix is between 0 and 1
+        if np.all(np.isclose(np.sum(M,axis=1),1,1e-5)) and np.all((M>=0) & (M<=1)):
+            return True
+        else:
+            return False
+        
+
+    def steady_state(self) -> np.ndarray:
+        """
+        Computes the steady state distribution of the discrete-time Markov chain
+
+        Computes the steady state probability distribution by replacing one of the 
+        matrix equations with a normalizing equation that ensures the result is a 
+        probability distribution. 
+
+        Returns the stationary probability distribution in array form
+        """
+        # computes the steady state distribution
+        if self.transition_matrix.any():
+            # sets A to be I-P and replace first column with ones for the normalizing equation
+            A = self.transition_matrix - np.eye(self.n_states, dtype=float)
+            A[:, 0] =  1
+            # sets b as the right hand vector with a 1 for the normalizing equation
+            b = np.zeros(self.n_states, dtype=float)
+            b[0] = 1
+            # solves transposed system as pi is a row vector
+            res = linalg.solve(A,b,transposed=True)
+            return res
+        else:    
+            print("Empty transition matrix")
+        return 0
+    
+
+    def transient_probabilities(self,n,alpha):
+        """
+        Computes the transient distribution at transition n with initial state alpha
+
+        Computes alpha*(P^n)*ones to obtain the probability distribution
+        at time/transition n given the initial probability distribution alpha
+        """
+         
+        #First, lets verify n is integer
+        if not isinstance(n,int):
+            raise ValueError("The number of transitions n must be integer")
+        #Now lets verify the dimensions of the vector alpha:
+        try:
+            shape=alpha.shape
+        except:
+            print("alpha vector must be a numpy array")
+            return None
+        if shape[0]!=self.n_states:
+            raise ValueError("The dimensions of alpha vector are incorrect. It must be a vector 1xn_states")
+        
+        #Computes transient_matrix**n
+        matrix_n=np.linalg.matrix_power(self.transition_matrix,n)
+        vector=alpha@matrix_n
+        return vector
+
+
+    def first_passage_time(self, target:str):
+        """
+        Computes the expected first passage time to a target state from a start state.
+
+        This method calculates the expected number of steps required for the Markov chain to reach
+        the specified target state from the start state by creating a sub-matrix of the transition matrix with the target removed.
+
+        Returns the expected steps to reach the target state from any start state (except target) in array form        
+        """
+        #The transition matrix and the number of states are brought
+        n=self.n_states 
+        M=self.transition_matrix.copy()
+        # The identity matrix is created with size n-1 states
+        i=np.identity(n-1)
+        # Matrix of ones with n-1 rows is created
+        u=np.full([n-1,1],1)
+        # The column and row corresponding to the target state are eliminated from the transition matrix
+        p=np.delete(M,target, axis=0)
+        p=np.delete(p,target, axis=1)
+        
+        t=np.matmul(np.linalg.inv(i-p),u)
+        return t 
+
+    def occupation_time(self, n:int):
+        """
+        Computes the expected occupation time in n steps.
+
+        This method calculates the expected time that the discrete-time Markov chain will remain in each state, from all starting states.
+
+
+        Returns the occupation matrix in array form  
+        """
+        # Create an identity matrix with the same shape of transition matrix
+        occupation=np.eye(self.transition_matrix.shape[0],self.transition_matrix.shape[1])
+        # Iterate for each step
+        for i in range(1,n+1):
+            # Calculate the occupation time for each step, and update the occupation matrix
+            occupation+=np.linalg.matrix_power(self.transition_matrix,i)
+        return occupation
+    
+    def period(self):
+        """
+        Computes the period of a discrete-time Markov Chain.
+        
+        This method calculates the period of a discrete-time Markov Chain by iterating a total of N steps, where N represents
+        the number of states that the chain has. In each k-th iteration, the chain is elevated to the k-th power to compute the
+        transient probabilities in the k-th step. If one of the elementsin in the diagonal of the resulting matrix is greater than 0,
+        the chain can potentially have a period k. The period of the matrix will be the Greatest Common Divisor (GCD) between the
+        potential new period of the matrix in the k-th iteration and the current GCD before the k-th iteration.
+
+        Returns the period of the chain as an int
+        """
+        
+        #Initializes the transition matrix and the greatest common divisor for the periodicity calculations
+        P_k = self.transition_matrix
+        gcd = 0
+        
+        #Loop to elevate the transition matrix to the k th power and evaluate its periodicity:
+        for k in range(2, (self.n_states)+1):
+            P_k = np.dot(self.transition_matrix, P_k)
+            #If the transition matrix to the k-th power has a non-zero element in its diagonal, the chain could have a period k:
+            if np.any(np.diagonal(P_k) != 0):
+                #GCD between the current GCD for the period of the matrix and the potential new GCD
+                gcd = math.gcd(gcd, k)
+            #If the GCD is 1, there is no need to keep looking for the period, the chain is aperiodic:
+            if gcd == 1:
+                break
+        return gcd
+    
+    def is_irreducible(self):
+        """
+        Checks if the given discrete-time Markov Chain is irreducible.
+        
+        This method determines if the discrete-time Markov Chain is irreducible by checking if, starting in
+        any state, it is possible to reach any other state in a sequence of transitions.
+
+        Returns a boolean
+        """
+        # Brings a copy of the transition matrix
+        P = np.copy(self.transition_matrix)
+        # Checks if all the states in the Markov chain are strongly connected
+        if sparse.csgraph.connected_components(P, directed=True,connection='strong',return_labels=False)==1:
+            return True
+        else:
+            return False
+
+    def is_ergodic(self):
+        """
+        Checks if a given discrete-time Markov Chain is ergodic.
+        
+        Given that a finite discrete-time Markov Chain is ergodic if it is aperiodic and irreducible, this
+        method checks if both conditions are met to determine if the provided chain is ergodic or not.
+        
+        Returns a boolean
+        """
+        # Checks if the chain is irreducible and if it has a period of 1
+        if self.period() == 1 & self.is_irreducible() == True:
+            return True
+        else:
+            return False
+    
+
+
+

jmarkov/markov_chain.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+
+class markov_chain(ABC):
+
+    @property
+    @abstractmethod
+    def n_states(self):
+        # number of states
+        pass
+
+    @property
+    @abstractmethod
+    def states(self):
+        # markov chain states
+        pass
+
+    @abstractmethod
+    def steady_state(self):
+        # computes the steady state distribution
+        pass
+
+    @abstractmethod
+    def first_passage_time(self, target:str):
+        # computes the expected first passage time to target state
+        pass
+
+    @abstractmethod
+    def occupation_time(self, nsteps:int):
+        # computes the expected occupation time matrix in nsteps steps
+        pass
+
+    @abstractmethod
+    def is_ergodic(self):
+        # determines id the chain is ergodic or not
+        pass
+

jmarkov/mdp/dtmdp.py

@@ -0,0 +1,219 @@
+import numpy as np
+from typing import Dict
+import sys
+import os.path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..','..')))
+from jmarkov.dtmc import dtmc
+
+class dtmdp():
+    """
+    Implements a Markov decision process (MDP)  
+    
+    The process is defined by its number of states, states, number of actions, actions,
+    the immediate returns of implementing each action and a transition matrix for each action. 
+    The class provides methods to solve MDPs and to compute the expected value of the optimal policy. 
+    """
+    # number of states in string array form
+    n_states:int=1
+    # states in string array form
+    states:np.array = np.array([1])
+    # number of actions
+    n_actions:int=1
+    # actions in array form
+    actions:np.array = np.array([1])
+    # transition matrix as dict of numpy arrays
+    transition_matrices:Dict[str, np.array]
+    # immediate return matrix as 2d numpy array 
+    immediate_returns:np.array = np.array([1])   
+    # discount factor as int
+    discount_factor:int = 0.8 
+    # initializer with a transition matrix, immediate returns and discount factor
+    def __init__(self,states:np.array, actions: np.array, transition_matrices:Dict, immediate_returns: np.array,discount_factor:int):
+        """
+        Creates a markov decision process from its transition matrices, immediate returns and discount factor
+        """
+        if not self._check_transition_matrices(transition_matrices):#Lets check if transition matrix is logical (i.e the rows sum 1)
+            raise ValueError("the rows of transition matrices do not sum 1 or have non positive values")
+        if not self._check_immediate_returns(immediate_returns,transition_matrices): # Lets check if immediate returns are consistent
+            raise ValueError("the dimensions of the immediate returns are not coherent")
+        if not self._check_discount_factor(discount_factor): # Lets check if discount factor is logical
+            raise ValueError("discount factor should be a number between 0 and 1")
+        self.n_actions = len(transition_matrices)
+        self.n_states=len(transition_matrices[next(iter(transition_matrices))])
+        self.transition_matrices = transition_matrices
+        self.immediate_returns = immediate_returns
+        self.discount_factor = discount_factor
+        self.actions = actions
+        self.states = states
+
+    def _check_transition_matrices(self, M:Dict):
+        """
+        Checks that all matrices are stochastic
+         
+        Checks that all row sums are equal to one and all elements are non negative
+        """
+        # determines if the transition matrices are logical
+        # i.e: if the sum of the rows equals to 1 (is an stochastic matrix)
+        # and if all of the elements are positive
+        if all(np.all((np.array(value) >= 0) & (np.array(value) <= 1)) for value in M.values()) and np.all(np.isclose(np.sum(list(M.values()), axis=2), 1, atol=1e-5)):
+            return True
+        else:
+            return False
+        
+    def _check_immediate_returns(self,R:np.array, M:Dict):  
+        """
+        Checks that the immediate returns are valid and dimensionally-coherent
+         
+        Checks that immediate return array has dimensions length of states x length of actions
+        """  
+        # checks if the dimensions of immediate returns are coherent
+        # expected: len(S) x len(actions)
+        if R.shape == (len(list(M.values())[0]),len(M)):
+            return True
+
+    def _check_discount_factor(self,beta:int):
+        """
+        Checks that the discount factor is valid
+         
+        Checks that discount factor is a number equal to or greater than 0 and  less than 1
+        """  
+        # checks if the discount factor is a number between 0 and 1 
+        if beta >= 0 and beta < 1:
+            return True
+        else: 
+            return False
+    
+    def solve(self, tolerance, minimize = False, method = "value_iteration"):
+        """
+        Solves MDP's with defined method
+
+        Returns the expected value of following the optimal policy at each state and the optimal policy for each state
+        """
+        S = self.states
+        A = self.actions
+        M = self.transition_matrices
+        R = self.immediate_returns
+        beta = self.discount_factor
+
+        # if the sense of the search is minimize, change the values of the immediate returns
+        # so that we maximize minimums
+        if minimize == True:
+            R = -1*R
+        
+        if method == "value_iteration":
+            result = value_iteration(S, A, M, R, beta, tolerance)
+            V = result[0]
+            optimal_policy = result[1]
+        elif method == "policy_iteration":
+            result = policy_iteration(S, A, M, R, beta, tolerance)
+            V = result[0]
+            optimal_policy = result[1]
+
+        if minimize == True:
+            V = -1 * V
+        # return the optimal policy
+        return V, optimal_policy
+    
+    def policy_transition_matrix(self, policy):
+        """
+        Calculates the expected value of a policy according 
+
+        Returns the transition matrix for following the optimal policy
+        """
+        # gets the transition matrix for the optimal policy
+        S = self.states
+        M = self.transition_matrices
+        optimal_transition_matrix = []
+        for i in range(0, len(S)):
+            optimal_transition_matrix.append(M[policy[S[i]]][i])
+        optimal_transition_matrix = np.array(optimal_transition_matrix)
+        return optimal_transition_matrix
+        
+    def expected_policy_value(self, value_function, policy):
+        """
+        Calculates the expected value of a policy according to the steady state probability of being in each state
+
+        Returns the expected value of following the optimal policy
+        """
+        # gets the transition matrix for the optimal policy
+        optimal_transition_matrix = self.policy_transition_matrix(policy)
+        # creates the dtmc object
+        mc = dtmc(optimal_transition_matrix)
+        expected_value = sum(mc.steady_state()*value_function)
+        return expected_value
+    
+def value_iteration(S, A, M, R, beta, tolerance):
+    # initialize value functions
+    V = np.zeros(len(S))
+    # initialize optimal policy
+    optimal_policy = {S[i]: A[0] for i in range(0, len(S))}
+    # iterate while there is no improvement
+    while True:
+        # save values from previous iteration
+        oldV = V.copy()
+        # iterate through states
+        for i in range(0, len(S)):
+            # initialize Q -> value-action function
+            Q = {}
+            # iterate through actions
+            for a in range(0,len(A)):
+                # evaluate the new value function
+                Q[A[a]] = R[i, a] + beta*sum(M[A[a]][i,j]*oldV[j] for j in range(0, len(S)))
+                # update the new value function for each state
+                V[i] = max(Q.values())
+                # update the action for each state
+                optimal_policy[S[i]] = max(Q, key = Q.get)
+
+        # if there is no improvement break the cycle
+        if np.allclose(oldV, V, tolerance):
+            break
+    return V, optimal_policy
+
+def policy_improvement(V, S, A, M, R, beta):
+    # initialize optimal policy
+    optimal_policy = {S[i]: A[0] for i in range(0, len(S))}
+    # iterate through states
+    for i in range(0, len(S)):
+        # initialize Q -> value-action function
+        Q = {}
+        # iterate through actions
+        for a in range(0, len(A)):
+            # evaluate the new value function
+            Q[A[a]] = R[i,a] + beta*sum(M[A[a]][i,j]*V[j] for j in range(0, len(S)))
+        # update the action for each state
+        optimal_policy[S[i]] = max(Q, key = Q.get)
+    return optimal_policy
+
+def policy_evaluation(policy, S, A, M, R, beta, tolerance):
+    # initialize value functions
+    V = np.zeros(len(S))
+    # iterate while there is improvement
+    while True:
+        # save old values of value functions
+        oldV = V.copy()
+        # iterate through states
+        for i in range(0,len(S)):
+            # save current policy
+            a = np.where(A == policy[S[i]])[0][0]
+            # evaluate the current policy for each state
+            V[i] = R[i,a] + beta*sum(M[A[a]][i,j]*V[j] for j in range(0,len(S)))
+        # if there is no improvement break the cycle    
+        if np.allclose(oldV, V, tolerance):
+            break
+    return V
+
+def policy_iteration(S, A, M, R, beta, tolerance):
+    # initialize optimal policy
+    optimal_policy = {S[i]: A[0] for i in range(0, len(S))}
+    # iterate while there is improvement
+    while True:
+        # save values of current policy
+        old_policy = optimal_policy.copy()
+        # evaluate current policy
+        V = policy_evaluation(optimal_policy, S, A, M, R, beta, tolerance)
+        # improve current policy
+        optimal_policy = policy_improvement(V, S, A, M, R, beta)
+        # if old policy and new policy are the same (there is no improvement) break cycle 
+        if all(old_policy[S[i]] == optimal_policy[S[i]] for i in range(0, len(S))):
+            break
+    return V, optimal_policy

jmarkov/phase/ctph.py

@@ -0,0 +1,59 @@
+import numpy as np
+from scipy import linalg
+from scipy import sparse
+
+class ctph():
+
+    # number of phases
+    n_phases:int=1
+
+    # subgenerator matrix as 2d numpy array
+    T:np.array
+
+    # initial phase vector as 1d numpy array
+    alpha:np.array
+    
+    # empty initializer 
+    # chain with a single state
+    def __init__(self):
+        self.n_phases = 1
+        self.T = np.array([-1])
+        self.alpha = np.array([1])
+
+    # initializer with only the number of states
+    def __init__(self,n:int):
+        self.n_phases = n
+        self.generator = -1*np.eye(n, dtype=float)
+        self.alpha = np.zeros(n, dtype=float)
+        self.alpha[0] = 1
+
+    # initializer with both alpha and T
+    def __init__(self, alpha:np.array, T:np.array):
+        if not self._check_sub_generator_matrix(T): #Lets check if transition matrix is logical (i.e the rows sum 0)
+            raise ValueError("the rows of transition matrix do not sum 0 or the diagonal has non negative values")
+        self.n_phases=T.shape[0]
+        self.T = T
+        shape = alpha.shape
+        if shape[0]!=self.n_phases:
+            raise ValueError("The dimensions of alpha vector are incorrect. Its length must coincide with the size of T")
+        self.alpha = alpha
+
+    def _check_sub_generator_matrix(self, M:np.ndarray):
+        #Check if a given rate matrix has the condition that every row sum <= 0, with at least one < 0 
+        check1 = np.max(np.sum(M, axis = 1)) <= 0 and np.min(np.sum(M, axis = 1)) < 0 
+        # Check if a given transition matrix has all diagonal elements non positive
+        if check1 and np.all(np.diag(M)<0):
+            return True
+        else:
+            return False
+
+    def pdf(self,t:float) -> np.float64:
+        P=linalg.expm(self.T*t)  #exponentiate the diferential generator following the method of Mohy et al (https://eprints.maths.manchester.ac.uk/1300/1/alhi09a.pdf)
+        probs=self.alpha@P
+        return sum(probs)
+
+
+    def expected_value(self):
+        # Compute the expected value as alpha*inv(T)*one
+        return np.sum(self.alpha@np.linalg.inv(-self.T))
+

jmarkov/phase/dtph.py

@@ -0,0 +1,57 @@
+import numpy as np
+from scipy import linalg
+from scipy import sparse
+
+class dtph():
+
+    # number of phases
+    n_phases:int=1
+
+    # substochastic matrix as 2d numpy array
+    T:np.array
+
+    # initial phase vector as 1d numpy array
+    alpha:np.array
+    
+    # empty initializer 
+    # chain with a single state
+    def __init__(self):
+        self.n_phases = 1
+        self.T = np.array([0.8])
+        self.alpha = np.array([1])
+
+    # initializer with only the number of states
+    def __init__(self,n:int):
+        self.n_phases = n
+        self.generator = np.zeros((n,n), dtype=float)
+        self.alpha = np.zeros(n, dtype=float)
+        self.alpha[0] = 1
+
+    # initializer with both alpha and T
+    def __init__(self, alpha:np.array, T:np.array):
+        if not self._check_sub_stochastic_matrix(T): #Lets check if transition matrix is logical (i.e the rows sum <=1)
+            raise ValueError("the rows of transition matrix do not sum <= 1")
+        self.n_phases=T.shape[0]
+        self.T = T
+        shape = alpha.shape
+        if shape[0]!=self.n_phases:
+            raise ValueError("The dimensions of alpha vector are incorrect. Its length must coincide with the size of T")
+        self.alpha = alpha
+
+    def _check_sub_stochastic_matrix(self, M:np.ndarray):
+        #Check if a given rate matrix has the condition that every row sum <= 0, with at least one < 0 
+        if np.max(np.sum(M, axis = 1)) <= 1 and np.min(np.sum(M, axis = 1)) < 1:
+            return True
+        else:
+            return False
+
+    def pmf(self,n:int) -> np.float64:
+        P=np.linalg.matrix_power(self.T,n)
+        probs=self.alpha@P
+        return sum(probs)
+
+
+    def expected_value(self):
+        # Compute the expected value as alpha*inv(I - T)*one
+        return np.sum(self.alpha@(np.eye(self.n_phases) -  np.linalg.inv(-self.T)))
+

jmarkov-0.0.1.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.3
+Name: jmarkov
+Version: 0.0.1
+Summary: A python package for Markov chain modeling
+Project-URL: Homepage, https://github.com/copa-uniandes/jmarkov
+Project-URL: Issues, https://github.com/copa-uniandes/jmarkov/issues
+Author-email: Juan F Perez <juanfernando.perez@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: typing
+Description-Content-Type: text/markdown
+
+# jmarkov
+jMarkov is a library to simplify the modeling of systems with Markov chains.

jmarkov-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+jmarkov/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jmarkov/ctmc.py,sha256=JV1G1qBWNecnqrZXrplQrPZ1BT27fu27u07bt-V5EF0,7283
+jmarkov/dtmc.py,sha256=6H-lfaelR5j9cbIOpVgCHEMGXUjT_n12z3Q9tGsbjUI,9180
+jmarkov/markov_chain.py,sha256=IdJxqfudti4lceWfpRR-r3vy0AbbsGNzjP662HPCF10,816
+jmarkov/mdp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jmarkov/mdp/dtmdp.py,sha256=0W31b8ebqE75SqjnLawUHgBLRfzLhAfh4KAj6IBpUEw,9373
+jmarkov/phase/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jmarkov/phase/ctph.py,sha256=29vKGGaFPBVj7DndO5CGFBna_2JWOzyTtfjy2kWzF-w,2159
+jmarkov/phase/dtph.py,sha256=m7YQGpOarxYYFEYQl4XRy65FXY5n1mhvBv8A07ncZb4,1899
+jmarkov-0.0.1.dist-info/METADATA,sha256=JuyPvbb7Qxp3ouGr4D668KIBBsbhtWi0E2oddYbTHPs,677
+jmarkov-0.0.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+jmarkov-0.0.1.dist-info/licenses/LICENSE,sha256=bDkGfTup1HnHpyVtgn2N5sZUHHhux3olwawM3_ijDiM,14474
+jmarkov-0.0.1.dist-info/RECORD,,

jmarkov-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any

jmarkov-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,277 @@
+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  d) Each Contributor represents that to its knowledge it has
+  sufficient copyright rights in its Contribution, if any, to grant
+  the copyright license set forth in this Agreement.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following
+Secondary Licenses when the conditions for such availability set forth
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.