IGJSP 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

IGJSP/generador.py

@@ -3,16 +3,18 @@ import datetime
 import json
 import os
 import pickle
+import re
 from itertools import combinations
+
 import networkx as nx
 import numpy as np
-import re
 
 np.set_printoptions(linewidth=np.inf, threshold=np.inf, formatter={"int": lambda x: f"{x}"})
 
-from scipy.stats import expon, norm, uniform
 from pprint import pprint
 
+from scipy.stats import expon, norm, uniform
+
 
 def f(x):
     return int(np.exp(-int(x)/100)*100)
@@ -23,6 +25,13 @@ def g(x):
 def t(c):
     return 4.0704 * np.log(2) / np.log(1 + (c* 2.5093)**3)
 
+
+#################################################################################
+#                                                                               # 
+#                                    JSP                                       # 
+#                                                                               #
+#################################################################################
+
 class JSP:
     def __init__(self, jobs, machines, ProcessingTime=np.array([]), EnergyConsumption=np.array([]), ReleaseDateDueDate=np.array([]), Orden=np.array([])) -> None:       
         self.numJobs = jobs
@@ -115,10 +124,325 @@ class JSP:
         else:
             return expon(loc=duration, scale=duration/2).rvs()
 
-    def savePythonFile(self, path):
-        os.makedirs(os.path.dirname(path), exist_ok=True)
-        with open(path, 'wb') as f:
-            pickle.dump(self, f)
+    def loadPythonFile(path):
+        """
+        Carga un fichero .pkl generado por savePythonFile y devuelve un JSP.
+        """
+        with open(path, 'rb') as f:
+            obj = pickle.load(f)
+
+        # Si ya es un JSP, lo devolvemos tal cual
+        if isinstance(obj, JSP):
+            return obj
+
+        # Si es un dict con la misma estructura que usamos en loadJsonFile, construimos el JSP
+        if isinstance(obj, dict) and all(
+            k in obj for k in ['jobs', 'machines', 'ProcessingTime', 'EnergyConsumption', 'ReleaseDateDueDate', 'Orden']
+        ):
+            return JSP(**obj)
+
+        raise TypeError(
+            f"El objeto cargado desde {path} no es un JSP ni un diccionario compatible para construir uno."
+        )
+
+    def loadDznFile(path):
+        """
+        Carga un .dzn generado por saveDznFile y devuelve un JSP.
+        Soporta rddd = 0, 1, 2 (sin fechas, fechas por job, fechas por operación).
+        """
+        with open(path, 'r', encoding='utf-8') as f:
+            text = f.read()
+
+        numJobs = _parse_int_var(text, 'jobs')
+        numMchs = _parse_int_var(text, 'machines')
+        speed = _parse_int_var(text, 'Speed', default=1)
+
+        time_flat = _parse_array_var(text, 'time')
+        energy_flat = _parse_array_var(text, 'energy')
+        prec_flat = _parse_array_var(text, 'precedence')
+
+        if time_flat is None or energy_flat is None or prec_flat is None:
+            raise ValueError("Faltan variables obligatorias (time, energy o precedence) en el fichero DZN.")
+
+        # Comprobar tamaños
+        expected_te = numJobs * numMchs * speed
+        if time_flat.size != expected_te or energy_flat.size != expected_te:
+            raise ValueError(
+                f"Tamaños incompatibles en time/energy: esperado {expected_te}, "
+                f"time={time_flat.size}, energy={energy_flat.size}"
+            )
+
+        expected_prec = numJobs * numMchs
+        if prec_flat.size != expected_prec:
+            raise ValueError(
+                f"Tamaño incompatible en precedence: esperado {expected_prec}, precedence={prec_flat.size}"
+            )
+
+        ProcessingTime = time_flat.reshape((numJobs, numMchs, speed))
+        EnergyConsumption = energy_flat.reshape((numJobs, numMchs, speed))
+        precedence = prec_flat.reshape((numJobs, numMchs))
+
+        # Reconstruir Orden a partir de la precedencia (cada fila es posiciones 0..numMchs-1 por máquina)
+        Orden = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            # precedence[j, m] = posición de la máquina m en la secuencia
+            # argsort da el índice de la máquina por orden de prioridad
+            Orden[j, :] = np.argsort(precedence[j, :])
+
+        # Release / Due dates (pueden no existir)
+        release_flat = _parse_array_var(text, 'releaseDate')
+        due_flat = _parse_array_var(text, 'dueDate')
+
+        if release_flat is None or due_flat is None:
+            # rddd = 0
+            ReleaseDueDate = np.array([])
+        else:
+            # O bien vector por job, o matriz jobs x machines
+            if release_flat.size == numJobs and due_flat.size == numJobs:
+                # rddd = 1 → (numJobs, 2)
+                ReleaseDueDate = np.zeros((numJobs, 2), dtype=int)
+                ReleaseDueDate[:, 0] = release_flat
+                ReleaseDueDate[:, 1] = due_flat
+            elif release_flat.size == numJobs * numMchs and due_flat.size == numJobs * numMchs:
+                # rddd = 2 → (numJobs, numMchs, 2)
+                ReleaseDueDate = np.zeros((numJobs, numMchs, 2), dtype=int)
+                ReleaseDueDate[:, :, 0] = release_flat.reshape((numJobs, numMchs))
+                ReleaseDueDate[:, :, 1] = due_flat.reshape((numJobs, numMchs))
+            else:
+                raise ValueError(
+                    "Los tamaños de releaseDate/dueDate no cuadran ni con rddd=1 ni con rddd=2."
+                )
+
+        sol = {
+            'jobs': numJobs,
+            'machines': numMchs,
+            'ProcessingTime': ProcessingTime,
+            'EnergyConsumption': EnergyConsumption,
+            'ReleaseDateDueDate': ReleaseDueDate,
+            'Orden': Orden
+        }
+        return JSP(**sol)
+
+    def loadTaillardFile(path):
+        """
+        Carga un fichero de texto generado por saveTaillardStandardFile y devuelve un JSP.
+        Formato esperado:
+
+            Number of jobs: J
+            Number of machines: M
+
+            Processing times:
+            ... J filas, cada una con M enteros ...
+
+            Energy consumption:
+            ... J filas, cada una con M enteros ...
+
+            Machine order:
+            ... J filas, cada una con M enteros ...
+        """
+        with open(path, 'r') as f:
+            lines = [line.strip() for line in f]
+
+        # Leer encabezado
+        # Number of jobs: X
+        # Number of machines: Y
+        numJobs = None
+        numMchs = None
+
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            if line.startswith("Number of jobs"):
+                numJobs = int(line.split(":")[1].strip())
+            elif line.startswith("Number of machines"):
+                numMchs = int(line.split(":")[1].strip())
+            if numJobs is not None and numMchs is not None:
+                i += 1
+                break
+            i += 1
+
+        if numJobs is None or numMchs is None:
+            raise ValueError("No se pudieron leer numJobs / numMchs del fichero Taillard.")
+
+        # Saltar líneas vacías hasta "Processing times:"
+        while i < len(lines) and lines[i] == "":
+            i += 1
+        if i >= len(lines) or not lines[i].startswith("Processing times"):
+            raise ValueError("No se encontró la sección 'Processing times:' en el fichero Taillard.")
+        i += 1  # pasar la línea de cabecera
+
+        # Leer matriz de tiempos de procesamiento (J filas)
+        proc_by_order = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            while i < len(lines) and lines[i] == "":
+                i += 1
+            parts = lines[i].split()
+            if len(parts) != numMchs:
+                raise ValueError(
+                    f"Línea de tiempos de procesamiento para job {j} tiene {len(parts)} elementos, "
+                    f"pero se esperaban {numMchs}."
+                )
+            proc_by_order[j, :] = [int(x) for x in parts]
+            i += 1
+
+        # Saltar hasta "Energy consumption:"
+        while i < len(lines) and lines[i] == "":
+            i += 1
+        if i >= len(lines) or not lines[i].startswith("Energy consumption"):
+            raise ValueError("No se encontró la sección 'Energy consumption:' en el fichero Taillard.")
+        i += 1  # cabecera
+
+        energy_by_order = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            while i < len(lines) and lines[i] == "":
+                i += 1
+            parts = lines[i].split()
+            if len(parts) != numMchs:
+                raise ValueError(
+                    f"Línea de consumo de energía para job {j} tiene {len(parts)} elementos, "
+                    f"pero se esperaban {numMchs}."
+                )
+            energy_by_order[j, :] = [int(x) for x in parts]
+            i += 1
+
+        # Saltar hasta "Machine order:"
+        while i < len(lines) and lines[i] == "":
+            i += 1
+        if i >= len(lines) or not lines[i].startswith("Machine order"):
+            raise ValueError("No se encontró la sección 'Machine order:' en el fichero Taillard.")
+        i += 1  # cabecera
+
+        Orden = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            while i < len(lines) and lines[i] == "":
+                i += 1
+            parts = lines[i].split()
+            if len(parts) != numMchs:
+                raise ValueError(
+                    f"Línea de orden de máquinas para job {j} tiene {len(parts)} elementos, "
+                    f"pero se esperaban {numMchs}."
+                )
+            Orden[j, :] = [int(x) for x in parts]
+            i += 1
+
+        # Reconstruir ProcessingTime y EnergyConsumption con speed=1
+        speed = 1
+        ProcessingTime = np.zeros((numJobs, numMchs, speed), dtype=int)
+        EnergyConsumption = np.zeros((numJobs, numMchs, speed), dtype=int)
+
+        for j in range(numJobs):
+            for pos in range(numMchs):
+                machine = Orden[j, pos]
+                ProcessingTime[j, machine, 0] = proc_by_order[j, pos]
+                EnergyConsumption[j, machine, 0] = energy_by_order[j, pos]
+
+        # Taillard estándar: sin release/due dates → rddd=0
+        ReleaseDueDate = np.array([])
+
+        sol = {
+            'jobs': numJobs,
+            'machines': numMchs,
+            'ProcessingTime': ProcessingTime,
+            'EnergyConsumption': EnergyConsumption,
+            'ReleaseDateDueDate': ReleaseDueDate,
+            'Orden': Orden
+        }
+        return JSP(**sol)
+        
+    def loadJsonFile(path):
+        with open(path, "r") as f:
+            data = json.load(f)
+        numJobs = len(data["nbJobs"])
+        numMchs = len(data["nbMchs"])
+        speed = data["speed"]
+    
+        # # Load KPIs (opcional)
+        # min_makespan = data.get("minMakespan", None)
+        # min_energy = data.get("minEnergy", None)
+        # max_min_makespan = data.get("maxMinMakespan", None)
+        # max_min_energy = data.get("maxMinEnergy", None)
+    
+        # Prepare empty structures
+        ProcessingTime = np.zeros((numJobs, numMchs, speed), dtype=int)
+        EnergyConsumption = np.zeros((numJobs, numMchs, speed), dtype=int)
+        Orden_list = [[] for _ in range(numJobs)]
+    
+        # Detect rddd mode
+        # rddd = 0 → no release/due dates
+        # rddd = 1 → job-level RDF
+        # rddd = 2 → operation-level RDF
+        rddd = 0
+        if data["timeEnergy"]:
+            if "release-date" in data["timeEnergy"][0]:
+                rddd = 1
+            for m in data["timeEnergy"][0]["operations"]:
+                if "release-date" in data["timeEnergy"][0]["operations"][m]:
+                    rddd = 2
+                    break
+    
+        # Initialize ReleaseDueDate array according to rddd
+        if rddd == 1:
+            ReleaseDueDate = np.zeros((numJobs, 2), dtype=int)
+        elif rddd == 2:
+            ReleaseDueDate = np.zeros((numJobs, numMchs, 2), dtype=int)
+        else:
+            # No dates: devolver array vacío para que __init__ detecte rddd=0
+            ReleaseDueDate = np.array([])
+    
+        # -------------------------
+        # Load jobs & operations
+        # -------------------------
+        for job_data in data["timeEnergy"]:
+            job = int(job_data["jobId"])
+    
+            # Optional job-level release/due dates
+            if rddd == 1:
+                ReleaseDueDate[job, 0] = int(job_data["release-date"])
+                ReleaseDueDate[job, 1] = int(job_data["due-date"])
+    
+            for machine_str, op_data in job_data["operations"].items():
+                machine = int(machine_str)
+                Orden_list[job].append(machine)
+    
+                # Load speed-scaling arrays
+                proc_times = [int(entry["procTime"]) for entry in op_data["speed-scaling"]]
+                energies = [int(entry["energyCons"]) for entry in op_data["speed-scaling"]]
+    
+                # Aseguramos longitud speed
+                # Si speed > len(proc_times) -> rellenamos con ceros (o ajustar según tu política)
+                proc_arr = np.zeros((speed,), dtype=int)
+                en_arr = np.zeros((speed,), dtype=int)
+                L = min(len(proc_times), speed)
+                proc_arr[:L] = proc_times[:L]
+                en_arr[:L] = energies[:L]
+    
+                ProcessingTime[job, machine, :] = proc_arr
+                EnergyConsumption[job, machine, :] = en_arr
+    
+                if rddd == 2:
+                    ReleaseDueDate[job, machine, 0] = int(op_data["release-date"])
+                    ReleaseDueDate[job, machine, 1] = int(op_data["due-date"])
+    
+        # Convertir Orden a ndarray (shape = numJobs x numMchs)
+        Orden = np.zeros((numJobs, numMchs), dtype=int)
+        for j in range(numJobs):
+            if len(Orden_list[j]) != numMchs:
+                # Si por algun motivo no tiene todas las máquinas,
+                # rellenamos con -1 o lanzamos error; aquí uso -1.
+                row = Orden_list[j] + [-1] * (numMchs - len(Orden_list[j]))
+            else:
+                row = Orden_list[j]
+            Orden[j, :] = np.array(row, dtype=int)
+    
+        sol = {
+            'jobs': numJobs,
+            'machines': numMchs,
+            'ProcessingTime': ProcessingTime,
+            'EnergyConsumption': EnergyConsumption,
+            'ReleaseDateDueDate': ReleaseDueDate,   # <-- ahora es array, no int
+            'Orden': Orden
+        }
+        return JSP(**sol)
 
     def saveJsonFile(self, path):
         self.JSP = {
@@ -141,13 +465,13 @@ class JSP:
             for machine in self.Orden[job]:
                 machine = int(machine)
                 new["operations"][machine] = {"speed-scaling" : 
-                                              [
+                                            [
                                                 {"procTime" : int(proc),
-                                                 "energyCons" : int(energy)
+                                                "energyCons" : int(energy)
                                                 }
                                                 for proc, energy in zip(self.ProcessingTime[job, machine],self.EnergyConsumption[job, machine])
-                                              ]
-                                              }
+                                            ]
+                                            }
                 if self.rddd == 2:
                     new["operations"][machine]["release-date"] = int(self.ReleaseDueDate[job][machine][0])
                     new["operations"][machine]["due-date"] = int(self.ReleaseDueDate[job][machine][1])
