tmc and markov creation files

tmc.py

+import numpy as np
+import random as rd
+from openpyxl import Workbook
+
+class TransitionMatrixCalculator:
+    def __init__(self):
+        # Initialisation des matrices de transition pour les dés "safe", "normal" et "risky"
+        self.matrix_safe = np.zeros((15, 15))
+        self.matrix_normal = np.zeros((15, 15))
+        self.matrix_risky = np.zeros((15, 15))
+        # Probability to go from state k to k'
+        self.safe_dice = np.array([1/2,1/2])
+        self.normal_dice = np.array([1/3,1/3,1/3])
+        self.risky_dice = np.array([1/4, 1/4, 1/4, 1/4])
+    
+    def compute_transition_matrix(self, layout, circle=False):
+        self.matrix_safe.fill(0)
+        self.matrix_normal.fill(0)
+        self.matrix_risky.fill(0)
+
+        self._compute_safe_matrix(layout, circle)
+        self._compute_normal_matrix(layout, circle)
+        self._compute_risky_matrix(layout, circle)
+
+        return self.matrix_safe, self.matrix_normal, self.matrix_risky
+
+
+    def _compute_safe_matrix(self, layout, circle):
+        for k in range(0,15):
+            for s, p in enumerate(self.safe_dice):
+                if k == 9 and s == 1:
+                    k_prime = 14
+                    self.matrix_safe[k,k_prime] += p
+                elif k == 2 and s > 0:
+                    p /= 2
+                    k_prime = 10
+                    self.matrix_safe[k,k_prime] += p
+                    k_prime = 3
+                    self.matrix_safe[k,k_prime] += p
+                else:
+                    k_prime = k + s
+                    k_prime = min(14, k_prime)
+                    self.matrix_safe[k,k_prime] += p
+
+        return self.matrix_safe
+
+    def _compute_normal_matrix(self, layout, circle):
+        for k in range(0, 15):
+            for s, p in enumerate(self.normal_dice):
+                if k == 8 and s == 2:
+                    k_prime = 14
+                    self.matrix_normal[k,k_prime] += p
+                    continue
+                elif k == 9 and s in [1, 2]:
+                    if not circle or s == 1:
+                        k_prime = 14
+                        self.matrix_normal[k,k_prime] += p
+                    elif circle and s == 2:
+                        k_prime = 0
+                        self.matrix_normal[k,k_prime] += p
+                    continue
+
+                # handle the fast lane
+                if k == 2 and s > 0:
+                    p /= 2
+                    k_prime = 10 + (s - 1)
+                    if layout[k_prime] in [0, 3]:  # normal or prison square
+                        self.matrix_normal[k,k_prime] += p
+                    elif layout[k_prime] == 1:  # handle type 1 trap
+                        self.matrix_normal[k,k_prime] += p / 2
+                        k_prime = 0
+                        self.matrix_normal[k,k_prime] += p / 2
+                    elif layout[k_prime] == 2:  # handle type 2 trap
+                        self.matrix_normal[k,k_prime] += p / 2
+                        if k_prime == 10:
+                            k_prime = 0
+                        elif k_prime == 11:
+                            k_prime = 1
+                        elif k_prime == 12:
+                            k_prime = 2
+                        else:
+                            k_prime = max(0, k_prime - 3)
+                        self.matrix_normal[k,k_prime] += p / 2
+                    k_prime = 3 + (s - 1)
+                    if layout[k_prime] in [0, 3]:  # normal or prison square
+                        self.matrix_normal[k,k_prime] += p
+                    elif layout[k_prime] == 1:  # handle type 1 trap
+                        self.matrix_normal[k,k_prime] += p / 2
+                        k_prime = 0
+                        self.matrix_normal[k,k_prime] += p / 2
+                    elif layout[k_prime] == 2:  # handle type 2 trap
+                        self.matrix_normal[k,k_prime] += p / 2
+                        k_prime = max(0, k_prime - 3)
+                        self.matrix_normal[k,k_prime] += p / 2
+                    continue
+
+                k_prime = k + s
+                k_prime = k_prime % 15 if circle else min(14, k_prime)
+                if layout[k_prime] in [1, 2]:
+                    p /= 2
+                    if layout[k_prime] == 1:
+                        k_prime = 0
+                        self.matrix_normal[k,k_prime] += p
+                        continue
+                    elif layout[k_prime] == 2:
+                        if k_prime == 10:
+                            k_prime = 0
+                        elif k_prime == 11:
+                            k_prime = 1
+                        elif k_prime == 12:
+                            k_prime = 2
+                        else:
+                            k_prime = max(0, k_prime - 3)
+                        self.matrix_normal[k,k_prime] += p
+                        continue
+                self.matrix_normal[k,k_prime] += p
+
+        return self.matrix_normal
+
+    def _compute_risky_matrix(self, layout, circle):
+        for k in range(0, 15):
+            for s, p in enumerate(self.risky_dice):
+                if k == 7 and s == 3:
+                    k_prime = 14
+                    self.matrix_risky[k,k_prime] += p
+                    continue
+                elif k == 8 and s in [2, 3]:
+                    if not circle or s == 2:
+                        k_prime = 14
+                        self.matrix_risky[k,k_prime] += p
+                    elif circle:
+                        k_prime = 0
+                        self.matrix_risky[k,k_prime] += p
+                    continue
+                elif k == 9 and s in [1, 2, 3]:
+                    if not circle or s == 1:
+                        k_prime = 14
+                        self.matrix_risky[k,k_prime] += p
+                    elif circle and s == 2:
+                        k_prime = 0
+                        self.matrix_risky[k,k_prime] += p
+                    elif circle and s == 3:
+                        k_prime = 1
+                        if layout[k_prime] != 0:
+                            if layout[k_prime] == 1:
+                                k_prime = 0
+                                self.matrix_risky[k,k_prime] += p
+                            elif layout[k_prime] == 2:
+                                k_prime = max(0, k_prime - 3)
+                                self.matrix_risky[k,k_prime] += p
+                            self.matrix_risky[k,k_prime] += p
+                            continue
+                    continue
+
+                if k == 2 and s > 0:
+                    p /= 2
+                    k_prime = 10 + (s - 1)
+                    if layout[k_prime] == 1:
+                        k_prime = 0
+                        self.matrix_risky[k,k_prime] += p
+                    elif layout[k_prime] == 2:
+                        if k_prime == 10:
+                            k_prime = 0
+                        elif k_prime == 11:
+                            k_prime = 1
+                        elif k_prime == 12:
+                            k_prime = 2
+                        else:
+                            k_prime = max(0, k_prime - 3)
+                        self.matrix_risky[k,k_prime] += p
+                    else:
+                        self.matrix_risky[k,k_prime] += p
+                    k_prime = 3 + (s - 1)
+                    self.matrix_risky[k,k_prime] += p
+                    continue
+
+                k_prime = k + s
+                k_prime = k_prime % 15 if circle else min(14, k_prime)
+                if layout[k_prime] in [1, 2, 4]:
+                    if layout[k_prime] == 1:
+                        k_prime = 0
+                        self.matrix_risky[k,k_prime] += p
+                        continue
+                    elif layout[k_prime] == 2:
+                        if k_prime == 10:
+                            k_prime = 0
+                        elif k_prime == 11:
+                            k_prime = 1
+                        elif k_prime == 12:
+                            k_prime = 2
+                        else:
+                            k_prime = max(0, k_prime - 3)
+                        self.matrix_risky[k,k_prime] += p
+                        continue
+                self.matrix_risky[k,k_prime] += p
+        return self.matrix_risky
+    
+
+    def generate_arrays(self,n):
+        # Initialize an empty list to store all the arrays
+        arrays = []
+
+        for _ in range(n):
+            # Initialize a zero array of size 15
+            array = np.zeros(15, dtype=int)
+
+            # Generate 3 random indices between 1 and 13 (exclusive)
+            indices = rd.sample(range(1, 14), 4)
+
+            # Assign the values 1, 2 and 3 to the randomly generated indices
+            array[indices] = 1, 2, 3,4
+
+            # Append the generated array to the list
+            arrays.append(array)
+
+        return arrays
+    
+    # create a function that test the transition matrix for different layout each time with one trap of each sort
+    def tst_transition_matrix(self):
+        # create a list of 100 different layouts
+        layouts = self.generate_arrays(100)
+        for array in layouts:
+            print(array)
+            self.compute_transition_matrix(array, False)
+            self.compute_transition_matrix(array, True)
+
+
+#tmc = TransitionMatrixCalculator()
+#tmc.tst_transition_matrix()
+
+
+
+
+
+"""
+              # create a function that test the transition matrix for different layout each time with one trap of each sort
+    def tst_transition_matrix(self):
+        # create a list of 100 different layouts
+        layout = np.array([0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 1, 0])
+        print(layout)
+        matrix_safe, matrix_normal, matrix_risky = self.compute_transition_matrix(layout, False)
+        print("Matrix Safe:")
+        print(matrix_safe)
+        print("Matrix Normal:")
+        print(matrix_normal)
+        print("Matrix Risky:")
+        print(matrix_risky)
+        matrix_safe, matrix_normal, matrix_risky = self.compute_transition_matrix(layout, True)
+        print("Matrix Safe (Circle):")
+        print(matrix_safe)
+        print("Matrix Normal (Circle):")
+        print(matrix_normal)
+        print("Matrix Risky (Circle):")
+        print(matrix_risky)
+"""
\ No newline at end of file