pyVolutionary 2.3.0__tar.gz → 2.4.0__tar.gz

{pyvolutionary-2.3.0 → pyvolutionary-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyVolutionary
-Version: 2.3.0
+Version: 2.4.0
 Summary: pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems.
 Home-page: https://github.com/matteocacciola/pyvolutionary
 License: MIT
@@ -93,13 +93,15 @@ continuous and discrete variables. In order to do so, you need to define a `Task
 `Task` class of the library. The list of variables in the problem must be specified in the constructor of the class
 inheriting from `Task`. The following table describes the types of variables currently implemented in the library.
 
-| Variable type   | Class name               | Description                                                    | Example                                                                            |
-|-----------------|--------------------------|----------------------------------------------------------------|------------------------------------------------------------------------------------|
-| Continuous      | `ContinuousVariable`     | A continuous variable                                          | `ContinuousVariable(name="x0", lower_bound=-100.0, upper_bound=100.0)`             |
-| Discrete        | `DiscreteVariable`       | A discrete variable                                            | `DiscreteVariable(choices=["scale", "auto", 0.01, 0.1, 0.5, 1.0], name="gamma")`   |
-| Permutation     | `PermutationVariable`    | A permutation of the specified choices                         | `PermutationVariable(items=[[60, 200], [180, 200], [80, 180]], name="routes")`     |
-| Binary          | `BinaryVariable`         | A type of variable used for problems where the data are binary | `BinaryVariable(name="x", n_vars=10)`                                              |
-| Multi-objective | `MultiObjectiveVariable` | A type of variable used for multi-objective problems           | `MultiObjectiveVariable(name="x", lower_bounds=(-10, -10), upper_bounds=(10, 10))` |
+| Variable type    | Class name                | Description                                                    | Example                                                                                                  |
+|------------------|---------------------------|----------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
+| Continuous       | `ContinuousVariable`      | A continuous variable                                          | `ContinuousVariable(name="x0", lower_bound=-100.0, upper_bound=100.0)`                                   |
+| Continuous (set) | `ContinuousMultiVariable` | A set of continuous variables                                  | `ContinuousMultiVariable(name="x0", lower_bounds=[-100.0, -200.0], upper_bounds=[100.0, 50.0])`          |
+| Discrete         | `DiscreteVariable`        | A discrete variable                                            | `DiscreteVariable(choices=["scale", "auto", 0.01, 0.1, 0.5, 1.0], name="gamma")`                         |
+| Discrete (set)   | `DiscreteMultiVariable`   | A set of discrete variables                                    | `DiscreteMultiVariable(choices=[[0.1, 10, 100], ["scale", "auto", 0.01, 0.1, 0.5, 1.0]], name="params")` |
+| Permutation      | `PermutationVariable`     | A permutation of the specified choices                         | `PermutationVariable(items=[[60, 200], [180, 200], [80, 180]], name="routes")`                           |
+| Binary           | `BinaryVariable`          | A type of variable used for problems where the data are binary | `BinaryVariable(name="x", n_vars=10)`                                                                    |
+| Multi-objective  | `MultiObjectiveVariable`  | A type of variable used for multi-objective problems           | `MultiObjectiveVariable(name="x", lower_bounds=(-10, -10), upper_bounds=(10, 10))`                       |
 
 An example of a custom `Task` class is the following:
 
@@ -176,7 +178,7 @@ task = Sphere(
 For example, let us inspect how you can solve the continuous _sphere_ problem with the Particle Swarm Optimization algorithm.
 
 ```python
-from pyvolutionary import ContinuousVariable, ParticleSwarmOptimization, ParticleSwarmOptimizationConfig, Task
+from pyvolutionary import ContinuousMultiVariable, ParticleSwarmOptimization, ParticleSwarmOptimizationConfig, Task
 
 # Define the problem, you can replace the following class with your custom problem to optimize
 class Sphere(Task):
@@ -188,22 +190,14 @@ class Sphere(Task):
 
 
 # Define the task with the bounds and the configuration of the optimizer
-population = 200
-dimension = 2
-position_min = -100.0
-position_max = 100.0
-generation = 400
-fitness_error = 10e-4
 task = Sphere(
-    variables=[ContinuousVariable(
-        name=f"x{i}", lower_bound=position_min, upper_bound=position_max
-    ) for i in range(dimension)],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=[-100.0, -100.0], upper_bound=[100.0, 100.0])],
 )
 
 configuration = ParticleSwarmOptimizationConfig(
-    population_size=population,
-    fitness_error=fitness_error,
-    max_cycles=generation,
+    population_size=200,
+    fitness_error=10e-4,
+    max_cycles=400,
     c1=0.1,
     c2=0.1,
     w=[0.35, 1],
@@ -438,7 +432,7 @@ implemented in the library):
 
 ```python
 import numpy as np
-from pyvolutionary import Task, ContinuousVariable, AntLionOptimization, AntLionOptimizationConfig
+from pyvolutionary import Task, ContinuousMultiVariable, AntLionOptimization, AntLionOptimizationConfig
 
 ## Link: https://onlinelibrary.wiley.com/doi/pdf/10.1002/9781119136507.app2
 class ConstrainedBenchmark(Task):
@@ -482,12 +476,10 @@ class ConstrainedBenchmark(Task):
 
 
 # Define the task with the bounds and the configuration of the optimizer
+lower_bounds = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+upper_bounds = [1, 1, 1, 1, 1, 1, 1, 1, 1, 100, 100, 100, 1]
 task = ConstrainedBenchmark(
-    variables=(
-        [ContinuousVariable(name=f"x{i}", lower_bound=0, upper_bound=1) for i in range(9)] + [
-            ContinuousVariable(name=f"x{i}", lower_bound=0, upper_bound=100) for i in range(9, 12)
-        ] + [ContinuousVariable(name=f"x12", lower_bound=0, upper_bound=1)]
-    )
+    variables=([ContinuousMultiVariable(name="x", lower_bounds=lower_bounds, upper_bounds=upper_bounds)])
 )
 
 configuration = AntLionOptimizationConfig(population_size=200, fitness_error=10e-4, max_cycles=400)
@@ -533,7 +525,7 @@ but it uses the algorithms implemented in the library to perform the search. The
 ```python
 from opfunu.cec_based.cec2017 import F52017
 