@@ -183,6 +507,11 @@ class JSP:
             
             f.write(json_str)
 
+    def savePythonFile(self, path):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'wb') as f:
+            pickle.dump(self, f)
+
     def saveDznFile(self, InputDir, OutputDir):
         indexProblema = OutputDir.split("/")[-2]
         OutputDir = "/".join(OutputDir.split("/")[:-2])
@@ -202,35 +531,30 @@ class JSP:
                     "machines": data.numMchs,
                     "jobs": data.numJobs,
                     "Speed": s,
-                    "time": time.flatten(),
-                    "energy": energy.flatten(),
+                    "time": str(time.flatten()).replace(" ", ", "),
+                    "energy": str(energy.flatten()).replace(" ", ", ")
                 }
 
                 if t == 1:
                     replace_data["releaseDate"] = str([int(data.ReleaseDueDate[job, 0]) for job in range(data.numJobs)]).replace(", ", " ")
                     replace_data["dueDate"] = str([int(data.ReleaseDueDate[job, 1]) for job in range(data.numJobs)]).replace(", ", " ")
                 elif t == 2:
-                    replace_data["releaseDate"] = data.ReleaseDueDate[:, :, 0].flatten()
-                    replace_data["dueDate"] = data.ReleaseDueDate[:, :, 1].flatten()
+                    replace_data["releaseDate"] = str(data.ReleaseDueDate[:, :, 0].flatten()).replace(", ", " ")
+                    replace_data["dueDate"] = str(data.ReleaseDueDate[:, :, 1].flatten()).replace(", ", " ")
 
                 for job in range(data.numJobs):
                     for i, prioridad in enumerate(range(data.numMchs)):
                         precedence[job, data.Orden[job, prioridad]] = i
 
