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

IGJSP/Minizinc/Types/RD/FJSP/type0.dzn

@@ -0,0 +1,9 @@
+%SETS
+JOBS     = 1..{jobs};
+MACHINES = 1..{machines};
+SPEED    = {Speed};
+
+time               = array3d(JOBS,MACHINES,1..SPEED,{time});
+energy             = array3d(JOBS,MACHINES,1..SPEED,{energy});
+precedence         = array2d(JOBS,MACHINES,{precedence});
+available_machines = array2d(JOBS,MACHINES,{available_machines});

IGJSP/Minizinc/Types/RD/FJSP/type1.dzn

@@ -0,0 +1,11 @@
+%SETS
+JOBS     = 1..{jobs};
+MACHINES = 1..{machines};
+SPEED    = {Speed};
+
+time               = array3d(JOBS,MACHINES,1..SPEED,{time});
+energy             = array3d(JOBS,MACHINES,1..SPEED,{energy});
+precedence         = array2d(JOBS,MACHINES,{precedence});
+releaseDate        = {releaseDate};
+dueDate            = {dueDate};
+available_machines = array2d(JOBS,MACHINES,{available_machines});

IGJSP/Minizinc/Types/RD/FJSP/type2.dzn

@@ -0,0 +1,11 @@
+%SETS
+JOBS     = 1..{jobs};
+MACHINES = 1..{machines};
+SPEED    = {Speed};
+
+time               = array3d(JOBS,MACHINES,1..SPEED,{time});
+energy             = array3d(JOBS,MACHINES,1..SPEED,{energy});
+precedence         = array2d(JOBS,MACHINES,{precedence});
+releaseDate        = array2d(JOBS,MACHINES,{releaseDate});
+dueDate            = array2d(JOBS,MACHINES,{dueDate});
+available_machines = array2d(JOBS,MACHINES,{available_machines});

IGJSP/Minizinc/Types/RD/JSP/type0.dzn

@@ -0,0 +1,8 @@
+%SETS
+JOBS     = 1..{jobs};
+MACHINES = 1..{machines};
+SPEED    = {Speed};
+
+time               = array3d(JOBS,MACHINES,1..SPEED,{time});
+energy             = array3d(JOBS,MACHINES,1..SPEED,{energy});
+precedence         = array2d(JOBS,MACHINES,{precedence});

IGJSP/Minizinc/Types/RD/JSP/type1.dzn

@@ -0,0 +1,10 @@
+%SETS
+JOBS     = 1..{jobs};
+MACHINES = 1..{machines};
+SPEED    = {Speed};
+
+time               = array3d(JOBS,MACHINES,1..SPEED,{time});
+energy             = array3d(JOBS,MACHINES,1..SPEED,{energy});
+precedence         = array2d(JOBS,MACHINES,{precedence});
+releaseDate        = {releaseDate};
+dueDate            = {dueDate};

IGJSP/Minizinc/Types/RD/JSP/type2.dzn

@@ -0,0 +1,10 @@
+%SETS
+JOBS     = 1..{jobs};
+MACHINES = 1..{machines};
+SPEED    = {Speed};
+
+time               = array3d(JOBS,MACHINES,1..SPEED,{time});
+energy             = array3d(JOBS,MACHINES,1..SPEED,{energy});
+precedence         = array2d(JOBS,MACHINES,{precedence});
+releaseDate        = array2d(JOBS,MACHINES,{releaseDate});
+dueDate            = array2d(JOBS,MACHINES,{dueDate});

IGJSP/generador.py

@@ -1,22 +1,18 @@
 import copy
+import datetime
 import json
-import multiprocessing
 import os
 import pickle
-import random
-from concurrent.futures import ProcessPoolExecutor, as_completed
-from datetime import datetime
-from itertools import combinations, product
-from pathlib import Path
+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
-import sys
 
-import importlib_resources
-from importlib.resources import read_text
-minizinc_files = importlib_resources.files("IGJSP")
 
 def f(x):
     return int(np.exp(-int(x)/100)*100)
@@ -41,14 +37,14 @@ class JSP:
         np.random.seed(seed)
         self.rddd = rddd
         self.speed = speed
-        if not tpm:
+        if not tpm or len(tpm) != self.numMchs:
             if distribution == "uniform":
                 tpm = np.random.uniform(10, 100, self.numMchs)
             elif distribution == "normal":
                 tpm = [max(10, data) for data in np.random.normal(50, 20, self.numMchs)]
             else:
                 tpm = expon(loc=10, scale=20).rvs(self.numMchs)
-        
+       
         energyPer, timePer = self._particionate_speed_space(speed)
         self._generate_standar_operation_cost(distribution)
 
@@ -71,7 +67,6 @@ class JSP:
 
         self._jobToMachine(release_date_tasks, timePer, distribution)
         self.generate_maxmin_objective_values()
-        self.vectorization()
 
     def _particionate_speed_space(self, speed):
         energyPer = np.linspace(0.5, 3, speed) if speed > 1 else [1]
@@ -121,6 +116,7 @@ class JSP:
             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)
 
@@ -139,19 +135,19 @@ class JSP:
         for job in range(self.numJobs):
             new = {
                 "jobId": job,
-                "operations": {}
+                "operations": {},
             }
+
             for machine in self.Orden[job]:
                 machine = int(machine)