-from pyvolutionary import ContinuousVariable, Task, BiogeographyBasedOptimization, GridSearchCV
+from pyvolutionary import ContinuousMultiVariable, Task, BiogeographyBasedOptimization, GridSearchCV
 
 f1 = F52017(30, f_bias=0)
 
@@ -546,9 +538,7 @@ class Problem(Task):
 
 # Define the task with the bounds and the configuration of the optimizer
 task = Problem(
-    variables=[
-        ContinuousVariable(name=f"x{i}", lower_bound=f1.lb[i], upper_bound=f1.ub[i]) for i in range(0, f1.ndim)
-    ],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f1.lb, upper_bounds=f1.ub)],
 )
 
 params_bbo_grid = {
@@ -587,7 +577,7 @@ to use the `Multitask` class:
 from opfunu.cec_based.cec2017 import F52017, F102017, F292017
 
 from pyvolutionary import (
-    ContinuousVariable,
+    ContinuousMultiVariable,
     Task,
     NuclearReactionOptimization,
     Multitask,
@@ -621,19 +611,13 @@ class Problem3(Task):
 
 
 task1 = Problem1(
-    variables=[
-        ContinuousVariable(name=f"x{i}", lower_bound=f1.lb[i], upper_bound=f1.ub[i]) for i in range(0, f1.ndim)
-    ],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f1.lb, upper_bounds=f1.ub)],
 )
 task2 = Problem2(
-    variables=[
-        ContinuousVariable(name=f"x{i}", lower_bound=f2.lb[i], upper_bound=f2.ub[i]) for i in range(0, f2.ndim)
-    ],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f2.lb, upper_bounds=f2.ub)],
 )
 task3 = Problem3(
-    variables=[
-        ContinuousVariable(name=f"x{i}", lower_bound=f3.lb[i], upper_bound=f3.ub[i]) for i in range(0, f3.ndim)
-    ],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f3.lb, upper_bounds=f3.ub)],
 )
 
 model1 = NuclearReactionOptimization(

{pyvolutionary-2.3.0 → pyvolutionary-2.4.0}/README.md

@@ -64,13 +64,15 @@ continuous and discrete variables. In order to do so, you need to define a `Task
 `Task` class of the library. The list of variables in the problem must be specified in the constructor of the class
 inheriting from `Task`. The following table describes the types of variables currently implemented in the library.
 
-| Variable type   | Class name               | Description                                                    | Example                                                                            |
-|-----------------|--------------------------|----------------------------------------------------------------|------------------------------------------------------------------------------------|
-| Continuous      | `ContinuousVariable`     | A continuous variable                                          | `ContinuousVariable(name="x0", lower_bound=-100.0, upper_bound=100.0)`             |
-| Discrete        | `DiscreteVariable`       | A discrete variable                                            | `DiscreteVariable(choices=["scale", "auto", 0.01, 0.1, 0.5, 1.0], name="gamma")`   |
-| Permutation     | `PermutationVariable`    | A permutation of the specified choices                         | `PermutationVariable(items=[[60, 200], [180, 200], [80, 180]], name="routes")`     |
-| Binary          | `BinaryVariable`         | A type of variable used for problems where the data are binary | `BinaryVariable(name="x", n_vars=10)`                                              |
-| Multi-objective | `MultiObjectiveVariable` | A type of variable used for multi-objective problems           | `MultiObjectiveVariable(name="x", lower_bounds=(-10, -10), upper_bounds=(10, 10))` |
+| Variable type    | Class name                | Description                                                    | Example                                                                                                  |
+|------------------|---------------------------|----------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
+| Continuous       | `ContinuousVariable`      | A continuous variable                                          | `ContinuousVariable(name="x0", lower_bound=-100.0, upper_bound=100.0)`                                   |
+| Continuous (set) | `ContinuousMultiVariable` | A set of continuous variables                                  | `ContinuousMultiVariable(name="x0", lower_bounds=[-100.0, -200.0], upper_bounds=[100.0, 50.0])`          |
+| Discrete         | `DiscreteVariable`        | A discrete variable                                            | `DiscreteVariable(choices=["scale", "auto", 0.01, 0.1, 0.5, 1.0], name="gamma")`                         |
+| Discrete (set)   | `DiscreteMultiVariable`   | A set of discrete variables                                    | `DiscreteMultiVariable(choices=[[0.1, 10, 100], ["scale", "auto", 0.01, 0.1, 0.5, 1.0]], name="params")` |
+| Permutation      | `PermutationVariable`     | A permutation of the specified choices                         | `PermutationVariable(items=[[60, 200], [180, 200], [80, 180]], name="routes")`                           |
+| Binary           | `BinaryVariable`          | A type of variable used for problems where the data are binary | `BinaryVariable(name="x", n_vars=10)`                                                                    |
+| Multi-objective  | `MultiObjectiveVariable`  | A type of variable used for multi-objective problems           | `MultiObjectiveVariable(name="x", lower_bounds=(-10, -10), upper_bounds=(10, 10))`                       |
 
 An example of a custom `Task` class is the following:
 
@@ -147,7 +149,7 @@ task = Sphere(
 For example, let us inspect how you can solve the continuous _sphere_ problem with the Particle Swarm Optimization algorithm.
 
 ```python
-from pyvolutionary import ContinuousVariable, ParticleSwarmOptimization, ParticleSwarmOptimizationConfig, Task
+from pyvolutionary import ContinuousMultiVariable, ParticleSwarmOptimization, ParticleSwarmOptimizationConfig, Task
 
 # Define the problem, you can replace the following class with your custom problem to optimize
 class Sphere(Task):
@@ -159,22 +161,14 @@ class Sphere(Task):
 
 
 # Define the task with the bounds and the configuration of the optimizer
-population = 200
-dimension = 2
-position_min = -100.0
-position_max = 100.0
-generation = 400
-fitness_error = 10e-4
 task = Sphere(
-    variables=[ContinuousVariable(
-        name=f"x{i}", lower_bound=position_min, upper_bound=position_max
-    ) for i in range(dimension)],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=[-100.0, -100.0], upper_bound=[100.0, 100.0])],
 )
 
 configuration = ParticleSwarmOptimizationConfig(
-    population_size=population,
-    fitness_error=fitness_error,
-    max_cycles=generation,
+    population_size=200,
+    fitness_error=10e-4,
+    max_cycles=400,
     c1=0.1,
     c2=0.1,
     w=[0.35, 1],
@@ -409,7 +403,7 @@ implemented in the library):
 
 ```python
 import numpy as np
-from pyvolutionary import Task, ContinuousVariable, AntLionOptimization, AntLionOptimizationConfig
+from pyvolutionary import Task, ContinuousMultiVariable, AntLionOptimization, AntLionOptimizationConfig
 
 ## Link: https://onlinelibrary.wiley.com/doi/pdf/10.1002/9781119136507.app2
 class ConstrainedBenchmark(Task):
@@ -453,12 +447,10 @@ class ConstrainedBenchmark(Task):
 
 
 # Define the task with the bounds and the configuration of the optimizer
+lower_bounds = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+upper_bounds = [1, 1, 1, 1, 1, 1, 1, 1, 1, 100, 100, 100, 1]
 task = ConstrainedBenchmark(
-    variables=(
-        [ContinuousVariable(name=f"x{i}", lower_bound=0, upper_bound=1) for i in range(9)] + [
-            ContinuousVariable(name=f"x{i}", lower_bound=0, upper_bound=100) for i in range(9, 12)
-        ] + [ContinuousVariable(name=f"x12", lower_bound=0, upper_bound=1)]
-    )
+    variables=([ContinuousMultiVariable(name="x", lower_bounds=lower_bounds, upper_bounds=upper_bounds)])
 )
 
 configuration = AntLionOptimizationConfig(population_size=200, fitness_error=10e-4, max_cycles=400)
@@ -504,7 +496,7 @@ but it uses the algorithms implemented in the library to perform the search. The
 ```python
 from opfunu.cec_based.cec2017 import F52017
 