-                replace_data["precedence"] = precedence.flatten()
+                replace_data["precedence"] = str(precedence.flatten()).replace(" ", ",")
 
                 with open(f"./Minizinc/Types/RD/JSP/type{t}.dzn", "r", encoding="utf-8") as file:
                     filedata = file.read()
                     for k, v in replace_data.items():
                         filedata = filedata.replace("{" + k + "}", str(v))
-
                     os.makedirs(f"{OutputDir}/", exist_ok=True)
-
                     with open(f"{OutputDir}/{indexProblema}-{t}-{s}.dzn", "w+", encoding="utf-8") as new:
                         new.write(filedata)
-                # print(f"{OutputDir}/{indexProblema}")
-                # with open(f"{OutputDir}/{indexProblema}", "wb") as new:
-                #     pickle.dump(new_object, new)
 
     def saveTaillardStandardFile(self, path):
         os.makedirs("/".join(path.split("/")[:-1]),exist_ok=True)
@@ -460,11 +784,6 @@ class JSP:
             if operation > 0 and operation < self.numMchs - 1:
                 graph.add_edge((job * self.numMchs + operation - 1, job * self.numMchs + operation))
 
-# if __name__ == "__main__":
-#     jsp = JSP(jobs=5, machines=5)
-#     jsp.fill_random_values(speed=3, rddd=2, distribution="uniform", seed=1234)
-#     jsp.saveTaillardStandardFile("./output_taillard.txt")
-
 
 
 #################################################################################