-                new["operations"][machine] = {
-                    "speed-scaling": [
-                        {
-                            "procTime": int(proc),
-                            "energyCons": int(energy)
-                        }
-                        for proc, energy in zip(self.ProcessingTime[job, machine], self.EnergyConsumption[job, machine])
-                    ]
-                }
+                new["operations"][machine] = {"speed-scaling" : 
+                                              [
+                                                {"procTime" : int(proc),
+                                                 "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])
@@ -164,8 +160,28 @@ class JSP:
             self.JSP["timeEnergy"].append(new)
 
         os.makedirs(os.path.dirname(path), exist_ok=True)
-        with open(path, 'w+' ) as f:
-            json.dump(self.JSP, f, indent=4)
+        with open(path, 'w+') as f:
+            # Generamos el JSON con indentación normal
+            json_str = json.dumps(self.JSP, indent=4)
+            
+            # Compresión selectiva: solo arrays de números simples
+            def compress_simple_arrays(match):
+                # Comprimir si el array contiene solo números y comas
+                content = match.group(1)
+                if re.match(r'^(\s*\d+\s*,)*\s*\d+\s*$', content):
+                    # Eliminar espacios y saltos de línea
+                    return '[' + re.sub(r'\s+', '', content) + ']'
+                return match.group(0)  # Mantener como está si no es simple
+            
+            # Buscar arrays que puedan comprimirse
+            json_str = re.sub(
+                r'\[([\s\S]*?)\]', 
+                compress_simple_arrays, 
+                json_str,
+                flags=re.DOTALL
+            )
+            
+            f.write(json_str)
 
     def saveDznFile(self, InputDir, OutputDir):
         indexProblema = OutputDir.split("/")[-2]
@@ -186,27 +202,27 @@ class JSP:
                     "machines": data.numMchs,
                     "jobs": data.numJobs,
                     "Speed": s,
-                    "time": list(map(int,time.flatten())),
-                    "energy": list(map(int,energy.flatten()))
+                    "time": time.flatten(),
+                    "energy": energy.flatten(),
                 }
+
                 if t == 1:
-                    replace_data["releaseDate"] = [data.ReleaseDueDate[job, 0] for job in range(data.numJobs)]
-                    replace_data["dueDate"] = [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"] = list(data.ReleaseDueDate[:, :, 0].flatten())
-                    replace_data["dueDate"] = list(data.ReleaseDueDate[:, :, 1].flatten())
+                    replace_data["releaseDate"] = data.ReleaseDueDate[:, :, 0].flatten()
+                    replace_data["dueDate"] = data.ReleaseDueDate[:, :, 1].flatten()
 
                 for job in range(data.numJobs):
                     for i, prioridad in enumerate(range(data.numMchs)):
                         precedence[job, data.Orden[job, prioridad]] = i
-                replace_data["precedence"] = list(map(int,precedence.flatten()))
 
-                # new_object = data.change_rddd_type(t).select_speeds(list(range(s0, sf, sp)))
-                with open(minizinc_files.joinpath("Minizinc/Types/RD", f"type{t}.dzn"), "r", encoding="utf-8") as file:
+                replace_data["precedence"] = precedence.flatten()
+
+                with open(f"./Minizinc/Types/RD/JSP/type{t}.dzn", "r", encoding="utf-8") as file:
                     filedata = file.read()
-                    # filedata = file
-                    for kk, v in replace_data.items():
-                        filedata = filedata.replace("{" + kk + "}", str(v))
+                    for k, v in replace_data.items():
+                        filedata = filedata.replace("{" + k + "}", str(v))
 
                     os.makedirs(f"{OutputDir}/", exist_ok=True)
 
@@ -253,7 +269,6 @@ class JSP:
                     f.write(f"{machine} ")
                 f.write("\n")
 
-
     def select_speeds(self, speeds):
         if self.speed == len(speeds):
             return self
@@ -283,16 +298,16 @@ class JSP:
         return new_object
 
     def generate_maxmin_objective_values(self):
-        self.max_makespan = sum([max(self.ProcessingTime[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
+        max_makespan = sum([max(self.ProcessingTime[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
         self.min_makespan = max([sum([min(self.ProcessingTime[job, machine, :]) for machine in range(self.numMchs)]) for job in range(self.numJobs)])
-        self.max_min_makespan = self.max_makespan - self.min_makespan
-        self.max_energy = sum([max(self.EnergyConsumption[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
+        self.max_min_makespan = max_makespan - self.min_makespan
+        max_energy = sum([max(self.EnergyConsumption[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
         self.min_energy = sum([min(self.EnergyConsumption[job, machine, :]) for job in range(self.numJobs) for machine in range(self.numMchs)])
-        self.max_min_energy = self.max_energy - self.min_energy
+        self.max_min_energy = max_energy - self.min_energy
         if self.rddd == 1:
-            self.max_tardiness = sum([max(0, self.max_makespan - self.ReleaseDueDate[job, 1]) for job in range(self.numJobs)])
+            self.max_tardiness = sum([max(0, max_makespan - self.ReleaseDueDate[job, 1]) for job in range(self.numJobs)])
         elif self.rddd == 2:
-            self.max_tardiness = np.sum([max(0, np.int64(self.max_makespan - self.ReleaseDueDate[job, machine, 1])) for job in range(self.numJobs) for machine in range(self.numMchs)])
+            self.max_tardiness = np.sum([max(0, np.int64(max_makespan - self.ReleaseDueDate[job, machine, 1])) for job in range(self.numJobs) for machine in range(self.numMchs)])
 
     def norm_makespan(self, makespan):
         return (makespan - self.min_makespan) / self.max_min_makespan
@@ -394,86 +409,7 @@ class JSP:
 
     def generate_schedule_image(self, schedule):
         pass
-    
-    def vectorization(self):
-        vectorization = {}
-        # Caracteristicas básicas
-        vectorization["jobs"]           = self.numJobs
-        vectorization["machines"]       = self.numMchs
-        vectorization["rddd"]           = self.rddd
-        vectorization["speed"]          = self.speed
-        vectorization["max_makespan"]    = self.max_makespan
-        vectorization["min_makespan"]    = self.min_makespan
-        vectorization["max_sum_energy"]   = self.max_energy
-        vectorization["min_sum_energy"]   = self.min_energy
-        vectorization["max_tardiness"]   = self.max_tardiness if self.rddd != 0 else 0
-        vectorization["min_window"]     = 0
-        vectorization["max_window"]     = 0
-        vectorization["mean_window"]    = 0
-        vectorization["overlap"]        = 0
-
-        # Caracteristicas complejas
-        if self.rddd == 0:
-            vectorization["min_window"]  = -1
-            vectorization["max_window"]  = -1
-            vectorization["mean_window"]  = -1
-            vectorization["overlap"] = -1
-        else:
-            if self.rddd == 1:
-                # Ventana de cada trabajo
-                for job in range(self.numJobs):
-                    tproc_min  = np.sum(np.min(self.ProcessingTime[job,machine,:]) for machine in range(self.numMchs))
-                    tproc_max  = np.sum(np.max(self.ProcessingTime[job,machine,:]) for machine in range(self.numMchs))                    
-                    tproc_mean = np.sum(np.mean(self.ProcessingTime[job,machine,:]) for machine in range(self.numMchs)) 
-                    window     = self.ReleaseDueDate[job,1] - self.ReleaseDueDate[job,0]
-                    vectorization["min_window"]  += window / tproc_max 
-                    vectorization["max_window"]  += window / tproc_min 
-                    vectorization["mean_window"] += window / tproc_mean 
-                vectorization["min_window"]  = vectorization["min_window"]  / self.numJobs
-                vectorization["max_window"]  = vectorization["max_window"]  / self.numJobs
-                vectorization["mean_window"] = vectorization["mean_window"] / self.numJobs
-                # Overlap entre trabajos
-                for job in range(self.numJobs):
-                    for job2 in range(job + 1, self.numJobs):
-                        diff = min(self.ReleaseDueDate[job,1],self.ReleaseDueDate[job2,1])-max(self.ReleaseDueDate[job,0], self.ReleaseDueDate[job2,0])
-                        if diff > 0:
-                            vectorization["overlap"] += diff / (self.ReleaseDueDate[job,1] - self.ReleaseDueDate[job,0])
-                            vectorization["overlap"] += diff / (self.ReleaseDueDate[job2,1] - self.ReleaseDueDate[job2,0])
-                vectorization["overlap"] = vectorization["overlap"] / (self.numJobs * (self.numJobs - 1))
-            else:
-                # Ventana de cada operacion
-                for job in range(self.numJobs):
-                    for machine in range(self.numMchs):
-                        tproc_min  = np.min(self.ProcessingTime[job,machine,:])
-                        tproc_max  = np.max(self.ProcessingTime[job,machine,:])                   
-                        tproc_mean = np.mean(self.ProcessingTime[job,machine,:])
-                        window     = self.ReleaseDueDate[job,machine,1] - self.ReleaseDueDate[job,machine,0]
-                        vectorization["min_window"]  += window / tproc_max 
-                        vectorization["max_window"]  += window / tproc_min 
-                        vectorization["mean_window"] += window / tproc_mean 
-                vectorization["min_window"]  = vectorization["min_window"]  / (self.numJobs * self.numMchs)
-                vectorization["max_window"]  = vectorization["max_window"]  / (self.numJobs * self.numMchs)
-                vectorization["mean_window"] = vectorization["mean_window"] / (self.numJobs * self.numMchs)
-                # Overlap entre operaciones
-                for job1 in range(self.numJobs):
-                    for machine1 in range(self.numMchs):
-                        for job2 in range(job1 + 1, self.numJobs):
-                            diff = min(self.ReleaseDueDate[job1,machine1,1],self.ReleaseDueDate[job2,machine1,1])-max(self.ReleaseDueDate[job1,machine1,0],  self.ReleaseDueDate[job2,machine1,0])
-                            if diff > 0:
-                                vectorization["overlap"] += diff / (self.ReleaseDueDate[job1,machine1,1] - self.ReleaseDueDate[job1,machine1,0])
-                                vectorization["overlap"] += diff / (self.ReleaseDueDate[job2,machine1,1] -  self.ReleaseDueDate[job2,machine1,0])
-                vectorization["overlap"] = vectorization["overlap"] / (self.numJobs * (self.numJobs - 1) * self.numMchs)   
-        # Estadísticos de los datos
-        vectorization["max_processing_time_value"]     = np.max(self.ProcessingTime)
-        vectorization["min_processing_time_value"]     = np.min(self.ProcessingTime)
-        vectorization["mean_processing_time_value"]    = np.mean(self.ProcessingTime)
-
-        vectorization["max_energy_value"]     = np.max(self.ProcessingTime)
-        vectorization["min_energy_value"]     = np.min(self.ProcessingTime)
-        vectorization["mean_energy_value"]    = np.mean(self.ProcessingTime)
-        self.features = vectorization
-        return vectorization
-    
+
     def disjuntive_graph(self):
         vertex = list(range(self.numJobs * self.numMchs + 2))
         A = {v: [] for v in vertex}
@@ -529,31 +465,258 @@ class JSP:
 #     jsp.fill_random_values(speed=3, rddd=2, distribution="uniform", seed=1234)
 #     jsp.saveTaillardStandardFile("./output_taillard.txt")
 
+
+
+#################################################################################
+#                                                                               # 
+#                                    FJSP                                       # 
+#                                                                               #
+#################################################################################
+
+
+class FJSP(JSP):
+    def __init__(self, jobs, machines, ProcessingTime=np.array([]), EnergyConsumption=np.array([]), ReleaseDateDueDate=np.array([]), Orden=np.array([]), AvailableMachines = np.array([])) -> None:
+
+        super().__init__(jobs, machines, ProcessingTime, EnergyConsumption, ReleaseDateDueDate, Orden)
+        self.available_machines = AvailableMachines
+        
+    def fill_random_values(self, speed, rddd, distribution, seed, tpm=[]):
+
+        super().fill_random_values(speed, rddd, distribution, seed, tpm)
+     
+        self.available_machines = np.random.choice([0, 1], size=(self.numJobs, self.numMchs))
+
+        # Asegurar al menos un 1 en cada columna
+        for job in range(self.numJobs):
+            if np.sum(self.available_machines[job, :]) == 0:
+                columna_aleatoria = np.random.randint(0, self.numMchs)
+                self.available_machines[job, columna_aleatoria] = 1
+
+    # def savePythonFile(self, path):
+    #     with open(path, 'wb') as f:
+    #         pickle.dump(self, f)
+
+    def saveJsonFile(self, path):
+        self.JSP = {
+            "nbJobs": list(range(self.numJobs)),
+            "nbMchs": list(range(self.numMchs)),
+            "speed": self.speed,
+            "timeEnergy": [],
+            "minMakespan": int(self.min_makespan),
+            "minEnergy": int(self.min_energy),
+            "maxMinMakespan": int(self.max_min_makespan),
+            "maxMinEnergy": int(self.max_min_energy)
+        }
+        
+        for job in range(self.numJobs):
+            new = {
+                "jobId": job,
+                "operations": {},
+                "available_machines": self.available_machines[job, : ].tolist()
+            }
+
+            #new["available_machines_prueba"] = self.available_machines[job, self.Orden[job] ].tolist() #for i in self.Orden[job]]
+
+            for machine in self.Orden[job]:
+                machine = int(machine)
+                new["operations"][machine] = {"speed-scaling" : 
+                                              [
+                                                {"procTime" : int(proc),
+                                                 "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])
+            if self.rddd == 1:
+                new["release-date"] = int(self.ReleaseDueDate[job][0])
+                new["due-date"] = int(self.ReleaseDueDate[job][1])
+            if self.rddd == 2:
+                new["release-date"] = int(min(self.ReleaseDueDate[job, :, 0]))
+                new["due-date"] = int(max(self.ReleaseDueDate[job, :, 1]))
+            self.JSP["timeEnergy"].append(new)
+
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'w+') as f:
+            # Generamos el JSON con indentación normal
+            json_str = json.dumps(self.JSP, indent=4)
+            
+            # Compresión selectiva: solo arrays de números simples
+            def compress_simple_arrays(match):
+                # Comprimir si el array contiene solo números y comas
+                content = match.group(1)
+                if re.match(r'^(\s*\d+\s*,)*\s*\d+\s*$', content):
+                    # Eliminar espacios y saltos de línea
+                    return '[' + re.sub(r'\s+', '', content) + ']'
+                return match.group(0)  # Mantener como está si no es simple
+            
+            # Buscar arrays que puedan comprimirse
+            json_str = re.sub(
+                r'\[([\s\S]*?)\]', 
+                compress_simple_arrays, 
+                json_str,
+                flags=re.DOTALL
+            )
+            
+            f.write(json_str)
+
+    def saveDznFile(self, InputDir, OutputDir):
+        indexProblema = OutputDir.split("/")[-2]
+        OutputDir = "/".join(OutputDir.split("/")[:-2])
+        # indexProblema = os.path.basename(os.path.normpath(OutputDir))
+        with open(f"{InputDir}", 'rb') as f:
+            data: FJSP = pickle.load(f)
+            # print(self.speed)
+            # for t in [0, 1, 2]:
+            t = data.rddd
+            for s in range(1,self.speed+1):
+                s0, sf, sp = [0,s,1]
+                time = data.ProcessingTime[:, :, s0:sf:sp]
+                energy = data.EnergyConsumption[:, :, s0:sf:sp]
+                precedence = np.full((data.numJobs, data.numMchs), 0)
+
+                replace_data = {
+                    "machines": data.numMchs,
+                    "jobs": data.numJobs,
+                    "Speed": s,
+                    "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_data["dueDate"] = str([int(data.ReleaseDueDate[job, 1]) for job in range(data.numJobs)])
+                elif t == 2:
+                    replace_data["releaseDate"] = data.ReleaseDueDate[:, :, 0].flatten()
+                    replace_data["dueDate"] = data.ReleaseDueDate[:, :, 1].flatten()
+
+                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["available_machines"] = str(data.available_machines.flatten()).replace(" ", ", ")
+
+                with open(f"./Minizinc/Types/RD/FJSP/type{t}.dzn", "r", encoding="utf-8") as file:
+                    filedata = file.read()
+                    for kk, v in replace_data.items():
+                        filedata = filedata.replace("{" + kk + "}", 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)
+        with open(path, 'w+') as f:
+            # Escribir el encabezado con el número de trabajos y máquinas
+            f.write(f"Number of jobs: {self.numJobs}\n")
+            f.write(f"Number of machines: {self.numMchs}\n\n")
+            
+            # Escribir la matriz de tiempos de procesamiento
+            f.write("Processing times:\n")
+            for job in range(self.numJobs):
+                # Almacenar todos los tiempos de esta fila
+                tiempos = []
+                for machine_index in range(self.numMchs):
+                    machine = self.Orden[job, machine_index]
+                    processing_time = self.ProcessingTime[job, machine, 0]
+                    tiempos.append(str(processing_time))
+                
+                # Unir los tiempos con comas y escribirlos
+                linea = ", ".join(tiempos)
+                f.write(linea + "\n")
+            
+            f.write("\n")
+
+            # Escribir la matriz de consumo de energía
+            f.write("Energy consumption:\n")
+            for job in range(self.numJobs):
+                consumos = []
+                for machine_index in range(self.numMchs):
+                    machine = self.Orden[job, machine_index]
+                    energy_consumption = self.EnergyConsumption[job, machine, 0]
+                    consumos.append(str(energy_consumption))
+                f.write(", ".join(consumos) + "\n")
+
+            f.write("\n")
+
+            # Escribir el orden de las máquinas para cada trabajo
+            f.write("Machine order:\n")
+            for job in range(self.numJobs):
+                maquinas = []
+                for machine_index in range(self.numMchs):
+                    machine = self.Orden[job, machine_index]
+                    maquinas.append(str(machine))
+                f.write(", ".join(maquinas) + "\n")
+
+            f.write("\n")
+
+            f.write("Available machines:\n")
+            for job in range(self.numJobs):
+                disponibles = []
+                for machine_index in range(self.numMchs):
+                    disponibles.append(str(self.available_machines[job, machine_index]))
+                f.write(", ".join(disponibles) + "\n")
+
+
+
 class Generator:
-    def __init__( self,json = False, dzn = False, taillard = False, savepath="./"):
+    def __init__(self, json = False, dzn = False, taillard = False, savepath = "./", single_folder_output = False):
         self.json = json
         self.dzn = dzn
         self.taillard = taillard
         self.savepath = savepath
+        self.single_folder_output = single_folder_output
         
-    def generate_new_instance(self, jobs = 10, machines = 4,speed = 1, ReleaseDateDueDate = 0, distribution = "uniform" , seed = 0, tpm=[]):
-        jsp = JSP(jobs=jobs, machines=machines)
-        jsp.fill_random_values(speed = speed, rddd = ReleaseDateDueDate, distribution = distribution, seed = seed,tpm = tpm)
-        if not (self.json or self.dzn or self.taillard): return jsp
-        
-        j = str(jobs)
-        m = str(machines)
-        jm_path = str(j)+"_"+str(m)+"/"
-        
-        i = seed
-
-        if self.json:
-            jsp.saveJsonFile(f"{self.savepath}/JSON/"+jm_path.split("/")[0]+f"_{j}x{m}_{i}.json")
-        if self.dzn:
-            pkl_path = f"{self.savepath}/"+jm_path.split("/")[0]+f"_{j}x{m}_{i}.pkl"
-            jsp.savePythonFile(pkl_path)
-            jsp.saveDznFile(pkl_path,f"{self.savepath}/DZN/"+jm_path)#f"{j}x{m}_{i}")
-            os.remove(pkl_path)
-        if self.taillard:
-            jsp.saveTaillardStandardFile(f"{self.savepath}/TAILLARD/"+jm_path.split("/")[0]+f"_{j}x{m}_{i}.txt")
-        return jsp
+    def generate_new_instance(self, jobs = 10, machines = 4, speed = 1, ReleaseDateDueDate = 0, distribution = "uniform" , seed = 0, tpm=[], instance_type = "JSP", size = 1):
+
+        match instance_type:
+            case "JSP":
+                jsp_instance = JSP(jobs = jobs, machines = machines)
+            case "FJSP":
+                jsp_instance = FJSP(jobs = jobs, machines = machines)
+
+        for index in range(1, size + 1):
+
+            jsp_instance.fill_random_values(speed = speed, rddd = ReleaseDateDueDate, distribution = distribution, seed = seed,tpm = tpm)
+
+            # Determinar el nombre de salida basado en `outputName` y los parámetros actuales
+            problem_path = self.savepath.format(size = size, jobs =jobs, machines = machines, release_due_date = ReleaseDateDueDate, 
+                                                    speed_scaling = speed, distribution = distribution, seed=seed)
+            
+            if not (self.json or self.dzn or self.taillard): return jsp_instance
+            
+            j = str(jobs)
+            m = str(machines)
+            jm_path = str(j)+"_"+str(m)+"/"
+            
+            i = seed
+
+            if self.single_folder_output:
+                if self.json:
+                    jsp_instance.saveJsonFile(problem_path + jm_path.split("/")[0] + f"_{j}x{m}_{i}.json")
+                if self.dzn:
+                    pkl_path = f"{problem_path}/" + jm_path.split("/")[0] + f"_{j}x{m}_{i}.pkl"
+                    jsp_instance.savePythonFile(pkl_path)
+                    jsp_instance.saveDznFile(pkl_path, problem_path + jm_path)#f"{j}x{m}_{i}")
+                    os.remove(pkl_path)
+                if self.taillard:
+                    jsp_instance.saveTaillardStandardFile(problem_path + jm_path.split("/")[0] + f"_{j}x{m}_{i}.txt")
+            else:
+                if self.json:
+                    jsp_instance.saveJsonFile(f"{problem_path}/JSON/" + jm_path.split("/")[0] + f"_{j}x{m}_{i}.json")
+                if self.dzn:
+                    pkl_path = f"{problem_path}/" + jm_path.split("/")[0] + f"_{j}x{m}_{i}.pkl"
+                    jsp_instance.savePythonFile(pkl_path)
+                    jsp_instance.saveDznFile(pkl_path,f"{problem_path}/DZN/" + jm_path)#f"{j}x{m}_{i}")
+                    os.remove(pkl_path)
+                if self.taillard:
+                    jsp_instance.saveTaillardStandardFile(f"{problem_path}/TAILLARD/" + jm_path.split("/")[0] + f"_{j}x{m}_{i}.txt")
+
+        return jsp_instance

IGJSP/main.py

@@ -18,10 +18,7 @@ try:
     parser.add_argument('-M','--machines', type=json.loads, default='[4]')
     # Semilla
     parser.add_argument('-s','--seeds', type= json.loads, default='[0]')
-    # Tipo de problema
-    # 1 - JSP, 2 - FlowJSP, 3 - FlexibleJSP, 4 - OpenJSP
-    # parser.add_argument('-T','--type', type=int, default=1)
-    # Niveles de dificultad
+
     # Speed Scaling
     parser.add_argument('-S', '--speed-scaling', type=int, default=1)
 
@@ -29,7 +26,7 @@ try:
     # 0 -> Tiempo infinito
     # 1 -> Tiempo por trabajo
     # 2 -> Tiempo por tarea de cada trabajo
-    parser.add_argument('-RDDD', '--release-due', type=int, default=0)
+    parser.add_argument('-RDDD', '--release-due', type=int, default=0, choices=[0, 1, 2])
     # Time
     # parser.add_argument('-Ti', '--time', type=int, default=0)
     # Path
@@ -48,7 +45,16 @@ try:
     # Taillard save
     parser.add_argument('-t','--taillard', type=bool, default=False)
 
+    #Instance Type (JSP o FJSP)
+    parser.add_argument('-T', '--type', type=int, default=1, choices=[1, 2])
+
     args = parser.parse_args()
+
+    type_dict = {
+        1: "JSP",
+        2: "FJSP"
+    }
+
     np.random.seed(args.seeds)
 
     start = time.time()
@@ -64,7 +70,8 @@ try:
                 args.seeds = args.seeds+ list(p_s[:args.quantity-len(args.seeds)])
             for i in trange(args.quantity,desc='Quantity',leave=False):
                 generator.savepath = args.path+"/instancesGenerated_"+str(i)
-                generator.generate_new_instance(jobs=j, machines=m,ReleaseDateDueDate =np.array(args.release_due),speed = args.speed_scaling,distribution = args.distribution, seed = args.seeds[i])
+                generator.generate_new_instance(jobs=j, machines=m, ReleaseDateDueDate=np.array(args.release_due), speed = args.speed_scaling,
+                                                distribution=args.distribution, seed=args.seeds[i], instance_type=type_dict[args.type])
     
 except Exception as e:
     raise

igjsp-1.0.0.dist-info/METADATA

@@ -0,0 +1,304 @@
+Metadata-Version: 2.4
+Name: IGJSP
+Version: 1.0.0
+Summary: Instance generator for JSP
+Project-URL: Homepage, https://gps.blogs.upv.es/
+Author-email: GPS-UPV <gps@dsic.upv.es>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Description-Content-Type: text/markdown
+
+# Instance Generator for JSP & FJSP (Energy‑aware)
+
+## Description
+
+Instance generator for the **Job Shop Scheduling Problem (JSP)** and the **Flexible Job Shop Scheduling Problem (FJSP)** with speed‑scaling and optional release/due dates. The generator produces instances in **JSON**, **MiniZinc DZN**, and **Taillard-like text** formats, and it is designed for reproducible experiments via a random seed.
+
+### Key features
+
+- Supports **JSP** and **FJSP** (`instance_type="JSP"` or `instance_type="FJSP"`).
+- **Energy‑aware speed scaling**: each operation can be executed at one of several speeds; processing time and energy consumption are linked per speed.
+- **Release/Due date modes** (`ReleaseDateDueDate`): `0` (none), `1` (per job), `2` (per operation).
+- Multiple output formats: **JSON**, **DZN** (MiniZinc templates), **Taillard-style** text.
+- **Distributions** for data generation: `uniform`, `normal`, `exponential`.
+- Reproducibility via **seed**.
+- **FJSP** adds a per‑job binary vector of **available machines**.
+
+> **About value ranges & scaling**
+>
+> - With the **uniform** distribution, base operation costs are sampled within **[10, 100]**.
+> - Initial *release times* are sampled from **[0, 100]** (in steps of 10) and then normalized to start at 0.
+> - **Energy consumption** values are normalized into **[1, 100]** by construction.
+> - **Processing times** are derived from base costs and speed scaling and **are not capped** at 100 (they can exceed 100), especially with `normal`/`exponential` draws.
+>
+> As a result, energy values and the initial release‑date seeds are within 0–100; if you need strict 0–100 ranges for *all* fields, set an external rescaling on the produced arrays or constrain generation to `distribution="uniform"` and adjust your post‑processing accordingly.
+
+---
+
+## Python API
+
+### Generator initialization
+
+```python
+from IGJSP.generador import Generator
+
+gen = Generator(
+    json=False,                 # write JSON files
+    dzn=False,                  # write DZN files (MiniZinc)
+    taillard=False,             # write Taillard-like txt
+    savepath="./output",        # base output directory/template
+    single_folder_output=False  # put artifacts in a single folder
+)
+```
+
+### Instance creation
+
+```python
+obj = gen.generate_new_instance(
+    jobs=10, machines=4,
+    speed=1,                      # number of speed levels
+    ReleaseDateDueDate=0,         # 0 (none), 1 (per job), 2 (per operation)
+    distribution="uniform",       # 'uniform' | 'normal' | 'exponential'
+    seed=1,
+    tpm=[],                       # optional per-machine time scale
+    instance_type="JSP",          # 'JSP' (default) or 'FJSP'
+    size=1                        # how many instances to emit (looped)
+)
+```
+
+If all three output flags (`json`, `dzn`, `taillard`) are `False`, the function returns the in‑memory instance object (`JSP` or `FJSP`). Otherwise, it writes files under `savepath` and returns the last instance created.
+
+---
+
+## Generating a JSP problem instance
+
+To generate an instance of the problem, use the `Generator` class (module `Generador`). Initialize it and then call `generate_new_instance` with the parameters below.
+
+### Parameters (generation)
+
+1. **Jobs:** `jobs` — number of jobs. Default: `10`
+2. **Machines:** `machines` — number of machines. Default: `4`
+3. **Release and Due Date:** `ReleaseDateDueDate`
+   - `0`: neither jobs nor operations have release/due times (default)
+   - `1`: each job has a release and due date
+   - `2`: each operation has a release and due date
+4. **Speeds:** `speed` — number of speed levels. Default: `1`
+5. **Distribution:** `distribution` — `uniform`, `normal`, or `exponential`. Default: `normal`
+6. **Seed:** `seed` — random seed for reproducibility. Default: `1`
+
+### Parameters (output)
+
+- **JSON:** `json` (bool) — write JSON file(s). Default: `False`
+- **DZN:** `dzn` (bool) — write MiniZinc DZN file(s). Default: `False`
+- **Taillard:** `taillard` (bool) — write Taillard-like text file. Default: `False`
+- **Save Path:** `savepath` (str) — base path/template for outputs. Default: `./output`
+- **Single folder:** `single_folder_output` (bool) — whether to write all artifacts into a single folder. Default: `False`
+
+### Example (JSP)
+
+```python
+from IGJSP.generador import Generator
+generator = Generator(json=True, savepath="output")
+generator.generate_new_instance(
+    jobs=4, machines=2,
+    ReleaseDateDueDate=2,
+    distribution="exponential",
+    seed=53
+)
+```
+
+### Example of JSON generated (JSP)
+
+```json
+{
+    "nbJobs": [
+        0,
+        1
+    ],
+    "nbMchs": [
+        0,
+        1,
+        2,
+        3
+    ],
+    "speed": 1,
+    "timeEnergy": [
+        {
+            "jobId": 0,
+            "operations": {
+                "0": {
+                    "speed-scaling": [
+                        {
+                            "procTime": 8,
+                            "energyCons": 92
+                        }
+                    ],
+                    "release-date": 30,
+                    "due-date": 41
+                },
+                "2": {
+                    "speed-scaling": [
+                        {
+                            "procTime": 17,
+                            "energyCons": 84
+                        }
+                    ],
+                    "release-date": 41,
+                    "due-date": 77
+                },
+                "3": {
+                    "speed-scaling": [
+                        {
+                            "procTime": 3,
+                            "energyCons": 97
+                        }
+                    ],
+                    "release-date": 77,
+                    "due-date": 80
+                },
+                "1": {
+                    "speed-scaling": [
+                        {
+                            "procTime": 7,
+                            "energyCons": 93
+                        }
+                    ],
+                    "release-date": 80,
+                    "due-date": 88
+                }
+            },
+            "release-date": 30,
+            "due-date": 88
+        },
+        {
+            "jobId": 1,
+            "operations": {
+                "1": {
+                    "speed-scaling": [
+                        {
+                            "procTime": 4,
+                            "energyCons": 96
+                        }
+                    ],
+                    "release-date": 0,
+                    "due-date": 5
+                },
+                "3": {
+                    "speed-scaling": [
+                        {
+                            "procTime": 3,
+                            "energyCons": 97
+                        }
+                    ],
+                    "release-date": 5,
+                    "due-date": 9
+                },
+                "2": {
+                    "speed-scaling": [
+                        {
+                            "procTime": 1,
+                            "energyCons": 99
+                        }
+                    ],
+                    "release-date": 9,
+                    "due-date": 10
+                },
+                "0": {
+                    "speed-scaling": [
+                        {
+                            "procTime": 6,
+                            "energyCons": 94
+                        }
+                    ],
+                    "release-date": 10,
+                    "due-date": 17
+                }
+            },
+            "release-date": 0,
+            "due-date": 17
+        }
+    ],
+    "minMakespan": 35,
+    "minEnergy": 752,
+    "maxMinMakespan": 14,
+    "maxMinEnergy": 0
+}
+```
+
+---
+
+## Generating an FJSP problem instance
+
+Set `instance_type="FJSP"` to enable flexible routing. In the JSON output, each job includes an `available_machines` binary vector of length `nbMchs`, indicating where the job's operations can be processed (`1` = available, `0` = not available).
+
+### Example (FJSP)
+
+```python
+from IGJSP.generador import Generator
+generator = Generator(json=True, savepath="output")
+generator.generate_new_instance(
+    jobs=3, machines=3,
+    speed=1,
+    ReleaseDateDueDate=0,
+    distribution="uniform",
+    seed=7,
+    instance_type="FJSP"
+)
+```
+
+### Example of JSON generated (FJSP)
+
+Abridged example to illustrate the additional `available_machines` field:
+
+```json
+{
+  "nbJobs": [0,1,2],
+  "nbMchs": [0,1,2],
+  "speed": 1,
+  "timeEnergy": [
+    {
+      "jobId": 0,
+      "available_machines": [1,0,1],
+      "operations": {
+        "0": { "speed-scaling": [ { "procTime": 12, "energyCons": 90 } ] },
+        "2": { "speed-scaling": [ { "procTime": 18, "energyCons": 84 } ] },
+        "1": { "speed-scaling": [ { "procTime": 11, "energyCons": 89 } ] }
+      }
+    },
+    {
+      "jobId": 1,
+      "available_machines": [1,1,0],
+      "operations": {
+        "2": { "speed-scaling": [ { "procTime": 7, "energyCons": 93 } ] },
+        "0": { "speed-scaling": [ { "procTime": 5, "energyCons": 95 } ] },
+        "1": { "speed-scaling": [ { "procTime": 13, "energyCons": 88 } ] }
+      }
+    }
+  ],
+  "minMakespan": 123,
+  "minEnergy": 456,
+  "maxMinMakespan": 78,
+  "maxMinEnergy": 90
+}
+```
+
+---
+
+## Notes on outputs
+
+- **JSON**: Contains `nbJobs`, `nbMchs`, `speed`, and a `timeEnergy` list with per‑job `operations`. For `ReleaseDateDueDate=1` (per job) or `2` (per operation), `release-date`/`due-date` fields are added accordingly.
+- **DZN**: The generator writes `.dzn` files using templates located inside generator packages, parameterized by the selected RD mode and speed levels.
+- **Taillard-like**: Writes textual matrices for processing times, energy consumption, and the job‑specific machine order; the FJSP variant also appends an `Available machines:` section (binary rows per job).
+
+---
+
+## Reproducibility & scaling tips
+
+- Use a fixed `seed` to reproduce instances exactly.
+- For tighter value ranges (e.g., unit testing), prefer `distribution="uniform"` and post‑scale arrays if you require strict bounds (e.g., map processing times to `[1,100]` after generation). Energy values are already normalized to `[1,100]` by design.

igjsp-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+IGJSP/generador.py,sha256=AuiRTZ-tfRVt8U0-EECznq85NtDZsLyZLCAIjM1U8-8,34124
+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
+IGJSP/Minizinc/Models/RD/JSP2.mzn,sha256=ATqpg-Ow_VzjQJ_hZSSXiTXmwmqNqFsq81TZgcnjTks,2941
+IGJSP/Minizinc/Types/RD/JSP0.mzn,sha256=cfN_E3RQ6nBulGfaOOYTd-zAgA5SI6E2saDlYtKCflg,2282
+IGJSP/Minizinc/Types/RD/JSP1.mzn,sha256=5B8cyw2WyKR8yEL1fFd0TaCAVhjPoxEJRJDPPEjJGEk,2840
+IGJSP/Minizinc/Types/RD/JSP2.mzn,sha256=ATqpg-Ow_VzjQJ_hZSSXiTXmwmqNqFsq81TZgcnjTks,2941
+IGJSP/Minizinc/Types/RD/FJSP/type0.dzn,sha256=lhHhITCHzWrChnmOsyVMPoNGdIJ9S09bg9JfmwgY16Q,330
+IGJSP/Minizinc/Types/RD/FJSP/type1.dzn,sha256=bUGYq03ZlQId5xdDwEy5s2Y_iE0LkVZO3camiGKva2A,400
+IGJSP/Minizinc/Types/RD/FJSP/type2.dzn,sha256=Wz1MnkSL5GUPsbh1eq0leoaQRImkNqQqkXh9fWoGhRM,446
+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/Minizinc/Types/RD/type0.dzn

@@ -1,8 +0,0 @@
-%SETS
-JOBS = 1..{jobs};
-MACHINES = 1..{machines};
-SPEED    = {Speed};
-
-time = array3d(JOBS,MACHINES,1..SPEED,{time});
-energy = array3d(JOBS,MACHINES,1..SPEED,{energy});
-precedence = array2d(JOBS,MACHINES,{precedence});

IGJSP/Minizinc/Types/RD/type1.dzn

@@ -1,10 +0,0 @@
-%SETS
-JOBS     = 1..{jobs};
-MACHINES = 1..{machines};
-SPEED    = {Speed};
-
-time        = array3d(JOBS,MACHINES,1..SPEED,{time});
-energy      = array3d(JOBS,MACHINES,1..SPEED,{energy});
-precedence  = array2d(JOBS,MACHINES,{precedence});
-releaseDate = {releaseDate};
-dueDate     = {dueDate};

IGJSP/Minizinc/Types/RD/type2.dzn

@@ -1,10 +0,0 @@
-%SETS
-JOBS     = 1..{jobs};
-MACHINES = 1..{machines};
-SPEED    = {Speed};
-
-time        = array3d(JOBS,MACHINES,1..SPEED,{time});
-energy      = array3d(JOBS,MACHINES,1..SPEED,{energy});
-precedence  = array2d(JOBS,MACHINES,{precedence});
-releaseDate = array2d(JOBS,MACHINES,{releaseDate});
-dueDate     = array2d(JOBS,MACHINES,{dueDate});

igjsp-0.0.10.dist-info/METADATA

@@ -1,216 +0,0 @@
-Metadata-Version: 2.4
-Name: IGJSP
-Version: 0.0.10
-Summary: Instance generator for JSP
-Project-URL: Homepage, https://gps.blogs.upv.es/
-Author-email: GPS-UPV <gps@dsic.upv.es>
-License-File: LICENSE
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.9
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: tqdm
-Description-Content-Type: text/markdown
-
-# Instance Generator Job Shop Scheduling
-
-## Description
-Benchmark generator for the Job Shop Problem (BG-JSP)
-
-## Generating a JSP problem instance
-
-To generate an instance of the problem, we will use the Generator class, located in the Generador module.
-To do this, we initialize the generator, giving it the following parameters:
-
-1. **JSON:`json`**
-   - **Description**: Parameter that indicates if the generated instance will be stored in JSON format.
-   - **Possible values**: Boolean value. Only the values True or False can be obtained.
-   - **Example of possible values**: `True`, `False`
-   - **Default value**: `False`
-
-2. **DZN:`dzn`**
-   - **Description**: Parameter that indicates if the generated instance will be stored in DZN format.
-   - **Possible values**: Boolean value. Only the values True or False can be obtained.
-   - **Example of possible values**: `True`, `False`
-   - **Default value**: `False`
-
-3. **Taillard:`taillard`**
-   - **Description**: Parameter that indicates if the generated instance will be stored in taillard format.
-   - **Possible values**: Boolean value. Only the values True or False can be obtained.
-   - **Example of possible values**: `True`, `False`
-   - **Default value**: `False`
-
-4. **Save Path:`savepath`**
-   - **Description**: Path where the problem instance file will be generated. 
-   - **Possible values**: String.
-   - **Example of possible values**: `./problems`, `./instances`
-   - **Default value**: `./output`
-
-
-Once the generator has been initialized, we proceed to generate different instances of the JSP problem with different values for this initialization; for that we use the following function using the following parameters to customize the generated instances:
-
-1. **Jobs:`jobs`**
-   - **Description**: Number of jobs that will have the problem generated.
-   - **Possible values**: Integer value.
-   - **Example of possible values**: `3`, `4`.
-   - **Default value**: `10`
-
-2. **Machines:`machines`**
-   - **Description**: Number of machines that will have the problem generated.
-   - **Possible values**: Integer value.
-   - **Example of possible values**: `6`, `2`.
-   - **Default value**: `4`
-
-3. **Release and Due Date:`ReleaseDateDueDate`**
-   - **Descripción**: Establish that each task has an instant of release and completion limit.
-   - **Possible values**: 
-      - `0`: Neither the works nor the operations of each of them will have an instant release or time limit for completion.
-      - `1`: The work will have an instant of release and instant of completion limit.
-      - `2`: The operations of each job will have a release time and a limiting end time.
-   - **Example of possible values**: `1`, `2`
-   - **Default value**: `0`
-
-4. **Speeds:`speed`**
-   - **Description**: Number of speeds that will be available to perform each task.
-   - **Possible values**: Integer value.
-   - **Example of possible values**: `3`, `5`
-   - **Default value**: `1`
-
-5. **Distribution:`distribution`**
-   - **Description**: Type of distribution to be followed for data generation.
-   - **Possible values**: You can only set one of the following values: `uniform` `normal` `exponential.`
-   - **Example of possible values**: `uniform`, `exponential`
-   - **Default value**: `normal`
-
-6. **Seed:`seed`**
-   - **Description**: Base number for data generation.
-   - **Possible values**: Integer value.
-   - **Example of possible values**: `84`, `32`
-   - **Default value**: `1`
-
-## Example of JSON generated
-
-This JSON shows how the data generated from a JSP problem with 2 machines and 4 jobs will look. For this generation, we have the following code:
-``` python
-from IGJSP.generador import Generator
-generator = Generator(json=True,savepath="output")
-generator.generate_new_instance(jobs=4,machines=2,ReleaseDateDueDate=2,distribution="exponential",seed=53) 
-```
-
-```json
-{
-    "nbJobs": [
-        0,
-        1
-    ],
-    "nbMchs": [
-        0,
-        1,
-        2,
-        3
-    ],
-    "speed": 1,
-    "timeEnergy": [
-        {
-            "jobId": 0,
-            "operations": {
-                "0": {
-                    "speed-scaling": [
-                        {
-                            "procTime": 8,
-                            "energyCons": 92
-                        }
-                    ],
-                    "release-date": 30,
-                    "due-date": 41
-                },
-                "2": {
-                    "speed-scaling": [
-                        {
-                            "procTime": 17,
-                            "energyCons": 84
-                        }
-                    ],
-                    "release-date": 41,
-                    "due-date": 77
-                },
-                "3": {
-                    "speed-scaling": [
-                        {
-                            "procTime": 3,
-                            "energyCons": 97
-                        }
-                    ],
-                    "release-date": 77,
-                    "due-date": 80
-                },
-                "1": {
-                    "speed-scaling": [
-                        {
-                            "procTime": 7,
-                            "energyCons": 93
-                        }
-                    ],
-                    "release-date": 80,
-                    "due-date": 88
-                }
-            },
-            "release-date": 30,
-            "due-date": 88
-        },
-        {
-            "jobId": 1,
-            "operations": {
-                "1": {
-                    "speed-scaling": [
-                        {
-                            "procTime": 4,
-                            "energyCons": 96
-                        }
-                    ],
-                    "release-date": 0,
-                    "due-date": 5
-                },
-                "3": {
-                    "speed-scaling": [
-                        {
-                            "procTime": 3,
-                            "energyCons": 97
-                        }
-                    ],
-                    "release-date": 5,
-                    "due-date": 9
-                },
-                "2": {
-                    "speed-scaling": [
-                        {
-                            "procTime": 1,
-                            "energyCons": 99
-                        }
-                    ],
-                    "release-date": 9,
-                    "due-date": 10
-                },
-                "0": {
-                    "speed-scaling": [
-                        {
-                            "procTime": 6,
-                            "energyCons": 94
-                        }
-                    ],
-                    "release-date": 10,
-                    "due-date": 17
-                }
-            },
-            "release-date": 0,
-            "due-date": 17
-        }
-    ],
-    "minMakespan": 35,
-    "minEnergy": 752,
-    "maxMinMakespan": 14,
-    "maxMinEnergy": 0
-}
-```

igjsp-0.0.10.dist-info/RECORD

@@ -1,24 +0,0 @@
-IGJSP/generador.py,sha256=lOgB0hDKLboO-eubDL8DV7dvK8XfnQ2MvXRc_CkkZdk,27747
-IGJSP/main.py,sha256=qnpAdI9Nymfbb2t674EHKCZr1vG80tGyVT5RKMiGvZM,2727
-IGJSP/Minizinc/Models/RD/JSP0.mzn,sha256=cfN_E3RQ6nBulGfaOOYTd-zAgA5SI6E2saDlYtKCflg,2282
-IGJSP/Minizinc/Models/RD/JSP1.mzn,sha256=5B8cyw2WyKR8yEL1fFd0TaCAVhjPoxEJRJDPPEjJGEk,2840
-IGJSP/Minizinc/Models/RD/JSP2.mzn,sha256=ATqpg-Ow_VzjQJ_hZSSXiTXmwmqNqFsq81TZgcnjTks,2941
-IGJSP/Minizinc/Types/RD/JSP0.mzn,sha256=cfN_E3RQ6nBulGfaOOYTd-zAgA5SI6E2saDlYtKCflg,2282
-IGJSP/Minizinc/Types/RD/JSP1.mzn,sha256=5B8cyw2WyKR8yEL1fFd0TaCAVhjPoxEJRJDPPEjJGEk,2840
-IGJSP/Minizinc/Types/RD/JSP2.mzn,sha256=ATqpg-Ow_VzjQJ_hZSSXiTXmwmqNqFsq81TZgcnjTks,2941
-IGJSP/Minizinc/Types/RD/type0.dzn,sha256=alo54TrPd2svp-YeOq8rNhb42Aj5w4N1y1WYRxZ-aWM,225
-IGJSP/Minizinc/Types/RD/type1.dzn,sha256=r3f1uOoDnscjpXHbpvOWPGhGN0tmwkJ3NYIRP-NGk5M,298
-IGJSP/Minizinc/Types/RD/type2.dzn,sha256=ddJxLqR_WlUpycHhA_QulxiTx3o9neIzNESEt59VUx0,344
-IGJSP/Minizinc/Models/RD/JSP0.mzn,sha256=cfN_E3RQ6nBulGfaOOYTd-zAgA5SI6E2saDlYtKCflg,2282
-IGJSP/Minizinc/Models/RD/JSP1.mzn,sha256=5B8cyw2WyKR8yEL1fFd0TaCAVhjPoxEJRJDPPEjJGEk,2840
-IGJSP/Minizinc/Models/RD/JSP2.mzn,sha256=ATqpg-Ow_VzjQJ_hZSSXiTXmwmqNqFsq81TZgcnjTks,2941
-IGJSP/Minizinc/Types/RD/JSP0.mzn,sha256=cfN_E3RQ6nBulGfaOOYTd-zAgA5SI6E2saDlYtKCflg,2282
-IGJSP/Minizinc/Types/RD/JSP1.mzn,sha256=5B8cyw2WyKR8yEL1fFd0TaCAVhjPoxEJRJDPPEjJGEk,2840
-IGJSP/Minizinc/Types/RD/JSP2.mzn,sha256=ATqpg-Ow_VzjQJ_hZSSXiTXmwmqNqFsq81TZgcnjTks,2941
-IGJSP/Minizinc/Types/RD/type0.dzn,sha256=alo54TrPd2svp-YeOq8rNhb42Aj5w4N1y1WYRxZ-aWM,225
-IGJSP/Minizinc/Types/RD/type1.dzn,sha256=r3f1uOoDnscjpXHbpvOWPGhGN0tmwkJ3NYIRP-NGk5M,298
-IGJSP/Minizinc/Types/RD/type2.dzn,sha256=ddJxLqR_WlUpycHhA_QulxiTx3o9neIzNESEt59VUx0,344
-igjsp-0.0.10.dist-info/METADATA,sha256=cAMGyVrod2bEHE5AUU5OG5uR96i3tVS8C162l07hCzA,7407
-igjsp-0.0.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-igjsp-0.0.10.dist-info/licenses/LICENSE,sha256=f7RDRO-z_nMoooAya7NAb8sXtrHR6WnttYtyUc9fB-c,1116
-igjsp-0.0.10.dist-info/RECORD,,