-from pyvolutionary import ContinuousVariable, Task, BiogeographyBasedOptimization, GridSearchCV
+from pyvolutionary import ContinuousMultiVariable, Task, BiogeographyBasedOptimization, GridSearchCV
 
 f1 = F52017(30, f_bias=0)
 
@@ -517,9 +509,7 @@ class Problem(Task):
 
 # Define the task with the bounds and the configuration of the optimizer
 task = Problem(
-    variables=[
-        ContinuousVariable(name=f"x{i}", lower_bound=f1.lb[i], upper_bound=f1.ub[i]) for i in range(0, f1.ndim)
-    ],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f1.lb, upper_bounds=f1.ub)],
 )
 
 params_bbo_grid = {
@@ -558,7 +548,7 @@ to use the `Multitask` class:
 from opfunu.cec_based.cec2017 import F52017, F102017, F292017
 
 from pyvolutionary import (
-    ContinuousVariable,
+    ContinuousMultiVariable,
     Task,
     NuclearReactionOptimization,
     Multitask,
@@ -592,19 +582,13 @@ class Problem3(Task):
 
 
 task1 = Problem1(
-    variables=[
-        ContinuousVariable(name=f"x{i}", lower_bound=f1.lb[i], upper_bound=f1.ub[i]) for i in range(0, f1.ndim)
-    ],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f1.lb, upper_bounds=f1.ub)],
 )
 task2 = Problem2(
-    variables=[
-        ContinuousVariable(name=f"x{i}", lower_bound=f2.lb[i], upper_bound=f2.ub[i]) for i in range(0, f2.ndim)
-    ],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f2.lb, upper_bounds=f2.ub)],
 )
 task3 = Problem3(
-    variables=[
-        ContinuousVariable(name=f"x{i}", lower_bound=f3.lb[i], upper_bound=f3.ub[i]) for i in range(0, f3.ndim)
-    ],
+    variables=[ContinuousMultiVariable(name="x", lower_bounds=f3.lb, upper_bounds=f3.ub)],
 )
 
 model1 = NuclearReactionOptimization(

{pyvolutionary-2.3.0 → pyvolutionary-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyVolutionary"
-version = "2.3.0"
+version = "2.4.0"
 description = "pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems."
 authors = ["Matteo Cacciola <matteo.cacciola@gmail.com>"]
 license = "MIT"

{pyvolutionary-2.3.0 → pyvolutionary-2.4.0}/pyvolutionary/__init__.py

@@ -80,7 +80,9 @@ from .models import (
     Agent,
     Task,
     ContinuousVariable,
+    ContinuousMultiVariable,
     DiscreteVariable,
+    DiscreteMultiVariable,
     PermutationVariable,
     MultiObjectiveVariable,
     BinaryVariable,

{pyvolutionary-2.3.0 → pyvolutionary-2.4.0}/pyvolutionary/models.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from dataclasses import field
-from typing import TypeVar
+from typing import TypeVar, List, Tuple
 from typing import Any
 import numpy as np
 from pydantic import BaseModel, field_validator, model_validator, ConfigDict, PrivateAttr
@@ -198,6 +198,49 @@ class ContinuousVariable(Variable):
         return False
 
 
+class ContinuousMultiVariable(Variable):
+    lower_bounds: list[float]
+    upper_bounds: list[float]
+
+    _children: list[ContinuousVariable] = PrivateAttr()
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        lower_bounds, upper_bounds = self.get_bounds()
+        self._children = [ContinuousVariable(
+            name=f"{self.name}{i}", lower_bound=lb, upper_bound=ub
+        ) for i, (lb, ub) in enumerate(zip(lower_bounds, upper_bounds))]
+
+    @model_validator(mode="after")
+    def validate_bounds(self) -> "ContinuousMultiVariable":
+        if len(self.lower_bounds) != len(self.upper_bounds):
+            raise ValueError("Lower and upper bounds must have the same length")
+        if np.any(np.array([ub <= lb for lb, ub in zip(self.lower_bounds, self.upper_bounds)])):
+            raise ValueError("Upper bound must be greater than lower bound")
+        return self
+
+    def get(self) -> list["ContinuousVariable"]:
+        return self._children
+
+    def randomize(self):
+        return [v.randomize() for v in self._children]
+
+    def get_bounds(self) -> tuple[tuple[float] | list[float], tuple[float] | list[float]]:
+        return self.lower_bounds, self.upper_bounds
+
+    def correct(self, value: list):
+        return [v.correct(value[idx]) for idx, v in enumerate(self._children)]
+
+    def decode(self, value: list) -> list:
+        return [v.decode(value[idx]) for idx, v in enumerate(self._children)]
+
+    def size(self) -> int:
+        return len(self.lower_bounds)
+
+    def has_children(self) -> bool:
+        return True
+
+
 class DiscreteVariable(Variable):
     choices: list[Any]
 
@@ -224,6 +267,39 @@ class DiscreteVariable(Variable):
         return False
 
 
+class DiscreteMultiVariable(Variable):
+    choices: list[list[Any]]
+
+    _children: list[DiscreteVariable] = PrivateAttr()
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        self._children = [
+            DiscreteVariable(name=f"{self.name}{i}", choices=self.choices[i]) for i in range(len(self.choices))
+        ]
+
+    def get(self) -> list["DiscreteVariable"]:
+        return self._children
+
+    def randomize(self):
+        return [v.randomize() for v in self._children]
+
+    def get_bounds(self) -> list[tuple[int, int]]:
+        return [v.get_bounds() for v in self._children]
+
+    def correct(self, value: list):
+        return [v.correct(value[idx]) for idx, v in enumerate(self._children)]
+
+    def decode(self, value: list) -> list:
+        return [v.decode(value[idx]) for idx, v in enumerate(self._children)]
+
+    def size(self) -> int:
+        return len(self.choices)
+
+    def has_children(self) -> bool:
+        return True
+
+
 class PermutationVariable(Variable):
     items: list[Any]