@@ -585,16 +904,16 @@ class FJSP(JSP):
                     "energy": str(energy.flatten()).replace(" ", ", ")
                 }
                 if t == 1:
-                    replace_data["releaseDate"] = str([int(data.ReleaseDueDate[job, 0]) for job in range(data.numJobs)])
-                    replace_data["dueDate"] = str([int(data.ReleaseDueDate[job, 1]) for job in range(data.numJobs)])
+                    replace_data["releaseDate"] = str([int(data.ReleaseDueDate[job, 0]) for job in range(data.numJobs)]).replace(" ", ",")
+                    replace_data["dueDate"] = str([int(data.ReleaseDueDate[job, 1]) for job in range(data.numJobs)]).replace(" ", ",")  
                 elif t == 2:
-                    replace_data["releaseDate"] = data.ReleaseDueDate[:, :, 0].flatten()
-                    replace_data["dueDate"] = data.ReleaseDueDate[:, :, 1].flatten()
+                    replace_data["releaseDate"] = str(data.ReleaseDueDate[:, :, 0].flatten()).replace(" ", ",")
+                    replace_data["dueDate"] = str(data.ReleaseDueDate[:, :, 1].flatten()).replace(" ", ",")
 
                 for job in range(data.numJobs):
                     for i, prioridad in enumerate(range(data.numMchs)):
                         precedence[job, data.Orden[job, prioridad]] = i
-                replace_data["precedence"] = str(precedence.flatten()).replace(" ", ", ")
+                replace_data["precedence"] = str(precedence.flatten()).replace(" ", ",")
 
                 replace_data["available_machines"] = str(data.available_machines.flatten()).replace(" ", ", ")
 

{igjsp-1.0.0.dist-info → igjsp-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IGJSP
-Version: 1.0.0
+Version: 1.1.0
 Summary: Instance generator for JSP
 Project-URL: Homepage, https://gps.blogs.upv.es/
 Author-email: GPS-UPV <gps@dsic.upv.es>

{igjsp-1.0.0.dist-info → igjsp-1.1.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-IGJSP/generador.py,sha256=AuiRTZ-tfRVt8U0-EECznq85NtDZsLyZLCAIjM1U8-8,34124
+IGJSP/generador.py,sha256=nSPgsVbpR5YydbrkIOhkGmXbFCnkaIAkRu-ok-_BJpY,47603
 IGJSP/main.py,sha256=Sia5Ss8O3HWBdshvPLJKUMaZIoQPHy6x8yzvojojPFo,2838
 IGJSP/Minizinc/Models/RD/JSP0.mzn,sha256=cfN_E3RQ6nBulGfaOOYTd-zAgA5SI6E2saDlYtKCflg,2282
 IGJSP/Minizinc/Models/RD/JSP1.mzn,sha256=5B8cyw2WyKR8yEL1fFd0TaCAVhjPoxEJRJDPPEjJGEk,2840
@@ -12,7 +12,7 @@ IGJSP/Minizinc/Types/RD/FJSP/type2.dzn,sha256=Wz1MnkSL5GUPsbh1eq0leoaQRImkNqQqkX
 IGJSP/Minizinc/Types/RD/JSP/type0.dzn,sha256=wNuPQkXBXPSpPaPz2WFhp4pGDgfSimtg4I93UfwC01Q,263
 IGJSP/Minizinc/Types/RD/JSP/type1.dzn,sha256=Xbt9StzCgEqqh_HS9tWGrTVtu-OEnf5Yq5Ty91AkzoM,333
 IGJSP/Minizinc/Types/RD/JSP/type2.dzn,sha256=L2nc7bPJEhyuaEwgw0ZCpC52CpVJILQU_WQdKn8GUZs,379
-igjsp-1.0.0.dist-info/METADATA,sha256=zU57DaxL2XUGadX8d5Bxlyfo8uUxgD1X_f43gKDMSns,10609
-igjsp-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-igjsp-1.0.0.dist-info/licenses/LICENSE,sha256=f7RDRO-z_nMoooAya7NAb8sXtrHR6WnttYtyUc9fB-c,1116
-igjsp-1.0.0.dist-info/RECORD,,
+igjsp-1.1.0.dist-info/METADATA,sha256=q-mdPgQhQCvXKTtYbNMsDzgvR-oov4pe27Js_9Oeazo,10609
+igjsp-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+igjsp-1.1.0.dist-info/licenses/LICENSE,sha256=f7RDRO-z_nMoooAya7NAb8sXtrHR6WnttYtyUc9fB-c,1116
+igjsp-1.1.0.dist-info/RECORD,,

{igjsp-1.0.0.dist-info → igjsp-1.1.0.dist-info}/WHEEL

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