diff --git a/_modules/pycellga/problems/abstract_problem.html b/_modules/pycellga/problems/abstract_problem.html index c7f8e90..4a3e03a 100644 --- a/_modules/pycellga/problems/abstract_problem.html +++ b/_modules/pycellga/problems/abstract_problem.html @@ -326,40 +326,91 @@

Source code for pycellga.problems.abstract_problem

+from abc import ABC, abstractmethod
+from typing import List, Tuple, Union, Any
+from pymoo.core.problem import Problem
+
 

 [docs]
-class AbstractProblem:
+class AbstractProblem(Problem, ABC):
     """
-    An abstract base class for optimization problems.
-
-    Methods
-    -------
-    f(x)
-        Evaluates the fitness of a given solution x.
+    Abstract base class for optimization problems.
     """
 
+

+[docs]
+    def __init__(self, 
+                 design_variables: Union[int, List[str]], 
+                 bounds: List[Tuple[float, float]], 
+                 objectives: Union[str, int, List[str]], 
+                 constraints: Union[str, int, List[str]] = []):
+        """
+        Initialize the problem with variables, bounds, objectives, and constraints.
+        
+        Parameters
+        ----------
+        design_variables : int or List[str]
+            If an integer, it specifies the number of design variables. 
+            If a list of strings, it specifies the names of design variables.
+        bounds : List[Tuple[float, float]]
+            Bounds for each design variable as (min, max).
+        objectives : str, int, or List[str]
+            Objectives for optimization, e.g., "minimize" or "maximize".
+        constraints : str, int, or List[str], optional
+            Constraints for the problem (default is an empty list).
+        """
+        # Ensure objectives and constraints are always lists
+        objectives = [str(objectives)] if isinstance(objectives, (str, int)) else list(objectives)
+        constraints = [str(constraints)] if isinstance(constraints, (str, int)) else list(constraints)
+
+        # Pymoo-specific attributes
+        n_var = design_variables if isinstance(design_variables, int) else len(design_variables)
+        xl = [bound[0] for bound in bounds]
+        xu = [bound[1] for bound in bounds]
+        
+        super().__init__(n_var=n_var, n_obj=len(objectives), n_constr=len(constraints), xl=xl, xu=xu)
+        
+        # Custom attributes
+        self.design_variables = [f"x{i+1}" for i in range(n_var)] if isinstance(design_variables, int) else design_variables
+        self.bounds = bounds
+        self.objectives = objectives
+        self.constraints = constraints

+
+
 

 [docs]
-    def f(self, x):
+    @abstractmethod
+    def f(self, x: List[Any]) -> float:
         """
-        Evaluate the fitness of a given solution x.
-
+        Abstract method for evaluating the fitness of a solution.
+        
         Parameters
         ----------
         x : list
-            A list representing a candidate solution.
-
+            List of design variable values.
+        
         Returns
         -------
         float
-            The fitness value of the candidate solution.
+            Fitness value.
+        """
+        raise NotImplementedError("Subclasses should implement this method.")

 
-        Raises
-        ------
-        NotImplementedError
-            If the method is not implemented by a subclass.
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Evaluate function for compatibility with pymoo's optimizer.
+        
+        Parameters
+        ----------
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
         """
-        raise NotImplementedError()

+        out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/continuous/ackley.html b/_modules/pycellga/problems/single_objective/continuous/ackley.html index 3d63d0b..9fea9eb 100644 --- a/_modules/pycellga/problems/single_objective/continuous/ackley.html +++ b/_modules/pycellga/problems/single_objective/continuous/ackley.html @@ -328,6 +328,7 @@

Source code for pycellga.problems.single_objective.continuous.ackley

 from numpy import pi, e, cos, sqrt, exp
 from problems.abstract_problem import AbstractProblem
+
 

 [docs]
 class Ackley(AbstractProblem):
@@ -340,12 +341,21 @@ 
Source code for pycellga.problems.single_objective.continuous.ackley
    Attributes
     ----------
-    None
+    design_variables : List[str]
+        List of variable names.
+    bounds : List[Tuple[float, float]]
+        Bounds for each variable.
+    objectives : List[str]
+        Objectives for optimization.
+    constraints : List[str]
+        Any constraints for the problem.
 
     Methods
     -------
-    f(x: list) -> float
-        Calculates the Ackley function value for a given list of variables.
+    evaluate(x, out, *args, **kwargs)
+        Calculates the Ackley function value for given variables.
+    f(x)
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
 
     Notes
     -----
@@ -353,34 +363,47 @@ 
Source code for pycellga.problems.single_objective.continuous.ackley
    Global minimum at f(0, 0) = 0
     """
 
-

-[docs]
-    def f(self, x: list) -> float:
+

+[docs]
+    def __init__(self, dimension: int):
+        design_variables = [f"x{i+1}" for i in range(dimension)]
+        bounds = [(-32.768, 32.768) for _ in range(dimension)]
+        objectives = ["minimize"]
+        constraints = []
+
+        super().__init__(design_variables, bounds, objectives, constraints)
+        self.dimension = dimension

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
         """
         Calculate the Ackley function value for a given list of variables.
 
         Parameters
         ----------
-        x : list
-            A list of float variables.
-
-        Returns
-        -------
-        float
-            The Ackley function value.
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
         """
-        sum1 = 0.0
-        sum2 = 0.0
-        fitness = 0.0
-
-        for i in range(len(x)):
-            gene = x[i]
-            sum1 += gene * gene
-            sum2 += cos(2 * pi * gene)
+        sum1 = sum(gene ** 2 for gene in x)
+        sum2 = sum(cos(2 * pi * gene) for gene in x)
         
-        fitness += -20.0 * exp(-0.2 * sqrt(sum1 / len(x))) - exp(sum2 / len(x)) + 20.0 + e
+        fitness = -20.0 * exp(-0.2 * sqrt(sum1 / self.dimension)) - exp(sum2 / self.dimension) + 20.0 + e
+        out["F"] = round(fitness, 3)

+
 
-        return round(fitness, 3)

+

+[docs]
+    def f(self, x):
+        """
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
+        """
+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/bentcigar.html b/_modules/pycellga/problems/single_objective/continuous/bentcigar.html index 1073ad1..e6f6b4a 100644 --- a/_modules/pycellga/problems/single_objective/continuous/bentcigar.html +++ b/_modules/pycellga/problems/single_objective/continuous/bentcigar.html @@ -328,6 +328,8 @@

Source code for pycellga.problems.single_objective.continuous.bentcigar

 from problems.abstract_problem import AbstractProblem
 from mpmath import power as pw
+from typing import List
+import numpy as np
 
 

 [docs]
@@ -340,12 +342,21 @@ 
Source code for pycellga.problems.single_objective.continuous.bentcigar

 
     Attributes
     ----------
-    None
+    design_variables : List[str]
+        List of variable names.
+    bounds : List[Tuple[float, float]]
+        Bounds for each variable.
+    objectives : List[str]
+        Objectives for optimization.
+    constraints : List[str]
+        Any constraints for the problem.
 
     Methods
     -------
-    f(X: list) -> float
-        Calculates the Bentcigar function value for a given list of variables.
+    evaluate(x, out, *args, **kwargs)
+        Calculates the Bentcigar function value for given variables.
+    f(x)
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
 
     Notes
     -----
@@ -353,30 +364,48 @@ 
Source code for pycellga.problems.single_objective.continuous.bentcigar

     Global minimum at f(0,...,0) = 0
     """
 
-

-[docs]
-    def f(self, X: list) -> float:
+

+[docs]
+    def __init__(self, dimension: int):
+        design_variables = [f"x{i+1}" for i in range(dimension)]
+        bounds = [(-100, 100) for _ in range(dimension)]
+        objectives = ["minimize"]
+        constraints = []
+
+        super().__init__(design_variables, bounds, objectives, constraints)
+        self.dimension = dimension

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
         """
         Calculate the Bentcigar function value for a given list of variables.
 
         Parameters
         ----------
-        X : list
-            A list of float variables.
-
-        Returns
-        -------
-        float
-            The Bentcigar function value.
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
         """
-        a = pw(X[0], 2)
+        a = pw(x[0], 2)
         b = pw(10, 6)
-        sum = 0.0
-        for i in range(1, len(X)):
-            sum += pw(X[i], 2)
+        sum_val = sum(pw(xi, 2) for xi in x[1:])
         
-        fitness = a + (b * sum)
-        return round(fitness, 3)

+        fitness = a + (b * sum_val)
+        out["F"] = round(fitness, 3)

+
+
+

+[docs]
+    def f(self, x):
+        """
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
+        """
+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/bohachevsky.html b/_modules/pycellga/problems/single_objective/continuous/bohachevsky.html index b5b2cd7..1c30270 100644 --- a/_modules/pycellga/problems/single_objective/continuous/bohachevsky.html +++ b/_modules/pycellga/problems/single_objective/continuous/bohachevsky.html @@ -326,9 +326,9 @@

Source code for pycellga.problems.single_objective.continuous.bohachevsky

-from numpy import cos
-from numpy import pi
+from numpy import cos, pi
 from mpmath import power as pw
+from typing import List, Dict, Any
 from problems.abstract_problem import AbstractProblem
 
 

@@ -342,12 +342,21 @@ 
Source code for pycellga.problems.single_objective.continuous.bohachevsky    Attributes
     ----------
-    None
+    design_variables : List[str]
+        List of variable names.
+    bounds : List[Tuple[float, float]]
+        Bounds for each variable.
+    objectives : List[str]
+        Objectives for optimization.
+    constraints : List[str]
+        Any constraints for the problem.
 
     Methods
     -------
-    f(x: list) -> float
-        Calculates the Bohachevsky function value for a given list of variables.
+    evaluate(x, out, *args, **kwargs)
+        Calculates the Bohachevsky function value for given variables.
+    f(x)
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
 
     Notes
     -----
@@ -355,9 +364,21 @@ 
Source code for pycellga.problems.single_objective.continuous.bohachevsky    Global minimum at f(0,...,0) = 0
     """
 
-

-[docs]
-    def f(self, x: list) -> float:
+

+[docs]
+    def __init__(self, dimension: int):
+        design_variables = [f"x{i+1}" for i in range(dimension)]
+        bounds = [(-15, 15) for _ in range(dimension)]
+        objectives = ["minimize"]
+        constraints = []
+
+        super().__init__(design_variables, bounds, objectives, constraints)
+        self.dimension = dimension

+
+
+

+[docs]
+    def evaluate(self, x: List[float], out: Dict[str, Any], *args, **kwargs):
         """
         Calculate the Bohachevsky function value for a given list of variables.
 
@@ -365,13 +386,27 @@ 
Source code for pycellga.problems.single_objective.continuous.bohachevsky        ----------
         x : list
             A list of float variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        fitness = sum([
+            pw(x[i], 2) + (2 * pw(x[i + 1], 2)) 
+            - (0.3 * cos(3 * pi * x[i])) 
+            - (0.4 * cos(4 * pi * x[i + 1])) + 0.7
+            for i in range(len(x) - 1)
+        ])
+        out["F"] = round(fitness, 3)

+
 
-        Returns
-        -------
-        float
-            The Bohachevsky function value.
+

+[docs]
+    def f(self, x: List[float]) -> float:
+        """
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
         """
-        return round(sum([(pw(x[i], 2) + (2 * pw(x[i + 1], 2)) - (0.3 * cos(3 * pi * x[i])) - (0.4 * cos(4 * pi * x[i + 1])) + 0.7) for i in range(len(x) - 1)]), 3)

+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/chichinadze.html b/_modules/pycellga/problems/single_objective/continuous/chichinadze.html index 3915d09..35c4728 100644 --- a/_modules/pycellga/problems/single_objective/continuous/chichinadze.html +++ b/_modules/pycellga/problems/single_objective/continuous/chichinadze.html @@ -326,8 +326,9 @@

Source code for pycellga.problems.single_objective.continuous.chichinadze

-from problems.abstract_problem import AbstractProblem
-import numpy as np
+import numpy as np
+from typing import List
+from problems.abstract_problem import AbstractProblem
 
 

 [docs]
@@ -340,12 +341,21 @@ 
Source code for pycellga.problems.single_objective.continuous.chichinadze    Attributes
     ----------
-    None
+    design_variables : List[str]
+        List of variable names.
+    bounds : List[Tuple[float, float]]
+        Bounds for each variable.
+    objectives : List[str]
+        Objectives for optimization.
+    constraints : List[str]
+        Any constraints for the problem.
 
     Methods
     -------
-    f(X: list) -> float
-        Calculates the Chichinadze function value for a given list of variables.
+    evaluate(x, out, *args, **kwargs)
+        Calculates the Chichinadze function value for given variables.
+    f(x)
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
 
     Notes
     -----
@@ -353,31 +363,49 @@ 
Source code for pycellga.problems.single_objective.continuous.chichinadze    Global minimum at f(5.90133, 0.5) = −43.3159
     """
 
-

-[docs]
-    def f(self, X: list) -> float:
+

+[docs]
+    def __init__(self):
+        design_variables = ["x", "y"]
+        bounds = [(-30, 30), (-30, 30)]
+        objectives = ["minimize"]
+        constraints = []
+
+        super().__init__(design_variables, bounds, objectives, constraints)

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
         """
         Calculate the Chichinadze function value for a given list of variables.
 
         Parameters
         ----------
-        X : list
-            A list of float variables.
-
-        Returns
-        -------
-        float
-            The Chichinadze function value.
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
         """
-        x = X[0]
-        y = X[1]
-        term1 = x**2 - 12 * x + 11
-        term2 = 10 * np.cos(np.pi * x / 2)
-        term3 = 8 * np.sin(5 * np.pi * x)
-        term4 = (1.0 / np.sqrt(5)) * np.exp(-((y - 0.5)**2) / 2)
+        x_val, y_val = x[0], x[1]
+        term1 = x_val**2 - 12 * x_val + 11
+        term2 = 10 * np.cos(np.pi * x_val / 2)
+        term3 = 8 * np.sin(5 * np.pi * x_val)
+        term4 = (1.0 / np.sqrt(5)) * np.exp(-((y_val - 0.5)**2) / 2)
         fitness = term1 + term2 + term3 - term4
-        
-        return round(fitness, 4)

+
+        out["F"] = round(fitness, 4)

+
+
+

+[docs]
+    def f(self, x: List[float]) -> float:
+        """
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
+        """
+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/dropwave.html b/_modules/pycellga/problems/single_objective/continuous/dropwave.html index e3fff7b..73f9988 100644 --- a/_modules/pycellga/problems/single_objective/continuous/dropwave.html +++ b/_modules/pycellga/problems/single_objective/continuous/dropwave.html @@ -327,11 +327,7 @@

Source code for pycellga.problems.single_objective.continuous.dropwave

 from problems.abstract_problem import AbstractProblem
-import math
-from numpy import *
-
-# -5.12 ≤ xi ≤ 5.12    i = 1,2
-# Global minimum at f(0,0) = −1
+from numpy import power, cos, sqrt
 
 

 [docs]
@@ -342,57 +338,76 @@ 
Source code for pycellga.problems.single_objective.continuous.dropwave
<
     The Dropwave function is a multimodal function commonly used as a performance test problem for optimization algorithms.
     It is defined within the bounds -5.12 ≤ xi ≤ 5.12 for i = 1, 2, and has a global minimum at f(0, 0) = -1.
 
+    Attributes
+    ----------
+    design_variables : list
+        The names of the variables, in this case ["x1", "x2"].
+    bounds : list of tuples
+        The lower and upper bounds for each variable, [-5.12, 5.12] for both x1 and x2.
+    objectives : list
+        List defining the optimization objective, which is to "minimize" for this function.
+    num_variables : int
+        The number of variables (dimensions) for the function, which is 2 in this case.
+
     Methods
     -------
-    f(x: list) -> float
-        Computes the value of the Dropwave function at a given point x.
+    evaluate(x, out, *args, **kwargs)
+        Calculates the value of the Dropwave function at a given point x.
+    f(x)
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
     """
 
-

-[docs]
-    def f(self, x: list) -> float:
+

+[docs]
+    def __init__(self):
+        # Dropwave problem-specific parameters
+        design_variables = ["x1", "x2"]
+        bounds = [(-5.12, 5.12), (-5.12, 5.12)]
+        objectives = ["minimize"]
+
+        # Initialize the AbstractProblem with specific parameters
+        super().__init__(design_variables, bounds, objectives)
+        self.num_variables = 2

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
         """
-        Evaluate the Dropwave function at a given point.
+        Calculate the Dropwave function value for a given list of variables.
 
         Parameters
         ----------
         x : list
             A list of two floats representing the coordinates [x1, x2].
-
-        Returns
-        -------
-        float
-            The value of the Dropwave function rounded to three decimal places.
+        out : dict
+            Dictionary to store the output fitness values.
 
         Notes
         -----
         The Dropwave function is defined as:
             f(x1, x2) = - (1 + cos(12 * sqrt(x1^2 + x2^2))) / (0.5 * (x1^2 + x2^2) + 2)
         where x1 and x2 are the input variables.
-
-        Examples
-        --------
-        >>> dropwave = Dropwave()
-        >>> dropwave.f([0, 0])
-        -1.0
-        >>> dropwave.f([1, 1])
-        -0.028
         """
-        # Extract the coordinates
-        x1 = x[0]
-        x2 = x[1]
-
-        # Compute the squared sums
-        sqrts_sums = power(x1, 2) + power(x2, 2)
-        
-        # Compute the denominator term
-        b = 0.5 * (sqrts_sums) + 2
+        if len(x) != self.num_variables:
+            raise ValueError(f"Input must have exactly {self.num_variables} variables.")
         
-        # Compute the fitness value
-        fitness = -(1 + cos(12 * sqrt(sqrts_sums))) / b
+        x1, x2 = x
+        sqrts_sums = power(x1, 2) + power(x2, 2)
+        denominator = 0.5 * sqrts_sums + 2
+        fitness = -(1 + cos(12 * sqrt(sqrts_sums))) / denominator
+        out["F"] = round(fitness, 3)

+
 
-        # Return the fitness value rounded to three decimal places
-        return round(fitness, 3)

+

+[docs]
+    def f(self, x):
+        """
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
+        """
+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/fms.html b/_modules/pycellga/problems/single_objective/continuous/fms.html index 318200f..85ea48e 100644 --- a/_modules/pycellga/problems/single_objective/continuous/fms.html +++ b/_modules/pycellga/problems/single_objective/continuous/fms.html @@ -327,7 +327,8 @@

Source code for pycellga.problems.single_objective.continuous.fms

 from problems.abstract_problem import AbstractProblem
-from numpy import pi, sin, random
+from numpy import pi, sin
+import numpy as np
 
 

 [docs]
@@ -339,62 +340,70 @@ 
Source code for pycellga.problems.single_objective.continuous.fms
    Attributes
     ----------
-    None
+    design_variables : List[str]
+        List of variable names.
+    bounds : List[Tuple[float, float]]
+        Bounds for each variable.
+    objectives : List[str]
+        Objectives for optimization.
+    constraints : List[str]
+        Any constraints for the problem.
 
     Methods
     -------
-    f(x: list) -> float
-        Calculates the Fms function value for a given list of variables.
-
-    Notes
-    -----
-    -6.4 ≤ xi ≤ 6.35
-    Length of chromosomes = 6
-    Maximum Fitness Value = 0.01
-    Maximum Fitness Value Error = 10^-2
+    evaluate(x, out, *args, **kwargs)
+        Calculates the Fms function value for given variables.
+    f(x)
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
     """
 
-

-[docs]
-    def f(self, x: list) -> float:
+

+[docs]
+    def __init__(self):
+        design_variables = ["a1", "w1", "a2", "w2", "a3", "w3"]
+        bounds = [(-6.4, 6.35)] * 6  # Same bounds for each variable
+        objectives = ["minimize"]
+        constraints = []
+        
+        super().__init__(design_variables, bounds, objectives, constraints)

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
         """
         Calculate the Fms function value for a given list of variables.
 
         Parameters
         ----------
-        x : list
-            A list of float variables.
-
-        Returns
-        -------
-        float
-            The Fms function value.
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
         """
         theta = (2.0 * pi) / 100.0
-        random.seed(100)
-
-        a1 = x[0]
-        w1 = x[1]
-        a2 = x[2]
-        w2 = x[3]
-        a3 = x[4]
-        w3 = x[5]
+        a1, w1, a2, w2, a3, w3 = x
 
         def yzero(t):
-            return 1.0 * sin((5.0 * theta * t) - (1.5 * sin((4.8 * theta * t) + (2.0 * sin(4.9 * theta * t)))))
-
-        distance = 0.0
-        partialfitness = 0.0
-        fitness = 0.0
+            return sin((5.0 * theta * t) - (1.5 * sin((4.8 * theta * t) + (2.0 * sin(4.9 * theta * t)))))
 
+        partial_fitness = 0.0
         for k in range(101):
-            distance = (
-                a1 * sin((w1 * theta * k) - (a2 * sin((w2 * theta * k) + (a3 * sin(w3 * theta * k))))))
-            distance -= yzero(k)
-            partialfitness += (distance * distance)
-        
-        fitness = partialfitness
-        return round(fitness, 3)

+            distance = a1 * sin((w1 * theta * k) - (a2 * sin((w2 * theta * k) + (a3 * sin(w3 * theta * k))))) - yzero(k)
+            partial_fitness += distance ** 2
+
+        out["F"] = round(partial_fitness, 3)

+
+
+

+[docs]
+    def f(self, x):
+        """
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
+        """
+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/griewank.html b/_modules/pycellga/problems/single_objective/continuous/griewank.html index d455a3c..1420002 100644 --- a/_modules/pycellga/problems/single_objective/continuous/griewank.html +++ b/_modules/pycellga/problems/single_objective/continuous/griewank.html @@ -328,6 +328,7 @@

Source code for pycellga.problems.single_objective.continuous.griewank

 from problems.abstract_problem import AbstractProblem
 import math
+from typing import List
 
 

 [docs]
@@ -338,10 +339,23 @@ 
Source code for pycellga.problems.single_objective.continuous.griewank
<
     The Griewank function is widely used for testing optimization algorithms.
     The function is usually evaluated on the hypercube x_i ∈ [-600, 600], for all i = 1, 2, ..., n.
 
+    Attributes
+    ----------
+    design_variables : List[str]
+        Names of the design variables.
+    bounds : List[Tuple[float, float]]
+        Bounds for each design variable.
+    objectives : List[str]
+        Objectives for optimization, typically ["minimize"].
+    constraints : List[str]
+        Any constraints for the optimization problem.
+
     Methods
     -------
-    f(X: list) -> float
-        Calculates the Griewank function value for a given list of variables.
+    evaluate(x, out, *args, **kwargs)
+        Evaluates the Griewank function value for a given list of variables.
+    f(x: list) -> float
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
 
     Notes
     -----
@@ -349,15 +363,54 @@ 
Source code for pycellga.problems.single_objective.continuous.griewank
<
     Global minimum at f(0,...,0) = 0
     """
 
+

+[docs]
+    def __init__(self, dimensions=10):
+        """
+        Initialize the Griewank function with the specified number of dimensions.
+
+        Parameters
+        ----------
+        dimensions : int, optional
+            The number of dimensions (design variables) for the Griewank function, by default 10.
+        """
+        design_variables = [f"x{i+1}" for i in range(dimensions)]
+        bounds = [(-600, 600)] * dimensions
+        objectives = ["minimize"]
+        constraints = []
+
+        super().__init__(design_variables, bounds, objectives, constraints)
+        self.dimensions = dimensions

+
+
+

+[docs]
+    def evaluate(self, x: List[float], out, *args, **kwargs):
+        """
+        Calculate the Griewank function value for a given list of variables.
+
+        Parameters
+        ----------
+        x : list
+            A list of float variables.
+        out : dict
+            Dictionary to store the output fitness value.
+        """
+        sum_sq = sum(xi ** 2 for xi in x)
+        prod_cos = math.prod(math.cos(xi / math.sqrt(i + 1)) for i, xi in enumerate(x))
+        fitness = 1 + sum_sq / 4000 - prod_cos
+        out["F"] = round(fitness, 3)

+
+
 

 [docs]
-    def f(self, X: list) -> float:
+    def f(self, x: List[float]) -> float:
         """
-        Calculate the Griewank function value for a given list of variables.
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
 
         Parameters
         ----------
-        X : list
+        x : list
             A list of float variables.
 
         Returns
@@ -365,10 +418,9 @@ 
Source code for pycellga.problems.single_objective.continuous.griewank
<
         float
             The Griewank function value.
         """
-        sum_sq = sum(x ** 2 for x in X)
-        prod_cos = math.prod(math.cos(X[i] / math.sqrt(i + 1)) for i in range(len(X)))
-        fitness = 1 + sum_sq / 4000 - prod_cos
-        return round(fitness, 3)

+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/holzman.html b/_modules/pycellga/problems/single_objective/continuous/holzman.html index 3b76fdc..4fd0cdc 100644 --- a/_modules/pycellga/problems/single_objective/continuous/holzman.html +++ b/_modules/pycellga/problems/single_objective/continuous/holzman.html @@ -328,6 +328,7 @@

Source code for pycellga.problems.single_objective.continuous.holzman

 from problems.abstract_problem import AbstractProblem
 from mpmath import power as pw
+from typing import List
 
 

 [docs]
@@ -340,12 +341,21 @@ 
Source code for pycellga.problems.single_objective.continuous.holzman
    Attributes
     ----------
-    None
+    design_variables : List[str]
+        Names of the design variables.
+    bounds : List[Tuple[float, float]]
+        Bounds for each variable.
+    objectives : List[str]
+        Objectives for optimization.
+    constraints : List[str]
+        Any constraints for the problem.
 
     Methods
     -------
+    evaluate(x, out, *args, **kwargs)
+        Calculates the Holzman function value for given variables.
     f(x: list) -> float
-        Calculates the Holzman function value for a given list of variables.
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
 
     Notes
     -----
@@ -353,9 +363,21 @@ 
Source code for pycellga.problems.single_objective.continuous.holzman
    Global minimum at f(0,...,0) = 0
     """
 
-

-[docs]
-    def f(self, x: list) -> float:
+

+[docs]
+    def __init__(self, design_variables: int = 2):
+        var_names = [f"x{i+1}" for i in range(design_variables)]
+        bounds = [(-10, 10) for _ in range(design_variables)]
+        objectives = ["minimize"]
+        constraints = []
+
+        super().__init__(var_names, bounds, objectives, constraints)
+        self.design_variables = design_variables

+
+
+

+[docs]
+    def evaluate(self, x: List[float], out, *args, **kwargs):
         """
         Calculate the Holzman function value for a given list of variables.
 
@@ -363,16 +385,22 @@ 
Source code for pycellga.problems.single_objective.continuous.holzman
        ----------
         x : list
             A list of float variables.
+        out : dict
+            Dictionary to store the output fitness value.
+        """
+        fitness = sum((i + 1) * pw(x[i], 4) for i in range(len(x)))
+        out["F"] = round(fitness, 3)

+
 
-        Returns
-        -------
-        float
-            The Holzman function value.
+

+[docs]
+    def f(self, x: List[float]) -> float:
+        """
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
         """
-        fitness = 0.0
-        for i in range(len(x)):
-            fitness += (i + 1) * pw(x[i], 4)
-        return round(fitness, 3)

+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/levy.html b/_modules/pycellga/problems/single_objective/continuous/levy.html index 7e94e6d..97ebcf2 100644 --- a/_modules/pycellga/problems/single_objective/continuous/levy.html +++ b/_modules/pycellga/problems/single_objective/continuous/levy.html @@ -329,6 +329,7 @@

Source code for pycellga.problems.single_objective.continuous.levy

from problems.abstract_problem import AbstractProblem import math from mpmath import power as pw +from typing import List
[docs] @@ -341,24 +342,71 @@

Source code for pycellga.problems.single_objective.continuous.levy

Attributes ---------- - None + design_variables : List[str] + The names of the design variables. + bounds : List[Tuple[float, float]] + The bounds for each variable, typically [(-10, 10), (-10, 10), ...]. + objectives : List[str] + Objectives for optimization, usually "minimize" for single-objective functions. + constraints : List[str] + Any constraints for the optimization problem. Methods ------- + evaluate(x, out, *args, **kwargs) + Calculates the Levy function value for a given list of variables and stores in `out`. f(x: list) -> float - Calculates the Levy function value for a given list of variables. + Alias for evaluate to maintain compatibility with the rest of the codebase. Notes ----- -10 ≤ xi ≤ 10 for i = 1,…,n - Global minimum at f(1,1) = 0 + Global minimum at f(1,1,...,1) = 0 """ +
+[docs] + def __init__(self, dimension: int = 2): + design_variables = [f"x{i+1}" for i in range(dimension)] + bounds = [(-10, 10) for _ in range(dimension)] + objectives = ["minimize"] + constraints = [] + + super().__init__(design_variables, bounds, objectives, constraints) + self.dimension = dimension
+ + +
+[docs] + def evaluate(self, x: List[float], out, *args, **kwargs): + """ + Evaluate the Levy function at a given point. + + Parameters + ---------- + x : list + A list of float variables. + out : dict + Dictionary to store the output fitness value. + """ + if len(x) != self.dimension: + raise ValueError(f"Input must have exactly {self.dimension} variables.") + + fitness = 0.0 + for i in range(self.dimension - 1): + term1 = pw(math.sin(3 * x[i] * math.pi), 2) + term2 = (pw((x[i] - 1), 2)) * (1 + pw(math.sin(3 * x[i + 1] * math.pi), 2)) + term3 = (pw((x[i + 1] - 1), 2)) * (1 + pw(math.sin(2 * x[i + 1] * math.pi), 2)) + fitness += term1 + term2 + term3 + + out["F"] = round(fitness, 3)
+ +
[docs] - def f(self, x: list) -> float: + def f(self, x: List[float]) -> float: """ - Calculate the Levy function value for a given list of variables. + Alias for evaluate to maintain compatibility with the rest of the codebase. Parameters ---------- @@ -368,19 +416,13 @@

Source code for pycellga.problems.single_objective.continuous.levy

Returns ------- float - The Levy function value. + The calculated Levy function value. """ - fitness = 0.0 - for i in range(len(x) - 1): - fitness += ( - pw((math.sin(3 * x[i] * math.pi)), 2) + - (pw((x[i] - 1), 2)) * (1 + pw((math.sin(3 * x[i + 1] * math.pi)), 2)) + - (pw((x[i + 1] - 1), 2)) * (1 + pw((math.sin(2 * x[i + 1] * math.pi)), 2)) - ) - return round(fitness, 3)
+ result = {} + self.evaluate(x, result) + return result["F"]
-
diff --git a/_modules/pycellga/problems/single_objective/continuous/matyas.html b/_modules/pycellga/problems/single_objective/continuous/matyas.html index 5fc3135..ad39d66 100644 --- a/_modules/pycellga/problems/single_objective/continuous/matyas.html +++ b/_modules/pycellga/problems/single_objective/continuous/matyas.html @@ -335,48 +335,66 @@

Source code for pycellga.problems.single_objective.continuous.matyas

""" Matyas function implementation for optimization problems. - The Matyas function is widely used for testing optimization algorithms. - The function is usually evaluated on the hypercube x_i ∈ [-10, 10], for all i = 1, 2, ..., n. - + The Matyas function is commonly used to evaluate the performance of optimization algorithms. + It is a simple, continuous, convex function that has a global minimum at the origin. + Attributes ---------- - None + design_variables : list of str + The names of the design variables, typically ["x1", "x2"] for 2 variables. + bounds : list of tuple + The bounds for each variable, typically [(-10, 10), (-10, 10)]. + objectives : list of str + The objectives for optimization, set to ["minimize"]. Methods ------- - f(X: list) -> float - Calculates the Matyas function value for a given list of variables. - - Notes - ----- - -10 ≤ xi ≤ 10 for i = 1,…,n - Global minimum at f(0,...,0) = 0 + evaluate(x, out, *args, **kwargs) + Computes the Matyas function value for a given list of variables. + f(x: list) -> float + Alias for evaluate to maintain compatibility with the rest of the codebase. """ -
-[docs] - def f(self, X: list) -> float: +
+[docs] + def __init__(self): + design_variables = ["x1", "x2"] + bounds = [(-10, 10), (-10, 10)] + objectives = ["minimize"] + + super().__init__(design_variables=design_variables, bounds=bounds, objectives=objectives)
+ + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): """ Calculate the Matyas function value for a given list of variables. Parameters ---------- - X : list - A list of float variables. + x : list of float + A list of float variables representing a point in the solution space. + out : dict + Dictionary to store the output fitness value with key "F". + """ + if len(x) != 2: + raise ValueError("Matyas function is defined for exactly 2 variables.") + + x1, x2 = x + fitness = 0.26 * (pw(x1, 2) + pw(x2, 2)) - 0.48 * x1 * x2 + out["F"] = round(fitness, 2)
+ - Returns - ------- - float - The Matyas function value. +
+[docs] + def f(self, x): + """ + Alias for the evaluate method to maintain compatibility with the rest of the codebase. """ - # Ensure X has at least 2 elements - if len(X) < 2: - raise ValueError("At least two variables are required for the Matyas function.") - - fitness = 0.0 - for i in range(len(X) - 1): - fitness += 0.26 * (pw(X[i], 2) + pw(X[i + 1], 2)) - 0.48 * X[i] * X[i + 1] - return round(fitness, 2)
+ result = {} + self.evaluate(x, result) + return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/pow.html b/_modules/pycellga/problems/single_objective/continuous/pow.html index a2de4ae..879176e 100644 --- a/_modules/pycellga/problems/single_objective/continuous/pow.html +++ b/_modules/pycellga/problems/single_objective/continuous/pow.html @@ -328,6 +328,7 @@

Source code for pycellga.problems.single_objective.continuous.pow

 from problems.abstract_problem import AbstractProblem
 from mpmath import power as pw
+from typing import List, Tuple
 
 

 [docs]
@@ -335,29 +336,70 @@ 
Source code for pycellga.problems.single_objective.continuous.pow
    """
     Pow function implementation for optimization problems.
 
-    The Pow function is widely used for testing optimization algorithms.
-    The function is usually evaluated on the hypercube x_i ∈ [-5.0, 15.0].
+    The Pow function is typically used for testing optimization algorithms.
+    It is evaluated on the hypercube x_i ∈ [-5.0, 15.0] with the goal of reaching 
+    the global minimum at f(5, 7, 9, 3, 2) = 0.
 
     Attributes
     ----------
-    None
+    design_variables : List[str]
+        The names of the design variables.
+    bounds : List[Tuple[float, float]]
+        The bounds for each variable, typically [(-5.0, 15.0) for each dimension].
+    objectives : List[str]
+        Objectives for optimization, e.g., "minimize".
 
     Methods
     -------
+    evaluate(x, out, *args, **kwargs)
+        Calculates the Pow function value for compatibility with Pymoo's optimizer.
     f(x: list) -> float
-        Calculates the Pow function value for a given list of variables.
-
-    Notes
-    -----
-    -5.0 ≤ xi ≤ 15.0
-    Global minimum at f(5, 7, 9, 3, 2) = 0
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
     """
 
+

+[docs]
+    def __init__(self, design_variables=5):
+        # Define design variable names
+        design_variable_names = [f"x{i+1}" for i in range(design_variables)]
+        bounds = [(-5.0, 15.0) for _ in range(design_variables)]
+        objectives = ["minimize"]
+
+        # Initialize the AbstractProblem
+        super().__init__(design_variable_names, bounds, objectives)
+        self.design_variables = design_variables

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Calculate the Pow function value for a given list of variables.
+
+        Parameters
+        ----------
+        x : list
+            A list of float variables representing the point in the solution space.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        if len(x) != self.design_variables:
+            raise ValueError(f"Input must have exactly {self.design_variables} variables.")
+
+        fitness = (pw(x[0] - 5, 2) +
+                   pw(x[1] - 7, 2) +
+                   pw(x[2] - 9, 2) +
+                   pw(x[3] - 3, 2) +
+                   pw(x[4] - 2, 2))
+
+        out["F"] = round(fitness, 2)

+
+
 

 [docs]
-    def f(self, x: list) -> float:
+    def f(self, x: List[float]) -> float:
         """
-        Calculate the Pow function value for a given list of variables.
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
 
         Parameters
         ----------
@@ -369,15 +411,9 @@ 
Source code for pycellga.problems.single_objective.continuous.pow
        float
             The Pow function value.
         """
-        fitness = 0.0
-        for i in range(len(x) - 4):
-            fitness += (pw(x[i] - 5, 2) +
-                        pw(x[i + 1] - 7, 2) +
-                        pw(x[i + 2] - 9, 2) +
-                        pw(x[i + 3] - 3, 2) +
-                        pw(x[i + 4] - 2, 2))
-
-        return round(fitness, 2)

+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/powell.html b/_modules/pycellga/problems/single_objective/continuous/powell.html index f76ef12..fb1a96b 100644 --- a/_modules/pycellga/problems/single_objective/continuous/powell.html +++ b/_modules/pycellga/problems/single_objective/continuous/powell.html @@ -329,7 +329,6 @@

Source code for pycellga.problems.single_objective.continuous.powell

from problems.abstract_problem import AbstractProblem from mpmath import power as pw -
[docs] class Powell(AbstractProblem): @@ -341,24 +340,60 @@

Source code for pycellga.problems.single_objective.continuous.powell

Attributes ---------- - None + design_variables : int + The number of variables for the problem. + bounds : list of tuple + The bounds for each variable, typically [(-4, 5), (-4, 5), ...]. + objectives : int + Number of objectives, set to 1 for single-objective optimization. Methods ------- - f(x: list) -> float - Calculates the Powell function value for a given list of variables. + evaluate(x, out, *args, **kwargs) -> None + Calculates the Powell function value and stores in the output dictionary. - Notes - ----- - -4 ≤ xi ≤ 5 for i = 1,…,n - Global minimum at f(0,....,0) = 0 + f(x: list) -> float + Wrapper for evaluate to maintain compatibility with the rest of the codebase. """ +
+[docs] + def __init__(self, design_variables=4): + bounds = [(-4, 5) for _ in range(design_variables)] + super().__init__(design_variables=design_variables, bounds=bounds, objectives=["minimize"])
+ + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): + """ + Evaluate the Powell function at a given point. + + Parameters + ---------- + x : list or numpy array + Input variables. + out : dict + Output dictionary to store the function value. + """ + fitness = 0.0 + d = len(x) // 4 + + for i in range(d): + a = pw(x[4 * i] + 10 * x[4 * i + 1], 2) + b = pw(x[4 * i + 2] - x[4 * i + 3], 2) + c = pw(x[4 * i + 1] - 2 * x[4 * i + 2], 4) + e = pw(x[4 * i] - x[4 * i + 3], 4) + fitness += a + 5 * b + c + 10 * e + + out["F"] = round(fitness, 1)
+ +
[docs] - def f(self, x: list) -> float: + def f(self, x): """ - Calculate the Powell function value for a given list of variables. + Wrapper for the evaluate method to maintain compatibility. Parameters ---------- @@ -368,20 +403,11 @@

Source code for pycellga.problems.single_objective.continuous.powell

Returns ------- float - The Powell function value. + The computed Powell function value. """ - fitness = 0.0 - n = len(x) - d = n // 4 - - for i in range(d): - a = pw(x[4*i] + 10 * x[4*i + 1], 2) - b = pw(x[4*i + 2] - x[4*i + 3], 2) - c = pw(x[4*i + 1] - 2 * x[4*i + 2], 4) - e = pw(x[4*i] - x[4*i + 3], 4) - fitness += a + 5 * b + c + 10 * e - - return round(fitness, 1)
+ result = {} + self.evaluate(x, result) + return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/rastrigin.html b/_modules/pycellga/problems/single_objective/continuous/rastrigin.html index 7954dff..3db43e7 100644 --- a/_modules/pycellga/problems/single_objective/continuous/rastrigin.html +++ b/_modules/pycellga/problems/single_objective/continuous/rastrigin.html @@ -328,6 +328,7 @@

Source code for pycellga.problems.single_objective.continuous.rastrigin

 from numpy import cos, pi
 from problems.abstract_problem import AbstractProblem
+
 

 [docs]
 class Rastrigin(AbstractProblem):
@@ -335,11 +336,16 @@ 
Source code for pycellga.problems.single_objective.continuous.rastrigin

     Rastrigin function implementation for optimization problems.
 
     The Rastrigin function is widely used for testing optimization algorithms.
-    The function is usually evaluated on the hypercube x_i ∈ [-5.12, 5.12], for all i = 1, 2, ..., n.
+    It is typically evaluated on the hypercube x_i ∈ [-5.12, 5.12], for all i = 1, 2, ..., n.
 
     Attributes
     ----------
-    None
+    design_variables : int
+        The number of variables for the problem.
+    bounds : list of tuple
+        The bounds for each variable, typically [(-5.12, 5.12), (-5.12, 5.12), ...].
+    objectives : int
+        Number of objectives, set to 1 for single-objective optimization.
 
     Methods
     -------
@@ -352,6 +358,22 @@ 
Source code for pycellga.problems.single_objective.continuous.rastrigin

     Global minimum at f(0,...,0) = 0
     """
 
+

+[docs]
+    def __init__(self, design_variables=2):
+        """
+        Initialize the Rastrigin problem with the specified number of variables.
+
+        Parameters
+        ----------
+        design_variables : int, optional
+            The number of design variables, by default 2.
+        """
+        self.design_variables = design_variables
+        self.bounds = [(-5.12, 5.12) for _ in range(design_variables)]
+        self.objectives = 1

+
+
 

 [docs]
     def f(self, x: list) -> float:
@@ -368,8 +390,12 @@ 
Source code for pycellga.problems.single_objective.continuous.rastrigin

         float
             The Rastrigin function value.
         """
+        if len(x) != self.design_variables:
+            raise ValueError(f"Input must have exactly {self.design_variables} variables.")
+
         A = 10.0
-        return round((A * len(x)) + sum([(i * i) - (A * cos(2 * pi * i)) for i in x]), 3)

+        fitness = (A * self.design_variables) + sum([(xi ** 2) - (A * cos(2 * pi * xi)) for xi in x])
+        return round(fitness, 3)
diff --git a/_modules/pycellga/problems/single_objective/continuous/rosenbrock.html b/_modules/pycellga/problems/single_objective/continuous/rosenbrock.html index de37aaf..6021590 100644 --- a/_modules/pycellga/problems/single_objective/continuous/rosenbrock.html +++ b/_modules/pycellga/problems/single_objective/continuous/rosenbrock.html @@ -328,6 +328,7 @@

Source code for pycellga.problems.single_objective.continuous.rosenbrock

 from problems.abstract_problem import AbstractProblem
 from mpmath import power as pw
+
 

 [docs]
 class Rosenbrock(AbstractProblem):
@@ -339,12 +340,19 @@ 
Source code for pycellga.problems.single_objective.continuous.rosenbrock
    Attributes
     ----------
-    None
+    design_variables : int
+        Number of variables for the problem.
+    bounds : list of tuple
+        The bounds for each variable, typically [(-5, 10), (-5, 10), ...].
+    objectives : int
+        Number of objectives, set to 1 for single-objective optimization.
 
     Methods
     -------
+    evaluate(x, out, *args, **kwargs)
+        Evaluates the Rosenbrock function value for a given list of variables.
     f(x: list) -> float
-        Calculates the Rosenbrock function value for a given list of variables.
+        Alias for evaluate to maintain compatibility with the rest of the codebase.
 
     Notes
     -----
@@ -352,11 +360,36 @@ 
Source code for pycellga.problems.single_objective.continuous.rosenbrock
    Global minimum at f(1,...,1) = 0
     """
 
+

+[docs]
+    def __init__(self, design_variables=2):
+        self.design_variables = design_variables
+        bounds = [(-5, 10) for _ in range(design_variables)]
+        super().__init__(design_variables=[f"x{i+1}" for i in range(design_variables)], bounds=bounds, objectives=["minimize"])

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Calculate the Rosenbrock function value for a given list of variables.
+
+        Parameters
+        ----------
+        x : list
+            A list of float variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        fitness = sum([(100 * pw((x[i + 1] - pw(x[i], 2)), 2)) + pw((1 - x[i]), 2) for i in range(len(x) - 1)])
+        out["F"] = round(fitness, 3)

+
+
 

 [docs]
     def f(self, x: list) -> float:
         """
-        Calculate the Rosenbrock function value for a given list of variables.
+        Alias for the evaluate method to maintain compatibility with the rest of the codebase.
 
         Parameters
         ----------
@@ -368,7 +401,9 @@ 
Source code for pycellga.problems.single_objective.continuous.rosenbrock
        float
             The Rosenbrock function value.
         """
-        return round(sum([(100 * (pw((x[i + 1] - pw(x[i], 2)), 2))) + pw((1 - x[i]), 2) for i in range(len(x) - 1)]), 3)

+        result = {}
+        self.evaluate(x, result)
+        return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/rothellipsoid.html b/_modules/pycellga/problems/single_objective/continuous/rothellipsoid.html index 97656b7..cd6c451 100644 --- a/_modules/pycellga/problems/single_objective/continuous/rothellipsoid.html +++ b/_modules/pycellga/problems/single_objective/continuous/rothellipsoid.html @@ -335,30 +335,62 @@

Source code for pycellga.problems.single_objective.continuous.rothellipsoid< """ Rotated Hyper-Ellipsoid function implementation for optimization problems. - The Rotated Hyper-Ellipsoid function is widely used for testing optimization algorithms. + This function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-100, 100], for all i = 1, 2, ..., n. Attributes ---------- - None + design_variables : int + Number of variables (dimensions) for the problem. + bounds : list of tuple + The bounds for each variable, typically [(-100, 100), (-100, 100), ...]. + objectives : int + Number of objectives, set to 1 for single-objective optimization. Methods ------- f(x: list) -> float - Calculates the Rotated Hyper-Ellipsoid function value for a given list of variables. - - Notes - ----- - -100 ≤ xi ≤ 100 for i = 1,…,n - Global minimum at f(0,....,0) = 0 + Alias for evaluate, calculates the Rotated Hyper-Ellipsoid function value for a given list of variables. + evaluate(x, out, *args, **kwargs) + Pymoo-compatible function for calculating the fitness values and storing them in the `out` dictionary. """ +
+[docs] + def __init__(self, design_variables=3): + # Initialize the parameters as required by AbstractProblem + super().__init__( + design_variables=[f"x{i+1}" for i in range(design_variables)], + bounds=[(-100, 100)] * design_variables, + objectives=["minimize"] + )
+ + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): + """ + Calculate the Rotated Hyper-Ellipsoid function value for pymoo compatibility. + + Parameters + ---------- + x : numpy.ndarray + Array of input variables. + out : dict + Dictionary to store the output fitness values. + """ + fitness = 0.0 + for i in range(len(x)): + fitness += (i + 1) * pw(x[i], 2) + out["F"] = round(fitness, 3)
+ +
[docs] - def f(self, x: list) -> float: + def f(self, x): """ - Calculate the Rotated Hyper-Ellipsoid function value for a given list of variables. - + Alias for the evaluate method to maintain compatibility with the rest of the codebase. + Parameters ---------- x : list @@ -369,13 +401,9 @@

Source code for pycellga.problems.single_objective.continuous.rothellipsoid< float The Rotated Hyper-Ellipsoid function value. """ - fitness = 0.0 - n = len(x) - - for i in range(n): - fitness += (i + 2) * pw(x[i], 2) - - return round(fitness, 3)

+ result = {} + self.evaluate(x, result) + return result["F"] diff --git a/_modules/pycellga/problems/single_objective/continuous/schaffer.html b/_modules/pycellga/problems/single_objective/continuous/schaffer.html index 5c59828..9003f1a 100644 --- a/_modules/pycellga/problems/single_objective/continuous/schaffer.html +++ b/_modules/pycellga/problems/single_objective/continuous/schaffer.html @@ -330,60 +330,75 @@

Source code for pycellga.problems.single_objective.continuous.schaffer

< from mpmath import power as pw from problems.abstract_problem import AbstractProblem -
[docs] class Schaffer(AbstractProblem): """ - Schaffer's Function. + Schaffer's Function for optimization problems. - This class implements the Schaffer's function, which is a common benchmark problem for optimization algorithms. + This class implements the Schaffer's function, a common benchmark problem for optimization algorithms. The function is defined over a multidimensional input and is used to test the performance of optimization methods. + Attributes + ---------- + design_variables : int + The number of variables for the problem. + bounds : list of tuple + The bounds for each variable, typically set to [(-100, 100), (-100, 100), ...]. + objectives : int + Number of objectives, set to 1 for single-objective optimization. + Methods ------- - f(X: list) -> float - Calculates the value of the Schaffer's function for a given list of input variables. + evaluate(x, out, *args, **kwargs) + Calculates the Schaffer's function value for compatibility with pymoo. + f(x: list) -> float + Alias for evaluate to maintain compatibility with the rest of the codebase. """ -
-[docs] - def f(self, X: list) -> float: +
+[docs] + def __init__(self, design_variables=2): + super().__init__( + design_variables=[f"x{i+1}" for i in range(design_variables)], + bounds=[(-100, 100) for _ in range(design_variables)], + objectives=["minimize"] + ) + self.design_variables_count = design_variables
+ + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): """ - Evaluate the Schaffer's function at a given point. + Evaluate the Schaffer's function for a given point using pymoo compatibility. Parameters ---------- - X : list - A list of input variables (continuous values). The length of X should be at least 2. - - Returns - ------- - float - The value of the Schaffer's function evaluated at X, rounded to three decimal places. - - Notes - ----- - The Schaffer's function is defined as: - \[ - f(X) = \sum_{i=1}^{n-1} \left[ 0.5 + \frac{(\sin(x_i^2 + x_{i+1}^2)^2 - 0.5)^2}{(1 + 0.001 \cdot (x_i^2 + x_{i+1}^2))^2} \right] - \] - where \( n \) is the number of elements in X. - - Examples - -------- - >>> schaffer = Schaffer() - >>> schaffer.f([1.0, 2.0]) - 0.554 + x : numpy.ndarray + Array of input variables. + out : dict + Dictionary to store the output fitness value. """ fitness = 0.0 - for i in range(len(X) - 1): - xi = X[i] - xi1 = X[i + 1] + for i in range(len(x) - 1): + xi = x[i] + xi1 = x[i + 1] term1 = np.sin(xi**2 + xi1**2)**2 term2 = 1 + 0.001 * (xi**2 + xi1**2) fitness += 0.5 + (term1 - 0.5)**2 / term2**2 - return round(fitness, 3)
+ out["F"] = round(fitness, 3)
+ + +
+[docs] + def f(self, x): + """ + Alias for the evaluate method to maintain compatibility with the rest of the codebase. + """ + result = {} + self.evaluate(x, result) + return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/schaffer2.html b/_modules/pycellga/problems/single_objective/continuous/schaffer2.html index cf9f46f..fb60fa6 100644 --- a/_modules/pycellga/problems/single_objective/continuous/schaffer2.html +++ b/_modules/pycellga/problems/single_objective/continuous/schaffer2.html @@ -330,7 +330,6 @@

Source code for pycellga.problems.single_objective.continuous.schaffer2

from numpy import power as pw from problems.abstract_problem import AbstractProblem -
[docs] class Schaffer2(AbstractProblem): @@ -342,40 +341,59 @@

Source code for pycellga.problems.single_objective.continuous.schaffer2

Attributes ---------- - None + design_variables : int + The number of design variables. + bounds : list of tuple + The bounds for each variable, typically [(-100, 100), (-100, 100), ...]. + objectives : int + Number of objectives, set to 1 for single-objective optimization. Methods ------- - f(X: list) -> float - Calculates the Modified Schaffer function #2 value for a given list of variables. - - Notes - ----- - -100 ≤ xi ≤ 100 for i = 1,…,n - Global minimum at f(0,...,0) = 0 + evaluate(x, out, *args, **kwargs) + Evaluates the Modified Schaffer function #2 value for a given list of variables. + f(x: list) -> float + Alias for evaluate to maintain compatibility with the rest of the codebase. """ -
-[docs] - def f(self, X: list) -> float: +
+[docs] + def __init__(self, design_variables=2): + super().__init__(design_variables=[f"x{i+1}" for i in range(design_variables)], + bounds=[(-100, 100)] * design_variables, + objectives=["minimize"])
+ + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): """ - Calculate the Modified Schaffer function #2 value for a given list of variables. + Evaluate the Modified Schaffer function #2 value for a given list of variables. Parameters ---------- - X : list - A list of float variables. - - Returns - ------- - float - The Modified Schaffer function #2 value. + x : numpy.ndarray + Array of input variables. + out : dict + Dictionary to store the output fitness values. """ fitness = 0.0 - for i in range(len(X) - 1): - fitness += (0.5 + ((pw(np.sin(pw(X[i], 2) - pw(X[i + 1], 2)), 2) - 0.5) / - pw((1 + 0.001 * (pw(X[i], 2) + pw(X[i + 1], 2))), 2))) - return round(fitness, 3)
+ for i in range(len(x) - 1): + term1 = np.sin(pw(x[i], 2) - pw(x[i + 1], 2)) ** 2 + term2 = (1 + 0.001 * (pw(x[i], 2) + pw(x[i + 1], 2))) ** 2 + fitness += 0.5 + ((term1 - 0.5) / term2) + out["F"] = round(fitness, 3)
+ + +
+[docs] + def f(self, x): + """ + Alias for the evaluate method to maintain compatibility with the rest of the codebase. + """ + result = {} + self.evaluate(x, result) + return result["F"]
diff --git a/_modules/pycellga/problems/single_objective/continuous/schwefel.html b/_modules/pycellga/problems/single_objective/continuous/schwefel.html index c3af8db..4b4aace 100644 --- a/_modules/pycellga/problems/single_objective/continuous/schwefel.html +++ b/_modules/pycellga/problems/single_objective/continuous/schwefel.html @@ -335,29 +335,56 @@

Source code for pycellga.problems.single_objective.continuous.schwefel

< """ Schwefel function implementation for optimization problems. - The Schwefel function is widely used for testing optimization algorithms. - The function is usually evaluated on the hypercube x_i ∈ [-500, 500], for all i = 1, 2, ..., n. + This function is commonly used for testing optimization algorithms and is evaluated on the range + [-500, 500] for each variable. Attributes ---------- - None + design_variables : int + The number of variables in the problem. + bounds : list of tuple + The bounds for each variable, typically [(-500, 500), (-500, 500), ...]. + objectives : int + Number of objectives, set to 1 for single-objective optimization. Methods ------- + evaluate(x, out, *args, **kwargs) + Calculates the Schwefel function value for a given list of variables, compatible with pymoo. f(x: list) -> float - Calculates the Schwefel function value for a given list of variables. - - Notes - ----- - -500 ≤ xi ≤ 500 for i = 1,…,n - Global minimum at f(420.9687,…,420.9687) = 0 + Alias for evaluate to maintain compatibility with the rest of the codebase. """ +
+[docs] + def __init__(self, design_variables=2): + bounds = [(-500, 500) for _ in range(design_variables)] + super().__init__(design_variables=design_variables, bounds=bounds, objectives=1)
+ + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): + """ + Calculate the Schwefel function value for a given list of variables. + + Parameters + ---------- + x : numpy.ndarray + A numpy array of float variables. + out : dict + Dictionary to store the output fitness values. + """ + d = len(x) + fitness = sum(xi * sin(sqrt(abs(xi))) for xi in x) + out["F"] = round((418.9829 * d) - fitness, 3)
+ +
[docs] - def f(self, x: list) -> float: + def f(self, x): """ - Calculate the Schwefel function value for a given list of variables. + Alias for the evaluate method to maintain compatibility with the rest of the codebase. Parameters ---------- @@ -369,13 +396,9 @@

Source code for pycellga.problems.single_objective.continuous.schwefel

< float The Schwefel function value. """ - fitness = 0.0 - d = len(x) - for i in range(d): - fitness += x[i] * sin(sqrt(abs(x[i]))) - fitness = (418.9829 * d) - fitness - - return round(fitness, 3)
+ result = {} + self.evaluate(x, result) + return result["F"] diff --git a/_modules/pycellga/problems/single_objective/continuous/sphere.html b/_modules/pycellga/problems/single_objective/continuous/sphere.html index e6396af..f56a00b 100644 --- a/_modules/pycellga/problems/single_objective/continuous/sphere.html +++ b/_modules/pycellga/problems/single_objective/continuous/sphere.html @@ -334,23 +334,23 @@

Source code for pycellga.problems.single_objective.continuous.sphere

""" Sphere function implementation for optimization problems. - The Sphere function is widely used for testing optimization algorithms. - The function is usually evaluated on the hypercube x_i ∈ [-5.12, 5.12], for all i = 1, 2, ..., n. - - Attributes - ---------- - None + The Sphere function is commonly used for testing optimization algorithms. + It is defined on a hypercube where each variable typically lies within [-5.12, 5.12]. + """ - Methods - ------- - f(x: list) -> float - Calculates the Sphere function value for a given list of variables. +
+[docs] + def __init__(self, design_variables=10): + """ + Initializes the Sphere function with specified design variables and bounds. + + Parameters + ---------- + design_variables : int, optional + Number of variables for the function, by default 10. + """ + super().__init__(design_variables=design_variables, bounds=[(-5.12, 5.12)] * design_variables, objectives=["minimize"])
- Notes - ----- - -5.12 ≤ xi ≤ 5.12 for i = 1,…,n - Global minimum at f(0,...,0) = 0 - """
[docs] @@ -368,7 +368,27 @@

Source code for pycellga.problems.single_objective.continuous.sphere

float The Sphere function value. """ - return round(sum([i * i for i in x]), 3)
+ if len(x) != self.n_var: + raise ValueError(f"Input must have exactly {self.n_var} variables.") + + fitness = sum([xi**2 for xi in x]) + return round(fitness, 3) + + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): + """ + Evaluate function for compatibility with pymoo's optimizer. + + Parameters + ---------- + x : numpy.ndarray + Array of input variables. + out : dict + Dictionary to store the output fitness values. + """ + out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/continuous/styblinskitang.html b/_modules/pycellga/problems/single_objective/continuous/styblinskitang.html index 4099310..de9627b 100644 --- a/_modules/pycellga/problems/single_objective/continuous/styblinskitang.html +++ b/_modules/pycellga/problems/single_objective/continuous/styblinskitang.html @@ -337,21 +337,21 @@

Source code for pycellga.problems.single_objective.continuous.styblinskitang The Styblinski-Tang function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-5, 5], for all i = 1, 2, ..., n. + """ - Attributes - ---------- - None - - Methods - ------- - f(x: list) -> float - Calculates the Styblinski-Tang function value for a given list of variables. +
+[docs] + def __init__(self, design_variables=2): + """ + Initializes the Styblinski-Tang function with specified design variables and bounds. + + Parameters + ---------- + design_variables : int, optional + Number of variables for the function, by default 2. + """ + super().__init__(design_variables=design_variables, bounds=[(-5, 5)] * design_variables, objectives=["minimize"])
- Notes - ----- - -5 ≤ xi ≤ 5 for i = 1,…,n - Global minimum at f(−2.903534, −2.903534) = −78.332 - """
[docs] @@ -369,12 +369,28 @@

Source code for pycellga.problems.single_objective.continuous.styblinskitang float The Styblinski-Tang function value. """ - fitness = 0.0 - for i in range(len(x)): - fitness += (pw(x[i], 4) - 16 * pw(x[i], 2) + 5 * x[i]) + if len(x) != self.n_var: + raise ValueError(f"Input must have exactly {self.n_var} variables.") - fitness = fitness / len(x) + fitness = sum(pw(xi, 4) - 16 * pw(xi, 2) + 5 * xi for xi in x) + fitness /= self.n_var return round(fitness, 3)

+ + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): + """ + Evaluate function for compatibility with pymoo's optimizer. + + Parameters + ---------- + x : numpy.ndarray + Array of input variables. + out : dict + Dictionary to store the output fitness values. + """ + out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/continuous/sumofdifferentpowers.html b/_modules/pycellga/problems/single_objective/continuous/sumofdifferentpowers.html index dc7b40b..b8d26ef 100644 --- a/_modules/pycellga/problems/single_objective/continuous/sumofdifferentpowers.html +++ b/_modules/pycellga/problems/single_objective/continuous/sumofdifferentpowers.html @@ -335,8 +335,38 @@

Source code for pycellga.problems.single_objective.continuous.sumofdifferent class Sumofdifferentpowers(AbstractProblem): """ Sum of Different Powers function implementation for optimization problems. + + The Sum of Different Powers function is often used for testing optimization algorithms. + It is usually evaluated within the bounds x_i ∈ [-1, 1] for each variable. + + Attributes + ---------- + n_var : int + The number of variables for the problem. + bounds : list of tuple + The bounds for each variable, typically [(-1, 1), (-1, 1), ...]. + objectives : int + Number of objectives, set to 1 for single-objective optimization. + + Methods + ------- + f(x: list) -> float + Calculates the Sum of Different Powers function value for a given list of variables. + + Notes + ----- + -1 ≤ xi ≤ 1 for all i. + Global minimum at f(0,...,0) = 0. """ +
+[docs] + def __init__(self, design_variables=2): + bounds = [(-1, 1) for _ in range(design_variables)] + objectives = ["minimize"] + super().__init__(design_variables=design_variables, bounds=bounds, objectives=objectives)
+ +
[docs] def f(self, x: list) -> float: @@ -353,14 +383,27 @@

Source code for pycellga.problems.single_objective.continuous.sumofdifferent float The Sum of Different Powers function value. """ - fitness = 0.0 - - for i in range(len(x)): - a = np.abs(x[i]) - b = i + 1 - fitness += pw(a, b) + if len(x) != self.n_var: + raise ValueError(f"Input must have exactly {self.n_var} variables.") + fitness = sum(pw(np.abs(xi), i + 1) for i, xi in enumerate(x)) return round(fitness, 3)

+ + +
+[docs] + def evaluate(self, x, out, *args, **kwargs): + """ + Evaluate method for compatibility with pymoo's framework. + + Parameters + ---------- + x : numpy.ndarray + Array of input variables. + out : dict + Dictionary to store the output fitness values. + """ + out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/continuous/threehumps.html b/_modules/pycellga/problems/single_objective/continuous/threehumps.html index 0612548..114bdb1 100644 --- a/_modules/pycellga/problems/single_objective/continuous/threehumps.html +++ b/_modules/pycellga/problems/single_objective/continuous/threehumps.html @@ -326,8 +326,8 @@

Source code for pycellga.problems.single_objective.continuous.threehumps

-from problems.abstract_problem import AbstractProblem
-from mpmath import power as pw
+from mpmath import power as pw
+from problems.abstract_problem import AbstractProblem
 
 

 [docs]
@@ -340,19 +340,25 @@ 
Source code for pycellga.problems.single_objective.continuous.threehumps
    Attributes
     ----------
-    None
+    bounds : list of tuple
+        Bounds for each variable, set to [(-5, 5), (-5, 5)] for this function.
+    design_variables : int
+        Number of variables for this problem, which is 2.
+    objectives : int
+        Number of objectives, which is 1 for single-objective optimization.
 
     Methods
     -------
     f(x: list) -> float
         Calculates the Three Hump Camel function value for a given list of variables.
-
-    Notes
-    -----
-    -5 ≤ xi ≤ 5 for i = 1,…,n
-    Global minimum at f(0,..,0) = 0
     """
 
+

+[docs]
+    def __init__(self):
+        super().__init__(design_variables=2, bounds=[(-5, 5), (-5, 5)], objectives=["minimize"])

+
+
 

 [docs]
     def f(self, x: list) -> float:
@@ -369,11 +375,28 @@ 
Source code for pycellga.problems.single_objective.continuous.threehumps
        float
             The Three Hump Camel function value.
         """
-        fitness = 0.0
-        for i in range(len(x) - 1):
-            fitness += (2 * pw(x[i], 2) - 1.05 * pw(x[i], 4) + (pw(x[i], 6) / 6) + 
-                        (x[i] * x[i + 1]) + pw(x[i + 1], 2))
+        if len(x) != self.n_var:
+            raise ValueError(f"Input must have exactly {self.n_var} variables.")
+        
+        x1, x2 = x
+        fitness = 2 * pw(x1, 2) - 1.05 * pw(x1, 4) + (pw(x1, 6) / 6) + x1 * x2 + pw(x2, 2)
         return round(fitness, 6)

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Evaluate method for compatibility with pymoo's framework.
+
+        Parameters
+        ----------
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/continuous/zakharov.html b/_modules/pycellga/problems/single_objective/continuous/zakharov.html index 2346e9c..2d0428b 100644 --- a/_modules/pycellga/problems/single_objective/continuous/zakharov.html +++ b/_modules/pycellga/problems/single_objective/continuous/zakharov.html @@ -328,33 +328,43 @@

Source code for pycellga.problems.single_objective.continuous.zakharov

 from problems.abstract_problem import AbstractProblem
 from mpmath import power as pw
+from typing import List, Any
+
 

 [docs]
 class Zakharov(AbstractProblem):
     """
     Zakharov function implementation for optimization problems.
 
-    The Zakharov function is widely used for testing optimization algorithms.
-    The function is usually evaluated on the hypercube x_i ∈ [-5, 10], for all i = 1, 2, ..., n.
+    The Zakharov function is commonly used to test optimization algorithms.
+    It evaluates inputs over the hypercube x_i ∈ [-5, 10].
 
     Attributes
     ----------
-    None
+    design_variables : int
+        The number of variables for the problem.
+    bounds : list of tuple
+        The bounds for each variable, typically [(-5, 10), (-5, 10), ...].
+    objectives : list
+        Objectives for the problem, set to ["minimize"] for single-objective optimization.
 
     Methods
     -------
     f(x: list) -> float
         Calculates the Zakharov function value for a given list of variables.
-
-    Notes
-    -----
-    -5 ≤ xi ≤ 10 for i = 1,…,n
-    Global minimum at f(0,..,0) = 0
     """
 
+

+[docs]
+    def __init__(self, design_variables=2):
+        bounds = [(-5, 10) for _ in range(design_variables)]
+        objectives = ["minimize"]
+        super().__init__(design_variables=design_variables, bounds=bounds, objectives=objectives)

+
+
 

 [docs]
-    def f(self, x: list) -> float:
+    def f(self, x: List[float]) -> float:
         """
         Calculate the Zakharov function value for a given list of variables.
 
@@ -368,25 +378,27 @@ 
Source code for pycellga.problems.single_objective.continuous.zakharov
<
         float
             The Zakharov function value.
         """
-        fitness1 = 0.0
-        fitness2 = 0.0
-        fitness3 = 0.0
-        fitness = 0.0
-        
-        for i in range(len(x)):
-            fitness1 += pw(x[i], 2)
-
-        for i in range(len(x)):
-            fitness2 += 0.5 * (i + 1) * x[i]
-        fitness2 = pw(fitness2, 2)
+        fitness1 = sum(pw(xi, 2) for xi in x)
+        fitness2 = pw(sum(0.5 * (i + 1) * xi for i, xi in enumerate(x)), 2)
+        fitness3 = pw(sum(0.5 * (i + 1) * xi for i, xi in enumerate(x)), 4)
+        fitness = fitness1 + fitness2 + fitness3
+        return round(fitness, 3)

 
-        for i in range(len(x)):
-            fitness3 += 0.5 * (i + 1) * x[i]
-        fitness3 = pw(fitness3, 4)
 
-        fitness = fitness1 + fitness2 + fitness3
+

+[docs]
+    def evaluate(self, x: List[float], out: dict, *args: Any, **kwargs: Any) -> None:
+        """
+        Evaluate function for compatibility with pymoo's optimizer.
 
-        return round(fitness, 3)

+        Parameters
+        ----------
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/continuous/zettle.html b/_modules/pycellga/problems/single_objective/continuous/zettle.html index 24a03d6..791c333 100644 --- a/_modules/pycellga/problems/single_objective/continuous/zettle.html +++ b/_modules/pycellga/problems/single_objective/continuous/zettle.html @@ -336,11 +336,16 @@

Source code for pycellga.problems.single_objective.continuous.zettle

Zettle function implementation for optimization problems. The Zettle function is widely used for testing optimization algorithms. - The function is usually evaluated on the hypercube x_i ∈ [-5, 5], for all i = 1, 2, ..., n. + It is usually evaluated on the hypercube x_i ∈ [-5, 5] for all i = 1, 2, ..., n. Attributes ---------- - None + design_variables : int + The number of variables for the problem. + bounds : list of tuple + The bounds for each variable, typically [(-5, 5), (-5, 5), ...]. + objectives : int + Number of objectives, set to 1 for single-objective optimization. Methods ------- @@ -350,9 +355,17 @@

Source code for pycellga.problems.single_objective.continuous.zettle

Notes ----- -5 ≤ xi ≤ 5 for i = 1,…,n - Global minimum at f(−0.0299, 0) = −0.003791 + Global minimum at f(-0.0299, 0) = -0.003791 """ +
+[docs] + def __init__(self, design_variables=2): + super().__init__(design_variables=design_variables, + bounds=[(-5, 5) for _ in range(design_variables)], + objectives=["minimize"])
+ +
[docs] def f(self, x: list) -> float: @@ -367,11 +380,15 @@

Source code for pycellga.problems.single_objective.continuous.zettle

Returns ------- float - The Zettle function value. + The Zettle function value, rounded to six decimal places. """ + if len(x) != self.n_var: + raise ValueError(f"Input must have exactly {self.n_var} variables.") + fitness = 0.0 for i in range(len(x) - 1): fitness += pw((pw(x[i], 2) + pw(x[i + 1], 2)) - 2 * x[i], 2) + 0.25 * x[i] + return round(fitness, 6)
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/count_sat.html b/_modules/pycellga/problems/single_objective/discrete/binary/count_sat.html index 7132769..deaf91b 100644 --- a/_modules/pycellga/problems/single_objective/discrete/binary/count_sat.html +++ b/_modules/pycellga/problems/single_objective/discrete/binary/count_sat.html @@ -327,6 +327,7 @@

Source code for pycellga.problems.single_objective.discrete.binary.count_sat

 from problems.abstract_problem import AbstractProblem
+
 

 [docs]
 class CountSat(AbstractProblem):
@@ -337,25 +338,32 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.count_sat
 
     Attributes
     ----------
-    None
+    design_variables : int
+        The number of variables (chromosome length) for the problem.
+    bounds : list of tuple
+        The bounds for each binary variable, typically [(0, 1), (0, 1), ...] for binary inputs.
+    objectives : int
+        Number of objectives, set to 1 for single-objective optimization.
 
     Methods
     -------
     f(x: list) -> float
-        Calculates the CountSat function value for a given list of variables.
-
-    Notes
-    -----
-    Length of chromosomes = 20
-    Maximum Fitness Value = 6860
-    Maximum Fitness Value (normalized) = 1
+        Calculates the CountSat function value for a given list of binary variables.
     """
 
+

+[docs]
+    def __init__(self, design_variables=20):
+        super().__init__(design_variables=design_variables,
+                         bounds=[(0, 1) for _ in range(design_variables)],
+                         objectives=["maximize"])

+
+
 

 [docs]
     def f(self, x: list) -> float:
         """
-        Calculate the CountSat function value for a given list of variables.
+        Calculate the CountSat function value for a given list of binary variables.
 
         Parameters
         ----------
@@ -367,17 +375,13 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.count_sat
         float
             The normalized CountSat function value.
         """
-        variables = len(x)  # --> n is the length of x
-        total_ones = 0
-        fitness = 0
-        fitness_normalized = 0.0
+        if len(x) != self.n_var:
+            raise ValueError(f"Input must have exactly {self.n_var} variables.")
         
-        # Count the number of ones in the list
-        for i in x:
-            if i == 1:
-                total_ones += 1
+        total_ones = sum(1 for i in x if i == 1)
+        variables = len(x)
 
-        # Calculate the fitness value based on the CountSat formula
+        # Calculate the fitness based on the CountSat formula
         fitness = (total_ones + 
                    (variables * (variables - 1) * (variables - 2)) - 
                    ((variables - 2) * total_ones * (total_ones - 1)) + 
@@ -386,6 +390,22 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.count_sat
         # Normalize the fitness value
         fitness_normalized = fitness / 6860
         return round(fitness_normalized, 3)

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Evaluate function for compatibility with pymoo's optimizer.
+
+        Parameters
+        ----------
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/ecc.html b/_modules/pycellga/problems/single_objective/discrete/binary/ecc.html index 08cdaa5..1059e84 100644 --- a/_modules/pycellga/problems/single_objective/discrete/binary/ecc.html +++ b/_modules/pycellga/problems/single_objective/discrete/binary/ecc.html @@ -339,18 +339,20 @@

Source code for pycellga.problems.single_objective.discrete.binary.ecc

< Attributes ---------- - None + design_variables : int + Number of binary variables, typically 144. + bounds : list of tuple + Bounds for each variable, typically [(0, 1)] * 144 for binary inputs. + objectives : int + Number of objectives, set to 1 for single-objective optimization. + """ - Methods - ------- - f(x: list) -> float - Calculates the ECC function value for a given list of variables. +
+[docs] + def __init__(self, design_variables=144): + bounds = [(0, 1) for _ in range(design_variables)] # Binary bounds for each variable + super().__init__(design_variables=design_variables, bounds=bounds, objectives=[1])
- Notes - ----- - Length of chromosomes = 144 - Maximum Fitness Value = 0.0674 - """
[docs] @@ -366,31 +368,23 @@

Source code for pycellga.problems.single_objective.discrete.binary.ecc

< Returns ------- float - The ECC function value. + The ECC function value, rounded to four decimal places. """ individual_length = 12 # Length of individual code segments half_code = 12 # Number of code segments to compare partial_fitness = 0.0 # Accumulated partial fitness value - fitness = 0.0 # Final fitness value for i in range(half_code): - partial_fitness += 1.0 / (individual_length * individual_length) - for j in range(half_code): - if j != i: - hamming = 1 # Initialize Hamming distance - for k in range(individual_length): - # Compute Hamming distance between segments - if x[(i * individual_length + k) ^ x[(j * individual_length + k)]]: - hamming += 1 + for j in range(i + 1, half_code): # Avoid double-counting pairs + hamming = sum(x[i * individual_length + k] != x[j * individual_length + k] for k in range(individual_length)) - # Update partial fitness with contributions from current pair of segments + if 0 < hamming < individual_length: partial_fitness += (1.0 / (hamming * hamming) + 1.0 / ((individual_length - hamming) * (individual_length - hamming))) # Calculate final fitness value - fitness = 1.0 / (2 * partial_fitness) - + fitness = 1.0 / (2 * partial_fitness) if partial_fitness != 0 else 0.0 return round(fitness, 4)
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/fms.html b/_modules/pycellga/problems/single_objective/discrete/binary/fms.html index fe3569f..d32f24e 100644 --- a/_modules/pycellga/problems/single_objective/discrete/binary/fms.html +++ b/_modules/pycellga/problems/single_objective/discrete/binary/fms.html @@ -328,6 +328,7 @@

Source code for pycellga.problems.single_objective.discrete.binary.fms

 from problems.abstract_problem import AbstractProblem
 from numpy import pi, sin, random
+
 

 [docs]
 class Fms(AbstractProblem):
@@ -338,7 +339,12 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.fms
<
 
     Attributes
     ----------
-    None
+    design_variables : int
+        The number of variables for the problem.
+    bounds : list of tuple
+        The bounds for each variable.
+    objectives : int
+        Number of objectives, set to 1 for single-objective optimization.
 
     Methods
     -------
@@ -352,6 +358,12 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.fms
<
     Maximum Fitness Value Error = 10^-2
     """
 
+

+[docs]
+    def __init__(self, design_variables=192, bounds=[(0, 1)] * 192, objectives=1):
+        super().__init__(design_variables, bounds, objectives)

+
+
 

 [docs]
     def f(self, x: list) -> float:
@@ -371,56 +383,19 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.fms
<
         theta = (2.0 * pi) / 100.0
         random.seed(100)
 
-        # initialize parameters
-        a1_int = 0
-        w1_int = 0
-        a2_int = 0
-        w2_int = 0
-        a3_int = 0
-        w3_int = 0
+        # Initialize integer values for parameters
+        a1_int, w1_int, a2_int, w2_int, a3_int, w3_int = 0, 0, 0, 0, 0, 0
 
-        # calculate parameter a1_int
+        # Convert segments of x to integer parameters
         for i in range(32):
-            if x[i] == 1:
-                a1_int += 1
-            a1_int <<= 1
-        a1_int >>= 1
-
-        # calculate parameter w1_int
-        for i in range(32, 64):
-            if x[i] == 1:
-                w1_int += 1
-            w1_int <<= 1
-        w1_int >>= 1
-
-        # calculate parameter a2_int
-        for i in range(64, 96):
-            if x[i] == 1:
-                a2_int += 1
-            a2_int <<= 1
-        a2_int >>= 1
-
-        # calculate parameter w2_int
-        for i in range(96, 128):
-            if x[i] == 1:
-                w2_int += 1
-            w2_int <<= 1
-        w2_int >>= 1
-
-        # calculate parameter a3_int
-        for i in range(128, 160):
-            if x[i] == 1:
-                a3_int += 1
-            a3_int <<= 1
-        a3_int >>= 1
-
-        # calculate parameter w3_int
-        for i in range(160, 192):
-            if x[i] == 1:
-                w3_int += 1
-            w3_int <<= 1
-        w3_int >>= 1
+            a1_int = (a1_int << 1) | x[i]
+            w1_int = (w1_int << 1) | x[i + 32]
+            a2_int = (a2_int << 1) | x[i + 64]
+            w2_int = (w2_int << 1) | x[i + 96]
+            a3_int = (a3_int << 1) | x[i + 128]
+            w3_int = (w3_int << 1) | x[i + 160]
 
+        # Map integer values to continuous values for each parameter
         a1 = -6.4 + (12.75 * (a1_int / 4294967295.0))
         w1 = -6.4 + (12.75 * (w1_int / 4294967295.0))
         a2 = -6.4 + (12.75 * (a2_int / 4294967295.0))
@@ -428,23 +403,33 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.fms
<
         a3 = -6.4 + (12.75 * (a3_int / 4294967295.0))
         w3 = -6.4 + (12.75 * (w3_int / 4294967295.0))
 
-        target = [random.randint(2) for g in range(101)]
-        for i in range(101):
-            target[i] = 1.0 * sin((5.0 * theta * i) - (1.5 * sin((4.8 * theta * i) + (2.0 * sin(4.9 * theta * i)))))
-        
-        y = [random.randint(2) for g in range(101)]
-        for j in range(101):
-            y[j] = a1 * sin((w1 * theta * j) - (a2 * sin((w2 * theta * j) + (a3 * sin(w3 * theta * j)))))
-
-        distance = 0.0
-        partialfitnesss = 0.0
-        fitness = 0.0
-        for k in range(101):
-            distance = target[k] - y[k]
-            partialfitnesss += distance * distance
-        
-        fitness = partialfitnesss
+        # Generate target signal based on predefined parameters
+        target = [sin((5.0 * theta * i) - (1.5 * sin((4.8 * theta * i) + (2.0 * sin(4.9 * theta * i)))))
+                  for i in range(101)]
+
+        # Generate signal y based on the parameters derived from x
+        y = [a1 * sin((w1 * theta * j) - (a2 * sin((w2 * theta * j) + (a3 * sin(w3 * theta * j)))))
+             for j in range(101)]
+
+        # Calculate fitness as the mean squared error between target and y
+        fitness = sum((target[k] - y[k]) ** 2 for k in range(101))
         return round(fitness, 3)

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Evaluate function for compatibility with pymoo's optimizer.
+
+        Parameters
+        ----------
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/maxcut100.html b/_modules/pycellga/problems/single_objective/discrete/binary/maxcut100.html index 46b1c51..9b4fc24 100644 --- a/_modules/pycellga/problems/single_objective/discrete/binary/maxcut100.html +++ b/_modules/pycellga/problems/single_objective/discrete/binary/maxcut100.html @@ -326,46 +326,31 @@

Source code for pycellga.problems.single_objective.discrete.binary.maxcut100

-from problems.abstract_problem import AbstractProblem
+
+from problems.abstract_problem import AbstractProblem
 
 

 [docs]
 class Maxcut100(AbstractProblem):
     """
-    A class used to represent the Maximum Cut (MAXCUT) function for 100 nodes.
+    A class to represent the Maximum Cut (MAXCUT) problem for 100 nodes.
     
     Attributes
     ----------
-    None
+    problema : list of list of float
+        A matrix representing the weights between nodes in the MAXCUT problem.
 
     Methods
     -------
     f(x: list) -> float
-        Calculates the fitness value of a given chromosome.
-
-    Notes
-    -----
-    Length of chromosomes = 100
-    Maximum Fitness Value = 1077.0
-    """
-

-[docs]
-    def f(self, x: list) -> float:
-        """
         Calculates the fitness value of a given chromosome for the Maxcut problem.
-
-        Parameters
-        ----------
-        x : list
-            A list representing a chromosome.
-
-        Returns
-        -------
-        float
-            The fitness value of the chromosome.
-        """
-
-        problema = [
+    """
+    
+

+[docs]
+    def __init__(self):
+        
+        self.problema = [
             [0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
                 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 10.000000, 0.000000, 10.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000],
             [0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 10.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
@@ -566,18 +551,34 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.maxcut100
                 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 10.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000],
             [0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
                 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 10.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 10.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000],
-        ]
+        ]

 
-        cols = 100
-        fitness = 0.0
 
-        for i in range(cols-1):
-            j = i
-            for j in range(cols):
-                if (x[i] ^ x[j]):
-                    fitness = fitness + problema[i][j]
+

+[docs]
+    def f(self, x: list) -> float:
+        """
+        Calculates the fitness value of a given chromosome for the Maxcut problem.
+
+        Parameters
+        ----------
+        x : list
+            A list representing a chromosome.
+
+        Returns
+        -------
+        float
+            The fitness value of the chromosome.
+        """
+        fitness = 0.0
+        n = len(self.problema)
+        
+        for i in range(n):
+            for j in range(i + 1, n):
+                if x[i] != x[j]:  # Nodes are in different subsets
+                    fitness += self.problema[i][j]
 
-        return round(fitness, 6)

+        return fitness
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/maxcut20_01.html b/_modules/pycellga/problems/single_objective/discrete/binary/maxcut20_01.html index 59b4b4c..b7b8e0a 100644 --- a/_modules/pycellga/problems/single_objective/discrete/binary/maxcut20_01.html +++ b/_modules/pycellga/problems/single_objective/discrete/binary/maxcut20_01.html @@ -327,46 +327,36 @@

Source code for pycellga.problems.single_objective.discrete.binary.maxcut20_01

 from problems.abstract_problem import AbstractProblem
+
 

 [docs]
 class Maxcut20_01(AbstractProblem):
     """
     Maximum Cut (MAXCUT) function implementation for optimization problems.
 
-    The MAXCUT function is used for testing optimization algorithms, particularly those involving maximum cut problems.
+    The MAXCUT function evaluates the fitness of a binary partition of nodes based on edge weights.
+    It is used to test optimization algorithms, particularly for maximum cut problems.
 
     Attributes
     ----------
-    None
+    problema : list of list of float
+        Adjacency matrix representing edge weights between nodes.
 
     Methods
     -------
     f(x: list) -> float
-        Calculates the MAXCUT function value for a given list of variables.
-
-    Notes
-    -----
-    Length of chromosomes = 20
-    Maximum Fitness Value = 10.119812
+        Calculates the MAXCUT function value for a given list of binary variables.
     """
 
-

-[docs]
-    def f(self, x: list) -> float:
-        """
-        Calculate the MAXCUT function value for a given list of variables.
-
-        Parameters
-        ----------
-        x : list
-            A list of binary variables.
+

+[docs]
+    def __init__(self, design_variables=20, bounds=None, objectives=1):
+        if bounds is None:
+            bounds = [(0, 1)] * design_variables  # Binary bounds for each variable
+        super().__init__(design_variables=design_variables, bounds=bounds, objectives=objectives)
 
-        Returns
-        -------
-        float
-            The MAXCUT function value.
-        """
-        problema = [
+        # Define adjacency matrix (20x20 matrix of edge weights)
+        self.problema = [
             [0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.359902,
                 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.313702, 0.000000, 0.000000, 0.000000],
             [0.000000, 0.000000, 0.000000, 0.000000, 0.848267, 0.000000, 0.000000, 0.000000, 0.287508, 0.000000,
@@ -407,20 +397,55 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.maxcut20_
                 0.000000, 0.000000, 0.000000, 0.000000, 0.936165, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000],
             [0.000000, 0.000000, 0.916311, 0.000000, 0.000000, 0.032054, 0.000000, 0.000000, 0.000000, 0.969750,
                 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000]
-        ]
+        ]

+
+
+

+[docs]
+    def f(self, x: list) -> float:
+        """
+        Calculate the MAXCUT function value for a given list of binary variables.
+
+        Parameters
+        ----------
+        x : list
+            A list of binary variables representing node partitions.
 
-        cols = 20
+        Returns
+        -------
+        float
+            The MAXCUT function value representing the total weight of edges cut by the partition.
+        """
         fitness = 0.0
+        cols = len(self.problema)
 
-        for i in range(cols-1):
-            j = i
-            for j in range(cols):
-                if x[i] ^ x[j]:
-                    fitness += problema[i][j]
+        for i in range(cols - 1):
+            for j in range(i + 1, cols):
+                if x[i] != x[j]:  # Nodes are in different partitions
+                    fitness += self.problema[i][j]
 
         return round(fitness, 6)

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Evaluate function for compatibility with pymoo's optimizer.
+
+        Parameters
+        ----------
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        out["F"] = self.f(x)

 

 
+
+
+
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/maxcut20_09.html b/_modules/pycellga/problems/single_objective/discrete/binary/maxcut20_09.html index f413a39..33b64c1 100644 --- a/_modules/pycellga/problems/single_objective/discrete/binary/maxcut20_09.html +++ b/_modules/pycellga/problems/single_objective/discrete/binary/maxcut20_09.html @@ -327,98 +327,120 @@

Source code for pycellga.problems.single_objective.discrete.binary.maxcut20_09

 from problems.abstract_problem import AbstractProblem
+
 

 [docs]
 class Maxcut20_09(AbstractProblem):
     """
-    Maximum Cut (MAXCUT) function implementation for optimization problems.
+    Maximum Cut (MAXCUT) function for optimization on a 20-node graph.
 
-    The MAXCUT function is used for testing optimization algorithms, particularly those involving maximum cut problems.
+    This class is used to evaluate the cut value by summing weights of edges
+    between nodes in different partitions defined by binary variables.
 
     Attributes
     ----------
-    None
+    problema : list of list of float
+        Adjacency matrix representing edge weights between nodes.
 
     Methods
     -------
     f(x: list) -> float
-        Calculates the MAXCUT function value for a given list of variables.
-
-    Notes
-    -----
-    Length of chromosomes = 20
-    Maximum Fitness Value = 56.740064
+        Calculates the MAXCUT function value for a given list of binary variables.
     """
 
-

-[docs]
-    def f(self, x: list) -> float:
-        """
-        Calculate the MAXCUT function value for a given list of variables.
-
-        Parameters
-        ----------
-        x : list
-            A list of binary variables.
-
-        Returns
-        -------
-        float
-            The MAXCUT function value.
-        """
-        problema = [
+

+[docs]
+    def __init__(self, design_variables=20, bounds=None, objectives=1):
+        if bounds is None:
+            bounds = [(0, 1) for _ in range(design_variables)]
+        super().__init__(design_variables=design_variables, bounds=bounds, objectives=objectives)
+        
+        # Define adjacency matrix (20x20 matrix of edge weights)
+        self.problema = [
             [0.000000, 0.130622, 0.694577, 0.922028, 0.335786, 0.359902, 0.279580, 0.880418, 0.201529, 0.313702,
-                0.322765, 0.399944, 0.000000, 0.848267, 0.933051, 0.085267, 0.957646, 0.331033, 0.389269, 0.193177],
+             0.322765, 0.399944, 0.000000, 0.848267, 0.933051, 0.085267, 0.957646, 0.331033, 0.389269, 0.193177],
             [0.130622, 0.000000, 0.946416, 0.388165, 0.000000, 0.232571, 0.605770, 0.065642, 0.114155, 0.737786,
-                0.033571, 0.843579, 0.465199, 0.043667, 0.000000, 0.382358, 0.661252, 0.931556, 0.206577, 0.262331],
+             0.033571, 0.843579, 0.465199, 0.043667, 0.000000, 0.382358, 0.661252, 0.931556, 0.206577, 0.262331],
             [0.694577, 0.946416, 0.000000, 0.989211, 0.000000, 0.152213, 0.000000, 0.084579, 0.610150, 0.131790,
-                0.950083, 0.426541, 0.721013, 0.428389, 0.308932, 0.861261, 0.479196, 0.863363, 0.000000, 0.110013],
+             0.950083, 0.426541, 0.721013, 0.428389, 0.308932, 0.861261, 0.479196, 0.863363, 0.000000, 0.110013],
             [0.922028, 0.388165, 0.989211, 0.000000, 0.785464, 0.227321, 0.469172, 0.032054, 0.574073, 0.736906,
-                0.764415, 0.000000, 0.495863, 0.602718, 0.684042, 0.492622, 0.000000, 0.918634, 0.974679, 0.134843],
+             0.764415, 0.000000, 0.495863, 0.602718, 0.684042, 0.492622, 0.000000, 0.918634, 0.974679, 0.134843],
             [0.335786, 0.000000, 0.000000, 0.785464, 0.000000, 0.478171, 0.684823, 0.594988, 0.000000, 0.043655,
-                0.266736, 0.265187, 0.167750, 0.539353, 0.120596, 0.483133, 0.928091, 0.571874, 0.118362, 0.808725],
+             0.266736, 0.265187, 0.167750, 0.539353, 0.120596, 0.483133, 0.928091, 0.571874, 0.118362, 0.808725],
             [0.359902, 0.232571, 0.152213, 0.227321, 0.478171, 0.000000, 0.969750, 0.948758, 0.527900, 0.652776,
-                0.990039, 0.945809, 0.831436, 0.355298, 0.049061, 0.103966, 0.897422, 0.732376, 0.491590, 0.526179],
+             0.990039, 0.945809, 0.831436, 0.355298, 0.049061, 0.103966, 0.897422, 0.732376, 0.491590, 0.526179],
             [0.279580, 0.605770, 0.000000, 0.469172, 0.684823, 0.969750, 0.000000, 0.652418, 0.123045, 0.368941,
-                0.000000, 0.053590, 0.035474, 0.000000, 0.360846, 0.665888, 0.757456, 0.000000, 0.912162, 0.974535],
+             0.000000, 0.053590, 0.035474, 0.000000, 0.360846, 0.665888, 0.757456, 0.000000, 0.912162, 0.974535],
             [0.880418, 0.065642, 0.084579, 0.032054, 0.594988, 0.948758, 0.652418, 0.000000, 0.656499, 0.879623,
-                0.656778, 0.572563, 0.107108, 0.550337, 0.230315, 0.568378, 0.000000, 0.915765, 0.659182, 0.688311],
+             0.656778, 0.572563, 0.107108, 0.550337, 0.230315, 0.568378, 0.000000, 0.915765, 0.659182, 0.688311],
             [0.201529, 0.114155, 0.610150, 0.574073, 0.000000, 0.527900, 0.123045, 0.656499, 0.000000, 0.995883,
-                0.172727, 0.442540, 0.974869, 0.000000, 0.997630, 0.035737, 0.835247, 0.139724, 0.859992, 0.000000],
+             0.172727, 0.442540, 0.974869, 0.000000, 0.997630, 0.035737, 0.835247, 0.139724, 0.859992, 0.000000],
             [0.313702, 0.737786, 0.131790, 0.736906, 0.043655, 0.652776, 0.368941, 0.879623, 0.995883, 0.000000,
-                0.120131, 0.483339, 0.969497, 0.300482, 0.879444, 0.000000, 0.836946, 0.084211, 0.723167, 0.195939],
+             0.120131, 0.483339, 0.969497, 0.300482, 0.879444, 0.000000, 0.836946, 0.084211, 0.723167, 0.195939],
             [0.322765, 0.033571, 0.950083, 0.764415, 0.266736, 0.990039, 0.000000, 0.656778, 0.172727, 0.120131,
-                0.000000, 0.950398, 0.236138, 0.268245, 0.701255, 0.894728, 0.303465, 0.989424, 0.228973, 0.978178],
+             0.000000, 0.950398, 0.236138, 0.268245, 0.701255, 0.894728, 0.303465, 0.989424, 0.228973, 0.978178],
             [0.399944, 0.843579, 0.426541, 0.000000, 0.265187, 0.945809, 0.053590, 0.572563, 0.442540, 0.483339,
-                0.950398, 0.000000, 0.060377, 0.854370, 0.488094, 0.581746, 0.935845, 0.723815, 0.225213, 0.424806],
+             0.950398, 0.000000, 0.060377, 0.854370, 0.488094, 0.581746, 0.935845, 0.723815, 0.225213, 0.424806],
             [0.000000, 0.465199, 0.721013, 0.495863, 0.167750, 0.831436, 0.035474, 0.107108, 0.974869, 0.969497,
-                0.236138, 0.060377, 0.000000, 0.404249, 0.867185, 0.865152, 0.330739, 0.876005, 0.978220, 0.651577],
+             0.236138, 0.060377, 0.000000, 0.404249, 0.867185, 0.865152, 0.330739, 0.876005, 0.978220, 0.651577],
             [0.848267, 0.043667, 0.428389, 0.602718, 0.539353, 0.355298, 0.000000, 0.550337, 0.000000, 0.300482,
-                0.268245, 0.854370, 0.404249, 0.000000, 0.492553, 0.088188, 0.690603, 0.287630, 0.000000, 0.690291],
+             0.268245, 0.854370, 0.404249, 0.000000, 0.492553, 0.088188, 0.690603, 0.287630, 0.000000, 0.690291],
             [0.933051, 0.000000, 0.308932, 0.684042, 0.120596, 0.049061, 0.360846, 0.230315, 0.997630, 0.879444,
-                0.701255, 0.488094, 0.867185, 0.492553, 0.000000, 0.000000, 0.593581, 0.076547, 0.297751, 0.159191],
+             0.701255, 0.488094, 0.867185, 0.492553, 0.000000, 0.000000, 0.593581, 0.076547, 0.297751, 0.159191],
             [0.085267, 0.382358, 0.861261, 0.492622, 0.483133, 0.103966, 0.665888, 0.568378, 0.035737, 0.000000,
-                0.894728, 0.581746, 0.865152, 0.088188, 0.000000, 0.000000, 0.747596, 0.562290, 0.000000, 0.955731],
+             0.894728, 0.581746, 0.865152, 0.088188, 0.000000, 0.000000, 0.747596, 0.562290, 0.000000, 0.955731],
             [0.957646, 0.661252, 0.479196, 0.000000, 0.928091, 0.897422, 0.757456, 0.000000, 0.835247, 0.836946,
-                0.303465, 0.935845, 0.330739, 0.690603, 0.593581, 0.747596, 0.000000, 0.244949, 0.994884, 0.067050],
+             0.303465, 0.935845, 0.330739, 0.690603, 0.593581, 0.747596, 0.000000, 0.244949, 0.994884, 0.067050],
             [0.331033, 0.931556, 0.863363, 0.918634, 0.571874, 0.732376, 0.000000, 0.915765, 0.139724, 0.084211,
-                0.989424, 0.723815, 0.876005, 0.287630, 0.076547, 0.562290, 0.244949, 0.000000, 0.621331, 0.752926],
+             0.989424, 0.723815, 0.876005, 0.287630, 0.076547, 0.562290, 0.244949, 0.000000, 0.621331, 0.752926],
             [0.389269, 0.206577, 0.000000, 0.974679, 0.118362, 0.491590, 0.912162, 0.659182, 0.859992, 0.723167,
-                0.228973, 0.225213, 0.978220, 0.000000, 0.297751, 0.000000, 0.994884, 0.621331, 0.000000, 0.224879],
+             0.228973, 0.225213, 0.978220, 0.000000, 0.297751, 0.000000, 0.994884, 0.621331, 0.000000, 0.224879],
             [0.193177, 0.262331, 0.110013, 0.134843, 0.808725, 0.526179, 0.974535, 0.688311, 0.000000, 0.195939,
-                0.978178, 0.424806, 0.651577, 0.690291, 0.159191, 0.955731, 0.067050, 0.752926, 0.224879, 0.000000]
-        ]
+             0.978178, 0.424806, 0.651577, 0.690291, 0.159191, 0.955731, 0.067050, 0.752926, 0.224879, 0.000000]
+        ]

+
+
+

+[docs]
+    def f(self, x: list) -> float:
+        """
+        Calculate the MAXCUT function value for a given list of binary variables.
+        
+        Parameters
+        ----------
+        x : list
+            A list of binary variables representing node partitions.
 
-        cols = 20
+        Returns
+        -------
+        float
+            The MAXCUT function value representing the total weight of edges cut by the partition.
+        """
         fitness = 0.0
+        cols = len(self.problema)
 
-        for i in range(cols-1):
-            j = i
-            for j in range(cols):
-                if x[i] ^ x[j]:
-                    fitness += problema[i][j]
+        for i in range(cols - 1):
+            for j in range(i + 1, cols):
+                if x[i] != x[j]:  # Nodes are in different partitions
+                    fitness += self.problema[i][j]
 
         return round(fitness, 6)

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Evaluate function for compatibility with pymoo's optimizer.
+        
+        Parameters
+        ----------
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        out["F"] = self.f(x.tolist())
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/mmdp.html b/_modules/pycellga/problems/single_objective/discrete/binary/mmdp.html index dcd4574..f2521e0 100644 --- a/_modules/pycellga/problems/single_objective/discrete/binary/mmdp.html +++ b/_modules/pycellga/problems/single_objective/discrete/binary/mmdp.html @@ -327,6 +327,7 @@

Source code for pycellga.problems.single_objective.discrete.binary.mmdp

 from problems.abstract_problem import AbstractProblem
+from typing import List, Tuple
 
 

 [docs]
@@ -340,7 +341,14 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.mmdp

 
     Attributes
     ----------
-    None
+    design_variables : List[str]
+        Names of the design variables (in this case, binary chromosome genes).
+    bounds : List[Tuple[float, float]]
+        Bounds for each design variable (0 or 1).
+    objectives : List[str]
+        Objectives for optimization, e.g., "maximize" in this case.
+    constraints : List[str]
+        Any constraints for the optimization problem.
 
     Methods
     -------
@@ -353,9 +361,24 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.mmdp

     # Maximum Fitness Value = 40
     """
 
+

+[docs]
+    def __init__(self):
+        """
+        Initializes the MMDP problem with predefined design variables, bounds, 
+        objectives, and constraints.
+        """
+        design_variables = ["gene" + str(i) for i in range(240)]
+        bounds = [(0, 1) for _ in range(240)]
+        objectives = ["maximize"]
+        constraints = []
+
+        super().__init__(design_variables, bounds, objectives, constraints)

+
+
 

 [docs]
-    def f(self, x: list) -> float:
+    def f(self, x: List[int]) -> float:
         """
         Evaluates the fitness of a given chromosome for the MMDP.
 
@@ -364,7 +387,7 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.mmdp

 
         Parameters
         ----------
-        x : list
+        x : List[int]
             A list representing the chromosome, where each element is a binary 
             value (0 or 1).
 
@@ -374,18 +397,12 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.mmdp

             The normalized fitness value of the chromosome, rounded to three 
             decimal places.
         """
-
         subproblems_length = 6
         subproblems_number = 40
-        total_ones = 0
-        partial_fitness = 0.0
         fitness = 0.0
 
         for i in range(subproblems_number):
-            total_ones = 0
-            for j in range(subproblems_length):
-                if x[i * subproblems_length + j] == 1:
-                    total_ones += 1
+            total_ones = sum(x[i * subproblems_length + j] for j in range(subproblems_length))
 
             if total_ones == 0 or total_ones == 6:
                 partial_fitness = 1.0
@@ -398,8 +415,7 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.mmdp

 
             fitness += partial_fitness
 
-        fitness_normalized = fitness / 40
-
+        fitness_normalized = fitness / subproblems_number
         return round(fitness_normalized, 3)

 

 
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/one_max.html b/_modules/pycellga/problems/single_objective/discrete/binary/one_max.html
index e9048b1..698d8a7 100644
--- a/_modules/pycellga/problems/single_objective/discrete/binary/one_max.html
+++ b/_modules/pycellga/problems/single_objective/discrete/binary/one_max.html
@@ -327,6 +327,7 @@
              
   
Source code for pycellga.problems.single_objective.discrete.binary.one_max
 from problems.abstract_problem import AbstractProblem
+from typing import List, Tuple
 
 

 [docs]
@@ -339,7 +340,14 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.one_max    Attributes
     ----------
-    None
+    design_variables : int
+        Number of design variables (chromosome length).
+    bounds : List[Tuple[float, float]]
+        Bounds for each design variable as (min, max).
+    objectives : List[str]
+        Objectives for optimization, e.g., "maximize".
+    constraints : List[str]
+        Any constraints for the optimization problem.
 
     Methods
     -------
@@ -347,9 +355,34 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.one_max        Evaluates the fitness of a given chromosome.
     """
 
+

+[docs]
+    def __init__(self, 
+                 design_variables: int = 100,
+                 bounds: List[Tuple[float, float]] = [(0, 1)] * 100,
+                 objectives: List[str] = ["maximize"],
+                 constraints: List[str] = []):
+        """
+        Initialize the OneMax problem with default design variables, bounds, 
+        objectives, and optional constraints.
+
+        Parameters
+        ----------
+        design_variables : int, optional
+            Number of design variables (default is 100).
+        bounds : List[Tuple[float, float]], optional
+            Bounds for each design variable in (min, max) format (default is [(0, 1)] * 100).
+        objectives : List[str], optional
+            Objectives for optimization, e.g., "maximize" (default is ["maximize"]).
+        constraints : List[str], optional
+            Constraints for the problem (default is an empty list).
+        """
+        super().__init__(design_variables=design_variables, bounds=bounds, objectives=objectives, constraints=constraints)

+
+
 

 [docs]
-    def f(self, x) -> float:
+    def f(self, x: List[int]) -> float:
         """
         Evaluates the fitness of a given chromosome for the OneMax problem.
 
@@ -357,7 +390,7 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.one_max        Parameters
         ----------
-        x : list
+        x : List[int]
             A list representing the chromosome, where each element is a binary 
             value (0 or 1).
 
@@ -366,7 +399,7 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.one_max        float
             The fitness value of the chromosome, which is the sum of its bits.
         """
-        return sum(x)

+        return float(sum(x))
diff --git a/_modules/pycellga/problems/single_objective/discrete/binary/peak.html b/_modules/pycellga/problems/single_objective/discrete/binary/peak.html index 22ed9d2..2eb9805 100644 --- a/_modules/pycellga/problems/single_objective/discrete/binary/peak.html +++ b/_modules/pycellga/problems/single_objective/discrete/binary/peak.html @@ -328,6 +328,7 @@

Source code for pycellga.problems.single_objective.discrete.binary.peak

 from problems.abstract_problem import AbstractProblem
 from numpy import random
+from typing import List, Tuple
 
 

 [docs]
@@ -340,7 +341,14 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.peak

 
     Attributes
     ----------
-    None
+    design_variables : List[str]
+        Names of the design variables.
+    bounds : List[Tuple[float, float]]
+        Bounds for each design variable as (min, max).
+    objectives : List[str]
+        Objectives for optimization, e.g., "minimize" or "maximize".
+    constraints : List[str]
+        Any constraints for the optimization problem.
 
     Methods
     -------
@@ -353,9 +361,23 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.peak

     # Maximum Fitness Value = 1.0
     """
 
+

+[docs]
+    def __init__(self):
+        """
+        Initializes the Peak problem with default values.
+        """
+        design_variables = ["x" + str(i) for i in range(100)]
+        bounds = [(0, 1) for _ in range(100)]  # Each gene is binary (0 or 1)
+        objectives = ["maximize"]  # Aim to maximize fitness value
+        constraints = []  # No additional constraints
+
+        super().__init__(design_variables, bounds, objectives, constraints)

+
+
 

 [docs]
-    def f(self, x: list) -> float:
+    def f(self, x: List[int]) -> float:
         """
         Evaluates the fitness of a given chromosome for the Peak problem.
 
@@ -394,6 +416,22 @@ 
Source code for pycellga.problems.single_objective.discrete.binary.peak

         fitness = min_distance / problem_length
 
         return round(fitness, 3)

+
+
+

+[docs]
+    def evaluate(self, x, out, *args, **kwargs):
+        """
+        Evaluate function for compatibility with pymoo's optimizer.
+
+        Parameters
+        ----------
+        x : numpy.ndarray
+            Array of input variables.
+        out : dict
+            Dictionary to store the output fitness values.
+        """
+        out["F"] = self.f(x)
diff --git a/_modules/pycellga/problems/single_objective/discrete/permutation/tsp.html b/_modules/pycellga/problems/single_objective/discrete/permutation/tsp.html index d52a1ff..6a08415 100644 --- a/_modules/pycellga/problems/single_objective/discrete/permutation/tsp.html +++ b/_modules/pycellga/problems/single_objective/discrete/permutation/tsp.html @@ -331,6 +331,7 @@

Source code for pycellga.problems.single_objective.discrete.permutation.tsp< from math import sqrt from geopy.distance import geodesic import os +from typing import List, Tuple
[docs] @@ -340,24 +341,45 @@

Source code for pycellga.problems.single_objective.discrete.permutation.tsp< This class solves the TSP using geographical distances (GEO) for node coordinates. - Notes + Attributes ---------- - #### burma14.tsp ######################################## - # EDGE_WEIGHT_TYPE: GEO, use gographical_dist function - # Length of chromosomes = 14 - # Known Best Route = [] - # Minumum Fitness Value = 3323 - ######################################################### + design_variables : list + Names of the design variables (nodes in this case). + bounds : list of tuples + Bounds for each design variable as (min, max). + objectives : list + Objectives for optimization, e.g., "minimize" or "maximize". + constraints : list + Constraints for the optimization problem. + + Notes + ----- + - Uses geographical distance function (GEO) for evaluating routes. + - Example problem: burma14.tsp, with a known minimum distance. """ +
+[docs] + def __init__(self): + """ + Initialize the TSP problem with default attributes. + + Uses the 'burma14' TSP dataset as an example with 14 nodes. + """ + design_variables = ["node" + str(i) for i in range(1, 15)] + bounds = [(1, 14) for _ in range(14)] # Nodes range from 1 to 14 + objectives = ["minimize"] + constraints = [] + + super().__init__(design_variables, bounds, objectives, constraints)
+ +
[docs] - def f(self, x: list) -> float: + def f(self, x: List[int]) -> float: """ Evaluates the fitness of a given chromosome (route) for the TSP. - This method calculates the total distance of the given route using geographical distances. - Parameters ---------- x : list @@ -368,20 +390,14 @@

Source code for pycellga.problems.single_objective.discrete.permutation.tsp< float The total distance of the route, rounded to one decimal place. """ - - + # Load TSP data file file_path = os.path.join(os.path.dirname(__file__), 'burma14.tsp.txt') with open(file_path) as fl: problem = tsplib95.read(fl) nodes = list(problem.node_coords.values()) - node_x = [] - node_y = [] - - for i in nodes: - node_x.append(i[0]) - node_y.append(i[1]) + # Compute distances between all pairs of nodes temp = [] for i in nodes: temp_row = [] @@ -389,27 +405,16 @@

Source code for pycellga.problems.single_objective.discrete.permutation.tsp< temp_row.append(self.gographical_dist(i, j)) temp.append(temp_row) - node_name = [] - for i in range(1, 15): - node_name.append(i) - - Dist = {} - # Creating the dictionary of dictionaries - for i, row_name in enumerate(node_name): - Dist[row_name] = {} - for j, col_name in enumerate(node_name): - Dist[row_name][col_name] = temp[i][j] - - # objective - fitness = 0.0 + # Dictionary of distances between nodes + node_name = list(range(1, 15)) + Dist = {row_name: {col_name: temp[i][j] for j, col_name in enumerate(node_name)} + for i, row_name in enumerate(node_name)} + # Calculate total route distance + fitness = 0.0 for i in range(len(x)): start_node = x[i] - - if i+1 == len(x): - end_node = x[0] - else: - end_node = x[i+1] + end_node = x[(i + 1) % len(x)] fitness += Dist[start_node][end_node] return round(fitness, 1)

@@ -417,7 +422,7 @@

Source code for pycellga.problems.single_objective.discrete.permutation.tsp<
[docs] - def euclidean_dist(self, a: list, b: list) -> float: + def euclidean_dist(self, a: List[float], b: List[float]) -> float: """ Computes the Euclidean distance between two nodes. @@ -439,7 +444,7 @@

Source code for pycellga.problems.single_objective.discrete.permutation.tsp<
[docs] - def gographical_dist(self, a: list, b: list) -> float: + def gographical_dist(self, a: List[float], b: List[float]) -> float: """ Computes the geographical distance between two nodes using the geodesic distance. @@ -455,11 +460,7 @@

Source code for pycellga.problems.single_objective.discrete.permutation.tsp< float The geographical distance between the two nodes, rounded to one decimal place. """ - dist = 0.0 - for i in range(len(a)): - x_city = ([a[0], a[1]]) - y_city = ([b[0], b[1]]) - dist = geodesic(x_city, y_city).km + dist = geodesic(a, b).km return round(dist, 1)

diff --git a/genindex.html b/genindex.html index d58e03f..78c11e7 100644 --- a/genindex.html +++ b/genindex.html @@ -354,12 +354,20 @@

Index

_

@@ -454,12 +522,70 @@

B

  • bits_to_floats() (in module pycellga.byte_operators)
    • - - + - + @@ -537,6 +689,64 @@

    C

    D

    - +
    + +
    • ExampleProblem (class in pycellga.example.example_alpha_cga)
        @@ -566,78 +834,78 @@

        E

        F

        @@ -969,78 +1237,84 @@

        N

      • (Population attribute)
        • + + +
        + +

        O

        + + -
        - -

        O

        - - + -
        +
        • pycellga.problems.single_objective.continuous.levy @@ -1312,8 +1596,6 @@

          P

        • module
        -
        • pycellga.problems.single_objective.continuous.matyas diff --git a/objects.inv b/objects.inv index e5183f7..1f66b26 100644 Binary files a/objects.inv and b/objects.inv differ diff --git a/pycellga.html b/pycellga.html index 648c59f..9b1c0e8 100644 --- a/pycellga.html +++ b/pycellga.html @@ -703,7 +703,7 @@

          Individual Representation
          -setneighbors(neighbors: list) → None[source]
          +setneighbors(neighbors: list) → None[source]

          Set the list of neighbors for the individual.

          Parameters:
          @@ -714,7 +714,7 @@

          Individual Representation
          -setneighbors_positions(positions: list) → None[source]
          +setneighbors_positions(positions: list) → None[source]

          Set the positions of the individual’s neighbors.

          Parameters:
          diff --git a/pycellga.problems.html b/pycellga.problems.html index 8336a8d..481bc3d 100644 --- a/pycellga.problems.html +++ b/pycellga.problems.html @@ -337,32 +337,54 @@

          Abstract Problem Base
          -class AbstractProblem[source]
          -

          Bases: object

          -

          An abstract base class for optimization problems.

          +class AbstractProblem(design_variables: int | List[str], bounds: List[Tuple[float, float]], objectives: str | int | List[str], constraints: str | int | List[str] = [])[source] +

          Bases: Problem, ABC

          +

          Abstract base class for optimization problems.

          -
          -f(x)[source]
          -

          Evaluates the fitness of a given solution x.

          +
          +__init__(design_variables: int | List[str], bounds: List[Tuple[float, float]], objectives: str | int | List[str], constraints: str | int | List[str] = [])[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          -
          -f(x)[source]
          -

          Evaluate the fitness of a given solution x.

          +
          +abstract f(x: List[Any]) → float[source]
          +

          Abstract method for evaluating the fitness of a solution.

          Parameters:
          -

          x (list) – A list representing a candidate solution.

          +

          x (list) – List of design variable values.

          Returns:
          -

          The fitness value of the candidate solution.

          +

          Fitness value.

          Return type:

          float

          -
          Raises:
          -

          NotImplementedError – If the method is not implemented by a subclass.

          -
          diff --git a/pycellga.problems.single_objective.continuous.html b/pycellga.problems.single_objective.continuous.html index 38426b0..ddbc976 100644 --- a/pycellga.problems.single_objective.continuous.html +++ b/pycellga.problems.single_objective.continuous.html @@ -339,43 +339,108 @@

          Ackley Function
          -class Ackley[source]
          +class Ackley(dimension: int)[source]

          Bases: AbstractProblem

          Ackley function implementation for optimization problems.

          The Ackley function is widely used for testing optimization algorithms. It has a nearly flat outer region and a large hole at the center. The function is usually evaluated on the hypercube x_i ∈ [-32.768, 32.768], for all i = 1, 2, …, d.

          -
          -None
          -
          +
          +design_variables
          +

          List of variable names.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +

          + +
          +
          +bounds
          +

          Bounds for each variable.

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Ackley function value for given variables.

          +
          -f(x: list) → float[source]
          -

          Calculates the Ackley function value for a given list of variables.

          +f(x)[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Notes

          -32.768 ≤ xi ≤ 32.768 Global minimum at f(0, 0) = 0

          +
          +
          +__init__(dimension: int)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          +
          -f(x: list) → float[source]
          +evaluate(x, out, *args, **kwargs)[source]

          Calculate the Ackley function value for a given list of variables.

          Parameters:
          -

          x (list) – A list of float variables.

          -
          -
          Returns:
          -

          The Ackley function value.

          -
          -
          Return type:
          -

          float

          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +

          @@ -384,42 +449,107 @@

          Bent Cigar Function
          -class Bentcigar[source]
          +class Bentcigar(dimension: int)[source]

          Bases: AbstractProblem

          Bentcigar function implementation for optimization problems.

          The Bentcigar function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-100, 100], for all i = 1, 2, …, n.

          -
          -None
          -
          +
          +design_variables
          +

          List of variable names.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +bounds
          +

          Bounds for each variable.

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Bentcigar function value for given variables.

          +
          -f(X: list) → float[source]
          -

          Calculates the Bentcigar function value for a given list of variables.

          +f(x)[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Notes

          -100 ≤ xi ≤ 100 for i = 1,…,n Global minimum at f(0,…,0) = 0

          -
          -f(X: list) → float[source]
          -

          Calculate the Bentcigar function value for a given list of variables.

          +
          +__init__(dimension: int)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          X (list) – A list of float variables.

          -
          -
          Returns:
          -

          The Bentcigar function value.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          -
          Return type:
          -

          float

          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Calculate the Bentcigar function value for a given list of variables.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +

          @@ -428,42 +558,107 @@

          Bohachevsky Function
          -class Bohachevsky[source]
          +class Bohachevsky(dimension: int)[source]

          Bases: AbstractProblem

          Bohachevsky function implementation for optimization problems.

          The Bohachevsky function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-15, 15], for all i = 1, 2, …, n.

          -
          -None
          -
          +
          +design_variables
          +

          List of variable names.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +bounds
          +

          Bounds for each variable.

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Bohachevsky function value for given variables.

          +
          -f(x: list) → float[source]
          -

          Calculates the Bohachevsky function value for a given list of variables.

          +f(x)[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Notes

          -15 ≤ xi ≤ 15 for i = 1,…,n Global minimum at f(0,…,0) = 0

          -
          -f(x: list) → float[source]
          -

          Calculate the Bohachevsky function value for a given list of variables.

          +
          +__init__(dimension: int)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          x (list) – A list of float variables.

          -
          -
          Returns:
          -

          The Bohachevsky function value.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          -
          Return type:
          -

          float

          +
          +
          + +
          +
          +evaluate(x: List[float], out: Dict[str, Any], *args, **kwargs)[source]
          +

          Calculate the Bohachevsky function value for a given list of variables.

          +
          +
          Parameters:
          +
            +

          • x (list) – A list of float variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +f(x: List[float]) → float[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          + @@ -478,36 +673,101 @@

          Chichinadze Function -
          -None
          -
          +
          +design_variables
          +

          List of variable names.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +bounds
          +

          Bounds for each variable.

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Chichinadze function value for given variables.

          +
          -f(X: list) → float[source]
          -

          Calculates the Chichinadze function value for a given list of variables.

          +f(x)[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Notes

          -30 ≤ x, y ≤ 30 Global minimum at f(5.90133, 0.5) = −43.3159

          -
          -f(X: list) → float[source]
          -

          Calculate the Chichinadze function value for a given list of variables.

          +
          +__init__()[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          X (list) – A list of float variables.

          -
          -
          Returns:
          -

          The Chichinadze function value.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          -
          Return type:
          -

          float

          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Calculate the Chichinadze function value for a given list of variables.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +f(x: List[float]) → float[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          + @@ -521,25 +781,89 @@

          Drop Wave Function +
          +design_variables
          +

          The names of the variables, in this case [“x1”, “x2”].

          +
          +
          Type:
          +

          list

          +
          +
          +
          + +
          +
          +bounds
          +

          The lower and upper bounds for each variable, [-5.12, 5.12] for both x1 and x2.

          +
          +
          Type:
          +

          list of tuples

          +
          +
          +
          + +
          +
          +objectives
          +

          List defining the optimization objective, which is to “minimize” for this function.

          +
          +
          Type:
          +

          list

          +
          +
          +
          + +
          +
          +num_variables
          +

          The number of variables (dimensions) for the function, which is 2 in this case.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the value of the Dropwave function at a given point x.

          +
          +
          -f(x: list) → float[source]
          -

          Computes the value of the Dropwave function at a given point x.

          +f(x)[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          -
          -f(x: list) → float[source]
          -

          Evaluate the Dropwave function at a given point.

          +
          +__init__()[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          x (list) – A list of two floats representing the coordinates [x1, x2].

          -
          -
          Returns:
          -

          The value of the Dropwave function rounded to three decimal places.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          -
          Return type:
          -

          float

          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Calculate the Dropwave function value for a given list of variables.

          +
          +
          Parameters:
          +
            +

          • x (list) – A list of two floats representing the coordinates [x1, x2].

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +

          Notes

          @@ -548,14 +872,12 @@

          Drop Wave FunctionExamples

          -
          >>> dropwave = Dropwave()
->>> dropwave.f([0, 0])
--1.0
->>> dropwave.f([1, 1])
--0.028
-
          -
          +

          + +
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          @@ -571,38 +893,98 @@

          Frequency Modulation Sound Function (FMS) -
          -None
          -
          +
          +design_variables
          +

          List of variable names.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +bounds
          +

          Bounds for each variable.

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Fms function value for given variables.

          +
          -f(x: list) → float[source]
          -

          Calculates the Fms function value for a given list of variables.

          +f(x)[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          -

          Notes

          -

          -6.4 ≤ xi ≤ 6.35 -Length of chromosomes = 6 -Maximum Fitness Value = 0.01 -Maximum Fitness Value Error = 10^-2

          -
          -f(x: list) → float[source]
          -

          Calculate the Fms function value for a given list of variables.

          +
          +__init__()[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          x (list) – A list of float variables.

          -
          -
          Returns:
          -

          The Fms function value.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          -
          Return type:
          -

          float

          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Calculate the Fms function value for a given list of variables.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          + @@ -611,27 +993,102 @@

          Griewank Function
          -class Griewank[source]
          +class Griewank(dimensions=10)[source]

          Bases: AbstractProblem

          Griewank function implementation for optimization problems.

          The Griewank function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-600, 600], for all i = 1, 2, …, n.

          +
          +
          +design_variables
          +

          Names of the design variables.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +bounds
          +

          Bounds for each design variable.

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization, typically [“minimize”].

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the optimization problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Evaluates the Griewank function value for a given list of variables.

          +
          +
          -f(X: list) → float[source]
          -

          Calculates the Griewank function value for a given list of variables.

          +f(x: list) → float[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Notes

          -600 ≤ xi ≤ 600 for i = 1,…,n Global minimum at f(0,…,0) = 0

          -
          -f(X: list) → float[source]
          +
          +__init__(dimensions=10)[source]
          +

          Initialize the Griewank function with the specified number of dimensions.

          +
          +
          Parameters:
          +

          dimensions (int, optional) – The number of dimensions (design variables) for the Griewank function, by default 10.

          +
          +
          +
          + +
          +
          +evaluate(x: List[float], out, *args, **kwargs)[source]

          Calculate the Griewank function value for a given list of variables.

          Parameters:
          -

          X (list) – A list of float variables.

          +
            +

          • x (list) – A list of float variables.

            • +

          • out (dict) – Dictionary to store the output fitness value.

            • +
          +
          +
          +
          + +
          +
          +f(x: List[float]) → float[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +
          Parameters:
          +

          x (list) – A list of float variables.

          Returns:

          The Griewank function value.

          @@ -650,42 +1107,107 @@

          Holzman Function
          -class Holzman[source]
          +class Holzman(design_variables: int = 2)[source]

          Bases: AbstractProblem

          Holzman function implementation for optimization problems.

          The Holzman function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-10, 10], for all i = 1, 2, …, n.

          -
          -None
          -
          +
          +design_variables
          +

          Names of the design variables.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +

          + +
          +
          +bounds
          +

          Bounds for each variable.

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Holzman function value for given variables.

          +
          f(x: list) → float[source]
          -

          Calculates the Holzman function value for a given list of variables.

          +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Notes

          -10 ≤ xi ≤ 10 for i = 1,…,n Global minimum at f(0,…,0) = 0

          -
          -f(x: list) → float[source]
          -

          Calculate the Holzman function value for a given list of variables.

          +
          +__init__(design_variables: int = 2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          x (list) – A list of float variables.

          -
          -
          Returns:
          -

          The Holzman function value.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          -
          Return type:
          -

          float

          +
          +
          + +
          +
          +evaluate(x: List[float], out, *args, **kwargs)[source]
          +

          Calculate the Holzman function value for a given list of variables.

          +
          +
          Parameters:
          +
            +

          • x (list) – A list of float variables.

            • +

          • out (dict) – Dictionary to store the output fitness value.

            • +
          +
          +
          +f(x: List[float]) → float[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +
          @@ -694,35 +1216,111 @@

          Levy FunctionThis function is used to test the efficiency of algorithms on smooth, differentiable landscapes.

          -class Levy[source]
          +class Levy(dimension: int = 2)[source]

          Bases: AbstractProblem

          Levy function implementation for optimization problems.

          The Levy function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-10, 10], for all i = 1, 2, …, n.

          -
          -None
          -
          +
          +design_variables
          +

          The names of the design variables.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-10, 10), (-10, 10), …].

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization, usually “minimize” for single-objective functions.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the optimization problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Levy function value for a given list of variables and stores in out.

          +
          f(x: list) → float[source]
          -

          Calculates the Levy function value for a given list of variables.

          +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Notes

          -10 ≤ xi ≤ 10 for i = 1,…,n -Global minimum at f(1,1) = 0

          +Global minimum at f(1,1,…,1) = 0

          +
          +
          +__init__(dimension: int = 2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x: List[float], out, *args, **kwargs)[source]
          +

          Evaluate the Levy function at a given point.

          +
          +
          Parameters:
          +
            +

          • x (list) – A list of float variables.

            • +

          • out (dict) – Dictionary to store the output fitness value.

            • +
          +
          +
          +
          +
          -
          -f(x: list) → float[source]
          -

          Calculate the Levy function value for a given list of variables.

          +
          +f(x: List[float]) → float[source]
          +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Parameters:

          x (list) – A list of float variables.

          Returns:
          -

          The Levy function value.

          +

          The calculated Levy function value.

          Return type:

          float

          @@ -741,39 +1339,90 @@

          Matyas Functionclass Matyas[source]

          Bases: AbstractProblem

          Matyas function implementation for optimization problems.

          -

          The Matyas function is widely used for testing optimization algorithms. -The function is usually evaluated on the hypercube x_i ∈ [-10, 10], for all i = 1, 2, …, n.

          +

          The Matyas function is commonly used to evaluate the performance of optimization algorithms. +It is a simple, continuous, convex function that has a global minimum at the origin.

          +
          +
          +design_variables
          +

          The names of the design variables, typically [“x1”, “x2”] for 2 variables.

          +
          +
          Type:
          +

          list of str

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-10, 10), (-10, 10)].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          +
          -
          -None
          -
          +
          +objectives
          +

          The objectives for optimization, set to [“minimize”].

          +
          +
          Type:
          +

          list of str

          +
          +
          +

          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Computes the Matyas function value for a given list of variables.

          +
          -f(X: list) → float[source]
          -

          Calculates the Matyas function value for a given list of variables.

          +f(x: list) → float[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          -

          Notes

          -

          -10 ≤ xi ≤ 10 for i = 1,…,n -Global minimum at f(0,…,0) = 0

          -
          -f(X: list) → float[source]
          -

          Calculate the Matyas function value for a given list of variables.

          +
          +__init__()[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          X (list) – A list of float variables.

          -
          -
          Returns:
          -

          The Matyas function value.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          -
          Return type:
          -

          float

          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Calculate the Matyas function value for a given list of variables.

          +
          +
          Parameters:
          +
            +

          • x (list of float) – A list of float variables representing a point in the solution space.

            • +

          • out (dict) – Dictionary to store the output fitness value with key “F”.

            • +
          +
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +
          @@ -782,31 +1431,94 @@

          Pow FunctionThis function is used to test the efficiency of algorithms on smooth, differentiable landscapes.

          -class Pow[source]
          +class Pow(design_variables=5)[source]

          Bases: AbstractProblem

          Pow function implementation for optimization problems.

          -

          The Pow function is widely used for testing optimization algorithms. -The function is usually evaluated on the hypercube x_i ∈ [-5.0, 15.0].

          +

          The Pow function is typically used for testing optimization algorithms. +It is evaluated on the hypercube x_i ∈ [-5.0, 15.0] with the goal of reaching +the global minimum at f(5, 7, 9, 3, 2) = 0.

          +
          +
          +design_variables
          +

          The names of the design variables.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-5.0, 15.0) for each dimension].

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          +
          -
          -None
          -
          +
          +objectives
          +

          Objectives for optimization, e.g., “minimize”.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Pow function value for compatibility with Pymoo’s optimizer.

          +
          f(x: list) → float[source]
          -

          Calculates the Pow function value for a given list of variables.

          +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          -

          Notes

          -

          -5.0 ≤ xi ≤ 15.0 -Global minimum at f(5, 7, 9, 3, 2) = 0

          -
          -f(x: list) → float[source]
          +
          +__init__(design_variables=5)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]

          Calculate the Pow function value for a given list of variables.

          Parameters:
          +
            +

          • x (list) – A list of float variables representing the point in the solution space.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: List[float]) → float[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +
          Parameters:

          x (list) – A list of float variables.

          Returns:
          @@ -826,35 +1538,97 @@

          Powell Function
          -class Powell[source]
          +class Powell(design_variables=4)[source]

          Bases: AbstractProblem

          Powell function implementation for optimization problems.

          The Powell function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-4, 5], for all i = 1, 2, …, n.

          -
          -None
          -
          +
          +design_variables
          +

          The number of variables for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +

          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-4, 5), (-4, 5), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs) → None[source]
          +

          Calculates the Powell function value and stores in the output dictionary.

          +
          f(x: list) → float[source]
          -

          Calculates the Powell function value for a given list of variables.

          +

          Wrapper for evaluate to maintain compatibility with the rest of the codebase.

          -

          Notes

          -

          -4 ≤ xi ≤ 5 for i = 1,…,n -Global minimum at f(0,….,0) = 0

          -
          -f(x: list) → float[source]
          -

          Calculate the Powell function value for a given list of variables.

          +
          +__init__(design_variables=4)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate the Powell function at a given point.

          +
          +
          Parameters:
          +
            +

          • x (list or numpy array) – Input variables.

            • +

          • out (dict) – Output dictionary to store the function value.

            • +
          +
          +
          +
          + +
          +
          +f(x)[source]
          +

          Wrapper for the evaluate method to maintain compatibility.

          Parameters:

          x (list) – A list of float variables.

          Returns:
          -

          The Powell function value.

          +

          The computed Powell function value.

          Return type:

          float

          @@ -870,15 +1644,43 @@

          Rastrigin Function
          -class Rastrigin[source]
          +class Rastrigin(design_variables=2)[source]

          Bases: AbstractProblem

          Rastrigin function implementation for optimization problems.

          The Rastrigin function is widely used for testing optimization algorithms. -The function is usually evaluated on the hypercube x_i ∈ [-5.12, 5.12], for all i = 1, 2, …, n.

          +It is typically evaluated on the hypercube x_i ∈ [-5.12, 5.12], for all i = 1, 2, …, n.

          +
          +
          +design_variables
          +

          The number of variables for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +
          +
          -
          -None
          -
          +
          +bounds
          +

          The bounds for each variable, typically [(-5.12, 5.12), (-5.12, 5.12), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +

          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          @@ -890,8 +1692,19 @@

          Rastrigin Function -
          -f(x: list) → float[source]
          +
          +__init__(design_variables=2)[source]
          +

          Initialize the Rastrigin problem with the specified number of variables.

          +
          +
          Parameters:
          +

          design_variables (int, optional) – The number of design variables, by default 2.

          +
          +
          +

          + +
          +
          +f(x: list) → float[source]

          Calculate the Rastrigin function value for a given list of variables.

          Parameters:
          @@ -914,31 +1727,96 @@

          Rosenbrock Function
          -class Rosenbrock[source]
          +class Rosenbrock(design_variables=2)[source]

          Bases: AbstractProblem

          Rosenbrock function implementation for optimization problems.

          The Rosenbrock function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-5, 10], for all i = 1, 2, …, n.

          -
          -None
          -
          +
          +design_variables
          +

          Number of variables for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +

          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-5, 10), (-5, 10), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Evaluates the Rosenbrock function value for a given list of variables.

          +
          f(x: list) → float[source]
          -

          Calculates the Rosenbrock function value for a given list of variables.

          +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          Notes

          -5 ≤ xi ≤ 10 for i = 1,…,n Global minimum at f(1,…,1) = 0

          -
          -f(x: list) → float[source]
          +
          +__init__(design_variables=2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]

          Calculate the Rosenbrock function value for a given list of variables.

          Parameters:
          +
            +

          • x (list) – A list of float variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: list) → float[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +
          Parameters:

          x (list) – A list of float variables.

          Returns:
          @@ -958,29 +1836,91 @@

          Rothellipsoid Function
          -class Rothellipsoid[source]
          +class Rothellipsoid(design_variables=3)[source]

          Bases: AbstractProblem

          Rotated Hyper-Ellipsoid function implementation for optimization problems.

          -

          The Rotated Hyper-Ellipsoid function is widely used for testing optimization algorithms. +

          This function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-100, 100], for all i = 1, 2, …, n.

          -
          -None
          -
          +
          +design_variables
          +

          Number of variables (dimensions) for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +

          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-100, 100), (-100, 100), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          f(x: list) → float[source]
          -

          Calculates the Rotated Hyper-Ellipsoid function value for a given list of variables.

          +

          Alias for evaluate, calculates the Rotated Hyper-Ellipsoid function value for a given list of variables.

          -

          Notes

          -

          -100 ≤ xi ≤ 100 for i = 1,…,n -Global minimum at f(0,….,0) = 0

          -
          -f(x: list) → float[source]
          -

          Calculate the Rotated Hyper-Ellipsoid function value for a given list of variables.

          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Pymoo-compatible function for calculating the fitness values and storing them in the out dictionary.

          +
          + +
          +
          +__init__(design_variables=3)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Calculate the Rotated Hyper-Ellipsoid function value for pymoo compatibility.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          Parameters:

          x (list) – A list of float variables.

          @@ -1002,45 +1942,91 @@

          Schaffer Function
          -class Schaffer[source]
          +class Schaffer(design_variables=2)[source]

          Bases: AbstractProblem

          -

          Schaffer’s Function.

          -

          This class implements the Schaffer’s function, which is a common benchmark problem for optimization algorithms. +

          Schaffer’s Function for optimization problems.

          +

          This class implements the Schaffer’s function, a common benchmark problem for optimization algorithms. The function is defined over a multidimensional input and is used to test the performance of optimization methods.

          +
          +
          +design_variables
          +

          The number of variables for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable, typically set to [(-100, 100), (-100, 100), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Schaffer’s function value for compatibility with pymoo.

          +
          +
          -f(X: list) → float[source]
          -

          Calculates the value of the Schaffer’s function for a given list of input variables.

          +f(x: list) → float[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          +
          + +
          +
          +__init__(design_variables=2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate the Schaffer’s function for a given point using pymoo compatibility.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness value.

            • +
          +
          +
          -
          -f(X: list) → float[source]
          -
          -

          Evaluate the Schaffer’s function at a given point.

          -
          -
          Xlist

          A list of input variables (continuous values). The length of X should be at least 2.

          -
          -
          -
          -
          float

          The value of the Schaffer’s function evaluated at X, rounded to three decimal places.

          -
          -
          -

          The Schaffer’s function is defined as: -[ -f(X) = sum_{i=1}^{n-1} left[ 0.5 +

          -
          -

          rac{(sin(x_i^2 + x_{i+1}^2)^2 - 0.5)^2}{(1 + 0.001 cdot (x_i^2 + x_{i+1}^2))^2} -ight]

          -
          -

          ] -where ( n ) is the number of elements in X.

          -
          >>> schaffer = Schaffer()
->>> schaffer.f([1.0, 2.0])
-0.554
-
          -
          -
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          @@ -1051,42 +2037,93 @@

          Schaffer2 Function
          -class Schaffer2[source]
          +class Schaffer2(design_variables=2)[source]

          Bases: AbstractProblem

          Modified Schaffer function #2 implementation for optimization problems.

          The Modified Schaffer function #2 is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-100, 100], for all i = 1, 2, …, n.

          -
          -None
          -
          +
          +design_variables
          +

          The number of design variables.

          +
          +
          Type:
          +

          int

          +
          +
          +

          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-100, 100), (-100, 100), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Evaluates the Modified Schaffer function #2 value for a given list of variables.

          +
          -f(X: list) → float[source]
          -

          Calculates the Modified Schaffer function #2 value for a given list of variables.

          +f(x: list) → float[source] +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          -

          Notes

          -

          -100 ≤ xi ≤ 100 for i = 1,…,n -Global minimum at f(0,…,0) = 0

          -
          -f(X: list) → float[source]
          -

          Calculate the Modified Schaffer function #2 value for a given list of variables.

          +
          +__init__(design_variables=2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          X (list) – A list of float variables.

          -
          -
          Returns:
          -

          The Modified Schaffer function #2 value.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          -
          Return type:
          -

          float

          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate the Modified Schaffer function #2 value for a given list of variables.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +
          @@ -1095,31 +2132,93 @@

          Schwefel Function
          -class Schwefel[source]
          +class Schwefel(design_variables=2)[source]

          Bases: AbstractProblem

          Schwefel function implementation for optimization problems.

          -

          The Schwefel function is widely used for testing optimization algorithms. -The function is usually evaluated on the hypercube x_i ∈ [-500, 500], for all i = 1, 2, …, n.

          +

          This function is commonly used for testing optimization algorithms and is evaluated on the range +[-500, 500] for each variable.

          +
          +
          +design_variables
          +

          The number of variables in the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-500, 500), (-500, 500), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          +
          -
          -None
          -
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +

          + +
          +
          +evaluate(x, out, \*args, \*\*kwargs)[source]
          +

          Calculates the Schwefel function value for a given list of variables, compatible with pymoo.

          +
          f(x: list) → float[source]
          -

          Calculates the Schwefel function value for a given list of variables.

          +

          Alias for evaluate to maintain compatibility with the rest of the codebase.

          -

          Notes

          -

          -500 ≤ xi ≤ 500 for i = 1,…,n -Global minimum at f(420.9687,…,420.9687) = 0

          -
          -f(x: list) → float[source]
          +
          +__init__(design_variables=2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]

          Calculate the Schwefel function value for a given list of variables.

          Parameters:
          +
            +

          • x (numpy.ndarray) – A numpy array of float variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x)[source]
          +

          Alias for the evaluate method to maintain compatibility with the rest of the codebase.

          +
          +
          Parameters:

          x (list) – A list of float variables.

          Returns:
          @@ -1139,28 +2238,39 @@

          Sphere Function
          -class Sphere[source]
          +class Sphere(design_variables=10)[source]

          Bases: AbstractProblem

          Sphere function implementation for optimization problems.

          -

          The Sphere function is widely used for testing optimization algorithms. -The function is usually evaluated on the hypercube x_i ∈ [-5.12, 5.12], for all i = 1, 2, …, n.

          -
          -
          -None
          -
          +

          The Sphere function is commonly used for testing optimization algorithms. +It is defined on a hypercube where each variable typically lies within [-5.12, 5.12].

          +
          +
          +__init__(design_variables=10)[source]
          +

          Initializes the Sphere function with specified design variables and bounds.

          +
          +
          Parameters:
          +

          design_variables (int, optional) – Number of variables for the function, by default 10.

          +
          +
          +
          -
          -f(x: list) → float[source]
          -

          Calculates the Sphere function value for a given list of variables.

          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          -

          Notes

          -

          -5.12 ≤ xi ≤ 5.12 for i = 1,…,n -Global minimum at f(0,…,0) = 0

          -
          -f(x: list) → float[source]
          +
          +f(x: list) → float[source]

          Calculate the Sphere function value for a given list of variables.

          Parameters:
          @@ -1183,28 +2293,39 @@

          Styblinskitang Function
          -class StyblinskiTang[source]
          +class StyblinskiTang(design_variables=2)[source]

          Bases: AbstractProblem

          Styblinski-Tang function implementation for optimization problems.

          The Styblinski-Tang function is widely used for testing optimization algorithms. The function is usually evaluated on the hypercube x_i ∈ [-5, 5], for all i = 1, 2, …, n.

          -
          -
          -None
          -
          +
          +
          +__init__(design_variables=2)[source]
          +

          Initializes the Styblinski-Tang function with specified design variables and bounds.

          +
          +
          Parameters:
          +

          design_variables (int, optional) – Number of variables for the function, by default 2.

          +
          +
          +
          -
          -f(x: list) → float[source]
          -

          Calculates the Styblinski-Tang function value for a given list of variables.

          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          -

          Notes

          -

          -5 ≤ xi ≤ 5 for i = 1,…,n -Global minimum at f(−2.903534, −2.903534) = −78.332

          -
          -f(x: list) → float[source]
          +
          +f(x: list) → float[source]

          Calculate the Styblinski-Tang function value for a given list of variables.

          Parameters:
          @@ -1227,12 +2348,87 @@

          Sumofdifferentpowers Function
          -class Sumofdifferentpowers[source]
          +class Sumofdifferentpowers(design_variables=2)[source]

          Bases: AbstractProblem

          Sum of Different Powers function implementation for optimization problems.

          +

          The Sum of Different Powers function is often used for testing optimization algorithms. +It is usually evaluated within the bounds x_i ∈ [-1, 1] for each variable.

          +
          +
          +n_var
          +

          The number of variables for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-1, 1), (-1, 1), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          +
          f(x: list) → float[source]
          +

          Calculates the Sum of Different Powers function value for a given list of variables.

          +
          + +

          Notes

          +

          -1 ≤ xi ≤ 1 for all i. +Global minimum at f(0,…,0) = 0.

          +
          +
          +__init__(design_variables=2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate method for compatibility with pymoo’s framework.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: list) → float[source]

          Calculate the Sum of Different Powers function value for a given list of variables.

          Parameters:
          @@ -1261,9 +2457,37 @@

          Threehumps Function -
          -None
          -

          +
          +bounds
          +

          Bounds for each variable, set to [(-5, 5), (-5, 5)] for this function.

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +design_variables
          +

          Number of variables for this problem, which is 2.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, which is 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          @@ -1271,12 +2495,40 @@

          Threehumps FunctionNotes

          -

          -5 ≤ xi ≤ 5 for i = 1,…,n -Global minimum at f(0,..,0) = 0

          -
          -f(x: list) → float[source]
          +
          +__init__()[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate method for compatibility with pymoo’s framework.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: list) → float[source]

          Calculate the Three Hump Camel function value for a given list of variables.

          Parameters:
          @@ -1299,15 +2551,43 @@

          Zakharov Function
          -class Zakharov[source]
          +class Zakharov(design_variables=2)[source]

          Bases: AbstractProblem

          Zakharov function implementation for optimization problems.

          -

          The Zakharov function is widely used for testing optimization algorithms. -The function is usually evaluated on the hypercube x_i ∈ [-5, 10], for all i = 1, 2, …, n.

          +

          The Zakharov function is commonly used to test optimization algorithms. +It evaluates inputs over the hypercube x_i ∈ [-5, 10].

          +
          +
          +design_variables
          +

          The number of variables for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-5, 10), (-5, 10), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          +
          -
          -None
          -
          +
          +objectives
          +

          Objectives for the problem, set to [“minimize”] for single-objective optimization.

          +
          +
          Type:
          +

          list

          +
          +
          +
          @@ -1315,12 +2595,40 @@

          Zakharov FunctionNotes

          -

          -5 ≤ xi ≤ 10 for i = 1,…,n -Global minimum at f(0,..,0) = 0

          -
          -f(x: list) → float[source]
          +
          +__init__(design_variables=2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x: List[float], out: dict, *args: Any, **kwargs: Any) → None[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: List[float]) → float[source]

          Calculate the Zakharov function value for a given list of variables.

          Parameters:
          @@ -1343,15 +2651,43 @@

          Zettle Function
          -class Zettle[source]
          +class Zettle(design_variables=2)[source]

          Bases: AbstractProblem

          Zettle function implementation for optimization problems.

          The Zettle function is widely used for testing optimization algorithms. -The function is usually evaluated on the hypercube x_i ∈ [-5, 5], for all i = 1, 2, …, n.

          +It is usually evaluated on the hypercube x_i ∈ [-5, 5] for all i = 1, 2, …, n.

          +
          +
          +design_variables
          +

          The number of variables for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable, typically [(-5, 5), (-5, 5), …].

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          +
          -
          -None
          -
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          @@ -1361,17 +2697,34 @@

          Zettle FunctionNotes

          -5 ≤ xi ≤ 5 for i = 1,…,n -Global minimum at f(−0.0299, 0) = −0.003791

          +Global minimum at f(-0.0299, 0) = -0.003791

          -
          -f(x: list) → float[source]
          +
          +__init__(design_variables=2)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +f(x: list) → float[source]

          Calculate the Zettle function value for a given list of variables.

          Parameters:

          x (list) – A list of float variables.

          Returns:
          -

          The Zettle function value.

          +

          The Zettle function value, rounded to six decimal places.

          Return type:

          float

          diff --git a/pycellga.problems.single_objective.discrete.binary.html b/pycellga.problems.single_objective.discrete.binary.html index bcc32a9..37853a7 100644 --- a/pycellga.problems.single_objective.discrete.binary.html +++ b/pycellga.problems.single_objective.discrete.binary.html @@ -340,29 +340,84 @@

          Count SAT
          -class CountSat[source]
          +class CountSat(design_variables=20)[source]

          Bases: AbstractProblem

          CountSat function implementation for optimization problems.

          The CountSat function is used for testing optimization algorithms, particularly those involving satisfiability problems.

          -
          -None
          -
          +
          +design_variables
          +

          The number of variables (chromosome length) for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each binary variable, typically [(0, 1), (0, 1), …] for binary inputs.

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          f(x: list) → float[source]
          -

          Calculates the CountSat function value for a given list of variables.

          +

          Calculates the CountSat function value for a given list of binary variables.

          +
          + +
          +
          +__init__(design_variables=20)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          -

          Notes

          -

          Length of chromosomes = 20 -Maximum Fitness Value = 6860 -Maximum Fitness Value (normalized) = 1

          f(x: list) → float[source]
          -

          Calculate the CountSat function value for a given list of variables.

          +

          Calculate the CountSat function value for a given list of binary variables.

          Parameters:

          x (list) – A list of binary variables.

          @@ -384,35 +439,71 @@

          ECC ProblemThe ECC problem tests the efficiency of algorithms in solving problems related to error-correcting codes, which have discrete solution spaces and are commonly encountered in communication systems.

          -class Ecc[source]
          +class Ecc(design_variables=144)[source]

          Bases: AbstractProblem

          Error Correcting Codes Design Problem (ECC) function implementation for optimization problems.

          The ECC function is used for testing optimization algorithms, particularly those involving error-correcting codes.

          -
          -None
          -
          +
          +design_variables
          +

          Number of binary variables, typically 144.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          Bounds for each variable, typically [(0, 1)] * 144 for binary inputs.

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          -
          -f(x: list) → float[source]
          -

          Calculates the ECC function value for a given list of variables.

          +
          +__init__(design_variables=144)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          -

          Notes

          -

          Length of chromosomes = 144 -Maximum Fitness Value = 0.0674

          -
          -f(x: list) → float[source]
          +
          +f(x: list) → float[source]

          Calculate the ECC function value for a given list of variables.

          Parameters:

          x (list) – A list of binary variables.

          Returns:
          -

          The ECC function value.

          +

          The ECC function value, rounded to four decimal places.

          Return type:

          float

          @@ -428,14 +519,42 @@

          Fletcher-Powell (FMS) Binary ProblemA binary version of the Fletcher-Powell function, used to evaluate robustness and efficiency in finding optimal solutions within a binary space.

          -class Fms[source]
          +class Fms(design_variables=192, bounds=[(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1)], objectives=1)[source]

          Bases: AbstractProblem

          Frequency Modulation Sound (FMS) function implementation for optimization problems.

          The FMS function is used for testing optimization algorithms, particularly those involving frequency modulation sound.

          -
          -None
          -
          +
          +design_variables
          +

          The number of variables for the problem.

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          The bounds for each variable.

          +
          +
          Type:
          +

          list of tuple

          +
          +
          +
          + +
          +
          +objectives
          +

          Number of objectives, set to 1 for single-objective optimization.

          +
          +
          Type:
          +

          int

          +
          +
          +
          @@ -448,8 +567,39 @@

          Fletcher-Powell (FMS) Binary Problem
          -
          -f(x: list) → float[source]
          +
          +__init__(design_variables=192, bounds=[(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1)], objectives=1)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: list) → float[source]

          Calculate the FMS function value for a given list of variables.

          Parameters:
          @@ -474,24 +624,44 @@

          Max-Cut (100 nodes) class Maxcut100[source]

          Bases: AbstractProblem

          -

          A class used to represent the Maximum Cut (MAXCUT) function for 100 nodes.

          +

          A class to represent the Maximum Cut (MAXCUT) problem for 100 nodes.

          -
          -None
          -
          +
          +problema
          +

          A matrix representing the weights between nodes in the MAXCUT problem.

          +
          +
          Type:
          +

          list of list of float

          +
          +
          +
          f(x: list) → float[source]
          -

          Calculates the fitness value of a given chromosome.

          +

          Calculates the fitness value of a given chromosome for the Maxcut problem.

          -

          Notes

          -

          Length of chromosomes = 100 -Maximum Fitness Value = 1077.0

          -
          -f(x: list) → float[source]
          +
          +__init__()[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +f(x: list) → float[source]

          Calculates the fitness value of a given chromosome for the Maxcut problem.

          Parameters:
          @@ -514,34 +684,69 @@

          Max-Cut (20 nodes, Density 0.1)
          -class Maxcut20_01[source]
          +class Maxcut20_01(design_variables=20, bounds=None, objectives=1)[source]

          Bases: AbstractProblem

          Maximum Cut (MAXCUT) function implementation for optimization problems.

          -

          The MAXCUT function is used for testing optimization algorithms, particularly those involving maximum cut problems.

          +

          The MAXCUT function evaluates the fitness of a binary partition of nodes based on edge weights. +It is used to test optimization algorithms, particularly for maximum cut problems.

          -
          -None
          -
          +
          +problema
          +

          Adjacency matrix representing edge weights between nodes.

          +
          +
          Type:
          +

          list of list of float

          +
          +
          +

          f(x: list) → float[source]
          -

          Calculates the MAXCUT function value for a given list of variables.

          +

          Calculates the MAXCUT function value for a given list of binary variables.

          -

          Notes

          -

          Length of chromosomes = 20 -Maximum Fitness Value = 10.119812

          -
          -f(x: list) → float[source]
          -

          Calculate the MAXCUT function value for a given list of variables.

          +
          +__init__(design_variables=20, bounds=None, objectives=1)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          x (list) – A list of binary variables.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: list) → float[source]
          +

          Calculate the MAXCUT function value for a given list of binary variables.

          +
          +
          Parameters:
          +

          x (list) – A list of binary variables representing node partitions.

          Returns:
          -

          The MAXCUT function value.

          +

          The MAXCUT function value representing the total weight of edges cut by the partition.

          Return type:

          float

          @@ -557,34 +762,69 @@

          Max-Cut (20 nodes, Density 0.9)
          -class Maxcut20_09[source]
          +class Maxcut20_09(design_variables=20, bounds=None, objectives=1)[source]

          Bases: AbstractProblem

          -

          Maximum Cut (MAXCUT) function implementation for optimization problems.

          -

          The MAXCUT function is used for testing optimization algorithms, particularly those involving maximum cut problems.

          +

          Maximum Cut (MAXCUT) function for optimization on a 20-node graph.

          +

          This class is used to evaluate the cut value by summing weights of edges +between nodes in different partitions defined by binary variables.

          -
          -None
          -
          +
          +problema
          +

          Adjacency matrix representing edge weights between nodes.

          +
          +
          Type:
          +

          list of list of float

          +
          +
          +

          f(x: list) → float[source]
          -

          Calculates the MAXCUT function value for a given list of variables.

          +

          Calculates the MAXCUT function value for a given list of binary variables.

          -

          Notes

          -

          Length of chromosomes = 20 -Maximum Fitness Value = 56.740064

          -
          -f(x: list) → float[source]
          -

          Calculate the MAXCUT function value for a given list of variables.

          +
          +__init__(design_variables=20, bounds=None, objectives=1)[source]
          +

          Initialize the problem with variables, bounds, objectives, and constraints.

          Parameters:
          -

          x (list) – A list of binary variables.

          +
            +

          • design_variables (int or List[str]) – If an integer, it specifies the number of design variables. +If a list of strings, it specifies the names of design variables.

            • +

          • bounds (List[Tuple[float, float]]) – Bounds for each design variable as (min, max).

            • +

          • objectives (str, int, or List[str]) – Objectives for optimization, e.g., “minimize” or “maximize”.

            • +

          • constraints (str, int, or List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: list) → float[source]
          +

          Calculate the MAXCUT function value for a given list of binary variables.

          +
          +
          Parameters:
          +

          x (list) – A list of binary variables representing node partitions.

          Returns:
          -

          The MAXCUT function value.

          +

          The MAXCUT function value representing the total weight of edges cut by the partition.

          Return type:

          float

          @@ -607,9 +847,48 @@

          Multi-modal Deceptive Problem (MMDP)
          -
          -None
          -
          +
          +design_variables
          +

          Names of the design variables (in this case, binary chromosome genes).

          +
          +
          Type:
          +

          List[str]

          +
          +
          +

          + +
          +
          +bounds
          +

          Bounds for each design variable (0 or 1).

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization, e.g., “maximize” in this case.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the optimization problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          @@ -621,14 +900,21 @@

          Multi-modal Deceptive Problem (MMDP)# Length of chromosomes = 240 # Maximum Fitness Value = 40

          -
          -f(x: list) → float[source]
          +
          +__init__()[source]
          +

          Initializes the MMDP problem with predefined design variables, bounds, +objectives, and constraints.

          +
          + +
          +
          +f(x: List[int]) → float[source]

          Evaluates the fitness of a given chromosome for the MMDP.

          The fitness function is calculated based on the number of ones in each of the 40 subproblems, each of length 6.

          Parameters:
          -

          x (list) – A list representing the chromosome, where each element is a binary +

          x (List[int]) – A list representing the chromosome, where each element is a binary value (0 or 1).

          Returns:
          @@ -649,15 +935,54 @@

          One-Max Problem
          -class OneMax[source]
          +class OneMax(design_variables: int = 100, bounds: List[Tuple[float, float]] = [(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1)], objectives: List[str] = ['maximize'], constraints: List[str] = [])[source]

          Bases: AbstractProblem

          Represents the OneMax problem.

          The OneMax problem is a simple genetic algorithm benchmark problem where the fitness of a chromosome is the sum of its bits.

          -
          -None
          -
          +
          +design_variables
          +

          Number of design variables (chromosome length).

          +
          +
          Type:
          +

          int

          +
          +
          +
          + +
          +
          +bounds
          +

          Bounds for each design variable as (min, max).

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization, e.g., “maximize”.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the optimization problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          @@ -666,13 +991,30 @@

          One-Max Problem -
          -f(x) → float[source]
          +
          +__init__(design_variables: int = 100, bounds: List[Tuple[float, float]] = [(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1)], objectives: List[str] = ['maximize'], constraints: List[str] = [])[source]
          +

          Initialize the OneMax problem with default design variables, bounds, +objectives, and optional constraints.

          +
          +
          Parameters:
          +
            +

          • design_variables (int, optional) – Number of design variables (default is 100).

            • +

          • bounds (List[Tuple[float, float]], optional) – Bounds for each design variable in (min, max) format (default is [(0, 1)] * 100).

            • +

          • objectives (List[str], optional) – Objectives for optimization, e.g., “maximize” (default is [“maximize”]).

            • +

          • constraints (List[str], optional) – Constraints for the problem (default is an empty list).

            • +
          +
          +
          +

          + +
          +
          +f(x: List[int]) → float[source]

          Evaluates the fitness of a given chromosome for the OneMax problem.

          The fitness function is the sum of all bits in the chromosome.

          Parameters:
          -

          x (list) – A list representing the chromosome, where each element is a binary +

          x (List[int]) – A list representing the chromosome, where each element is a binary value (0 or 1).

          Returns:
          @@ -698,9 +1040,48 @@

          Peak ProblemThe Peak problem evaluates the fitness of a chromosome based on its distance to a set of target peaks.

          -
          -None
          -
          +
          +design_variables
          +

          Names of the design variables.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +

          + +
          +
          +bounds
          +

          Bounds for each design variable as (min, max).

          +
          +
          Type:
          +

          List[Tuple[float, float]]

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization, e.g., “minimize” or “maximize”.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          + +
          +
          +constraints
          +

          Any constraints for the optimization problem.

          +
          +
          Type:
          +

          List[str]

          +
          +
          +
          @@ -712,8 +1093,28 @@

          Peak Problem# Length of chromosomes = 100 # Maximum Fitness Value = 1.0

          -
          -f(x: list) → float[source]
          +
          +__init__()[source]
          +

          Initializes the Peak problem with default values.

          +
          + +
          +
          +evaluate(x, out, *args, **kwargs)[source]
          +

          Evaluate function for compatibility with pymoo’s optimizer.

          +
          +
          Parameters:
          +
            +

          • x (numpy.ndarray) – Array of input variables.

            • +

          • out (dict) – Dictionary to store the output fitness values.

            • +
          +
          +
          +
          + +
          +
          +f(x: List[int]) → float[source]

          Evaluates the fitness of a given chromosome for the Peak problem.

          The fitness function calculates the distance between the given chromosome and a set of randomly generated target peaks.

          diff --git a/pycellga.problems.single_objective.discrete.permutation.html b/pycellga.problems.single_objective.discrete.permutation.html index e651a10..072174d 100644 --- a/pycellga.problems.single_objective.discrete.permutation.html +++ b/pycellga.problems.single_objective.discrete.permutation.html @@ -344,16 +344,65 @@

          Traveling Salesman Problem (TSP)

          Bases: AbstractProblem

          Represents the Traveling Salesman Problem (TSP).

          This class solves the TSP using geographical distances (GEO) for node coordinates.

          +
          +
          +design_variables
          +

          Names of the design variables (nodes in this case).

          +
          +
          Type:
          +

          list

          +
          +
          +
          + +
          +
          +bounds
          +

          Bounds for each design variable as (min, max).

          +
          +
          Type:
          +

          list of tuples

          +
          +
          +
          + +
          +
          +objectives
          +

          Objectives for optimization, e.g., “minimize” or “maximize”.

          +
          +
          Type:
          +

          list

          +
          +
          +
          + +
          +
          +constraints
          +

          Constraints for the optimization problem.

          +
          +
          Type:
          +

          list

          +
          +
          +
          +

          Notes

          -

          #### burma14.tsp ######################################## -# EDGE_WEIGHT_TYPE: GEO, use gographical_dist function -# Length of chromosomes = 14 -# Known Best Route = [] -# Minumum Fitness Value = 3323 -#########################################################

          +
            +

          • Uses geographical distance function (GEO) for evaluating routes.

            • +

          • Example problem: burma14.tsp, with a known minimum distance.

            • +
          +
          +
          +__init__()[source]
          +

          Initialize the TSP problem with default attributes.

          +

          Uses the ‘burma14’ TSP dataset as an example with 14 nodes.

          +
          +
          -euclidean_dist(a: list, b: list) → float[source]
          +euclidean_dist(a: List[float], b: List[float]) → float[source]

          Computes the Euclidean distance between two nodes.

          Parameters:
          @@ -373,9 +422,8 @@

          Traveling Salesman Problem (TSP)
          -f(x: list) → float[source]
          +f(x: List[int]) → float[source]

          Evaluates the fitness of a given chromosome (route) for the TSP.

          -

          This method calculates the total distance of the given route using geographical distances.

          Parameters:

          x (list) – A list representing the route (chromosome), where each element is a node index.

          @@ -391,7 +439,7 @@

          Traveling Salesman Problem (TSP)
          -gographical_dist(a: list, b: list) → float[source]
          +gographical_dist(a: List[float], b: List[float]) → float[source]

          Computes the geographical distance between two nodes using the geodesic distance.

          Parameters:
          diff --git a/searchindex.js b/searchindex.js index 78d5717..236a231 100644 --- a/searchindex.js +++ b/searchindex.js @@ -1 +1 @@ -Search.setIndex({"alltitles": {"Abstract Problem Base": [[8, "abstract-problem-base"]], "Ackley Function": [[10, "ackley-function"]], "Arithmetic Crossover": [[14, "arithmetic-crossover"]], "Available Example Modules": [[5, "available-example-modules"]], "BLX-Alpha Crossover": [[14, "blx-alpha-crossover"]], "Bent Cigar Function": [[10, "bent-cigar-function"]], "Binary Optimization Problems": [[12, null]], "Binary-Based Problems": [[11, "binary-based-problems"]], "Bit Flip Mutation": [[6, "bit-flip-mutation"]], "Bohachevsky Function": [[10, "bohachevsky-function"]], "Byte One-Point Crossover": [[14, "byte-one-point-crossover"]], "Byte Operators": [[4, "byte-operators"]], "Byte Uniform Crossover": [[14, "byte-uniform-crossover"]], "Byte-Level Mutation": [[6, "byte-level-mutation"]], "Chichinadze Function": [[10, "chichinadze-function"]], "Citing": [[0, null]], "Coding Standards": [[1, "coding-standards"]], "Compact 13": [[7, "compact-13"]], "Compact 21": [[7, "compact-21"]], "Compact 25": [[7, "compact-25"]], "Compact 9": [[7, "compact-9"]], "Continuous Optimization Problems": [[9, "continuous-optimization-problems"], [10, null]], "Contributing": [[1, null]], "Core Modules": [[4, "core-modules"]], "Count SAT": [[12, "count-sat"]], "Development Setup": [[1, "development-setup"]], "Discrete Optimization Problems": [[9, "discrete-optimization-problems"], [11, null]], "Drop Wave Function": [[10, "drop-wave-function"]], "ECC Problem": [[12, "ecc-problem"]], "Example Implementations in pycellga": [[5, null]], "Example Problem": [[17, "example-problem"]], "ExampleProblem Class": [[17, "exampleproblem-class"]], "Flat Crossover": [[14, "flat-crossover"]], "Fletcher-Powell (FMS) Binary Problem": [[12, "fletcher-powell-fms-binary-problem"]], "Frequency Modulation Sound Function (FMS)": [[10, "frequency-modulation-sound-function-fms"]], "Grid Structure": [[4, "grid-structure"]], "Griewank Function": [[10, "griewank-function"]], "Holzman Function": [[10, "holzman-function"]], "Individual Representation": [[4, "individual-representation"]], "Insertion-Based Mutation": [[6, "insertion-based-mutation"]], "Installation": [[3, null]], "Installing from PyPI": [[3, "installing-from-pypi"]], "Installing from Source": [[3, "installing-from-source"]], "Levy Function": [[10, "levy-function"]], "Linear 5": [[7, "linear-5"]], "Linear 9": [[7, "linear-9"]], "Linear Crossover": [[14, "linear-crossover"]], "Matyas Function": [[10, "matyas-function"]], "Max-Cut (100 nodes)": [[12, "max-cut-100-nodes"]], "Max-Cut (20 nodes, Density 0.1)": [[12, "max-cut-20-nodes-density-0-1"]], "Max-Cut (20 nodes, Density 0.9)": [[12, "max-cut-20-nodes-density-0-9"]], "Multi-modal Deceptive Problem (MMDP)": [[12, "multi-modal-deceptive-problem-mmdp"]], "Mutation Operators": [[6, null]], "Neighborhood Operators": [[7, null]], "One-Max Problem": [[12, "one-max-problem"]], "One-Point Crossover": [[14, "one-point-crossover"]], "Optimizer": [[4, "optimizer"]], "Optional Dependencies": [[3, "optional-dependencies"]], "PYCELLGA Documentation": [[2, null]], "Partially Matched Crossover (PMX)": [[14, "partially-matched-crossover-pmx"]], "Peak Problem": [[12, "peak-problem"]], "Permutation-Based Optimization Problems": [[13, null]], "Permutation-Based Problems": [[11, "permutation-based-problems"]], "Population Management": [[4, "population-management"]], "Pow Function": [[10, "pow-function"]], "Powell Function": [[10, "powell-function"]], "Problem Definitions": [[8, null]], "Pull Request Guidelines": [[1, "pull-request-guidelines"]], "Randomized Byte Mutation": [[6, "randomized-byte-mutation"]], "Rastrigin Function": [[10, "rastrigin-function"]], "Recombination Operators": [[14, null]], "Requirements": [[3, "requirements"]], "Rosenbrock Function": [[10, "rosenbrock-function"]], "Rothellipsoid Function": [[10, "rothellipsoid-function"]], "Roulette Wheel Selection": [[15, "roulette-wheel-selection"]], "Running Tests": [[1, "running-tests"]], "Schaffer Function": [[10, "schaffer-function"]], "Schaffer2 Function": [[10, "schaffer2-function"]], "Schwefel Function": [[10, "schwefel-function"]], "Selection Operators": [[15, null]], "Shuffle Mutation": [[6, "shuffle-mutation"]], "Single-Objective Optimization Problems": [[9, null]], "Single-Objective Problems": [[8, "single-objective-problems"]], "Sphere Function": [[10, "sphere-function"]], "Styblinskitang Function": [[10, "styblinskitang-function"]], "Sumofdifferentpowers Function": [[10, "sumofdifferentpowers-function"]], "Swap Mutation": [[6, "swap-mutation"]], "Table of Contents :": [[2, null]], "Threehumps Function": [[10, "threehumps-function"]], "Tournament Selection": [[15, "tournament-selection"]], "Traveling Salesman Problem (TSP)": [[13, "traveling-salesman-problem-tsp"]], "Troubleshooting": [[3, "troubleshooting"]], "Two-Opt Mutation": [[6, "two-opt-mutation"]], "Two-Point Crossover": [[14, "two-point-crossover"]], "Unfair Average Crossover": [[14, "unfair-average-crossover"]], "Uniform Crossover": [[14, "uniform-crossover"]], "Uniform Float Mutation": [[6, "uniform-float-mutation"]], "Uninstallation": [[3, "uninstallation"]], "Usage": [[17, "usage"]], "Usage Examples": [[17, null]], "Verifying the Installation": [[3, "verifying-the-installation"]], "Ways to Contribute": [[1, "ways-to-contribute"]], "Zakharov Function": [[10, "zakharov-function"]], "Zettle Function": [[10, "zettle-function"]], "cga (Cellular Genetic Algorithm)": [[17, "cga-cellular-genetic-algorithm"]], "pycellga: A Comprehensive Guide": [[4, null]], "setup module": [[16, null]]}, "docnames": ["citing", "contributing", "index", "installation", "pycellga", "pycellga.example", "pycellga.mutation", "pycellga.neighborhoods", "pycellga.problems", "pycellga.problems.single_objective", "pycellga.problems.single_objective.continuous", "pycellga.problems.single_objective.discrete", "pycellga.problems.single_objective.discrete.binary", "pycellga.problems.single_objective.discrete.permutation", "pycellga.recombination", "pycellga.selection", "setup", "usage_examples"], "envversion": {"sphinx": 62, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.todo": 2, "sphinx.ext.viewcode": 1}, "filenames": ["citing.rst", "contributing.rst", "index.rst", "installation.rst", "pycellga.rst", "pycellga.example.rst", "pycellga.mutation.rst", "pycellga.neighborhoods.rst", "pycellga.problems.rst", "pycellga.problems.single_objective.rst", "pycellga.problems.single_objective.continuous.rst", "pycellga.problems.single_objective.discrete.rst", "pycellga.problems.single_objective.discrete.binary.rst", "pycellga.problems.single_objective.discrete.permutation.rst", "pycellga.recombination.rst", "pycellga.selection.rst", "setup.rst", "usage_examples.rst"], "indexentries": {"__init__() (arithmeticcrossover method)": [[14, "pycellga.recombination.arithmetic_crossover.ArithmeticCrossover.__init__", false]], "__init__() (bitflipmutation method)": [[6, "pycellga.mutation.bit_flip_mutation.BitFlipMutation.__init__", false]], "__init__() (blxalphacrossover method)": [[14, "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover.__init__", false]], "__init__() (bytemutation method)": [[6, "pycellga.mutation.byte_mutation.ByteMutation.__init__", false]], "__init__() (bytemutationrandom method)": [[6, "pycellga.mutation.byte_mutation_random.ByteMutationRandom.__init__", false]], "__init__() (byteonepointcrossover method)": [[14, "pycellga.recombination.byte_one_point_crossover.ByteOnePointCrossover.__init__", false]], "__init__() (byteuniformcrossover method)": [[14, "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover.__init__", false]], "__init__() (compact13 method)": [[7, "pycellga.neighborhoods.compact_13.Compact13.__init__", false]], "__init__() (compact21 method)": [[7, "pycellga.neighborhoods.compact_21.Compact21.__init__", false]], "__init__() (compact25 method)": [[7, "pycellga.neighborhoods.compact_25.Compact25.__init__", false]], "__init__() (compact9 method)": [[7, "pycellga.neighborhoods.compact_9.Compact9.__init__", false]], "__init__() (exampleproblem method)": [[5, "pycellga.example.example_alpha_cga.ExampleProblem.__init__", false], [5, "pycellga.example.example_ccga.ExampleProblem.__init__", false], [5, "pycellga.example.example_cga.ExampleProblem.__init__", false], [5, "pycellga.example.example_sync_cga.ExampleProblem.__init__", false]], "__init__() (flatcrossover method)": [[14, "pycellga.recombination.flat_crossover.FlatCrossover.__init__", false]], "__init__() (floatuniformmutation method)": [[6, "pycellga.mutation.float_uniform_mutation.FloatUniformMutation.__init__", false]], "__init__() (grid method)": [[4, "pycellga.grid.Grid.__init__", false]], "__init__() (individual method)": [[4, "pycellga.individual.Individual.__init__", false]], "__init__() (insertionmutation method)": [[6, "pycellga.mutation.insertion_mutation.InsertionMutation.__init__", false]], "__init__() (linear5 method)": [[7, "pycellga.neighborhoods.linear_5.Linear5.__init__", false]], "__init__() (linear9 method)": [[7, "pycellga.neighborhoods.linear_9.Linear9.__init__", false]], "__init__() (linearcrossover method)": [[14, "pycellga.recombination.linear_crossover.LinearCrossover.__init__", false]], "__init__() (onepointcrossover method)": [[14, "pycellga.recombination.one_point_crossover.OnePointCrossover.__init__", false]], "__init__() (pmxcrossover method)": [[14, "pycellga.recombination.pmx_crossover.PMXCrossover.__init__", false]], "__init__() (population method)": [[4, "pycellga.population.Population.__init__", false]], "__init__() (realproblem method)": [[5, "pycellga.example.example_mcccga.RealProblem.__init__", false]], "__init__() (roulettewheelselection method)": [[15, "pycellga.selection.roulette_wheel_selection.RouletteWheelSelection.__init__", false]], "__init__() (shufflemutation method)": [[6, "pycellga.mutation.shuffle_mutation.ShuffleMutation.__init__", false]], "__init__() (swapmutation method)": [[6, "pycellga.mutation.swap_mutation.SwapMutation.__init__", false]], "__init__() (tournamentselection method)": [[15, "pycellga.selection.tournament_selection.TournamentSelection.__init__", false]], "__init__() (twooptmutation method)": [[6, "pycellga.mutation.two_opt_mutation.TwoOptMutation.__init__", false]], "__init__() (twopointcrossover method)": [[14, "pycellga.recombination.two_point_crossover.TwoPointCrossover.__init__", false]], "__init__() (unfairavaragecrossover method)": [[14, "pycellga.recombination.unfair_avarage_crossover.UnfairAvarageCrossover.__init__", false]], "__init__() (uniformcrossover method)": [[14, "pycellga.recombination.uniform_crossover.UniformCrossover.__init__", false]], "abstractproblem (class in pycellga.problems.abstract_problem)": [[8, "pycellga.problems.abstract_problem.AbstractProblem", false]], "ackley (class in pycellga.problems.single_objective.continuous.ackley)": [[10, "pycellga.problems.single_objective.continuous.ackley.Ackley", false]], "alpha_cga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.ALPHA_CGA", false]], "alpha_cga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.alpha_cga", false]], "arithmeticcrossover (class in pycellga.recombination.arithmetic_crossover)": [[14, "pycellga.recombination.arithmetic_crossover.ArithmeticCrossover", false]], "bentcigar (class in pycellga.problems.single_objective.continuous.bentcigar)": [[10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar", false]], "binary (genetype attribute)": [[4, "pycellga.individual.GeneType.BINARY", false]], "bitflipmutation (class in pycellga.mutation.bit_flip_mutation)": [[6, "pycellga.mutation.bit_flip_mutation.BitFlipMutation", false]], "bits_to_float() (in module pycellga.byte_operators)": [[4, "pycellga.byte_operators.bits_to_float", false]], "bits_to_floats() (in module pycellga.byte_operators)": [[4, "pycellga.byte_operators.bits_to_floats", false]], "blxalphacrossover (class in pycellga.recombination.blxalpha_crossover)": [[14, "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover", false]], "bohachevsky (class in pycellga.problems.single_objective.continuous.bohachevsky)": [[10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky", false]], "bytemutation (class in pycellga.mutation.byte_mutation)": [[6, "pycellga.mutation.byte_mutation.ByteMutation", false]], "bytemutationrandom (class in pycellga.mutation.byte_mutation_random)": [[6, "pycellga.mutation.byte_mutation_random.ByteMutationRandom", false]], "byteonepointcrossover (class in pycellga.recombination.byte_one_point_crossover)": [[14, "pycellga.recombination.byte_one_point_crossover.ByteOnePointCrossover", false]], "byteuniformcrossover (class in pycellga.recombination.byte_uniform_crossover)": [[14, "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover", false]], "calculate_neighbors_positions() (compact13 method)": [[7, "pycellga.neighborhoods.compact_13.Compact13.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (compact21 method)": [[7, "pycellga.neighborhoods.compact_21.Compact21.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (compact25 method)": [[7, "pycellga.neighborhoods.compact_25.Compact25.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (compact9 method)": [[7, "pycellga.neighborhoods.compact_9.Compact9.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (linear5 method)": [[7, "pycellga.neighborhoods.linear_5.Linear5.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (linear9 method)": [[7, "pycellga.neighborhoods.linear_9.Linear9.calculate_neighbors_positions", false]], "ccga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.CCGA", false]], "ccga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.ccga", false]], "cga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.CGA", false]], "cga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.cga", false]], "ch_size (individual attribute)": [[4, "pycellga.individual.Individual.ch_size", false]], "ch_size (population attribute)": [[4, "pycellga.population.Population.ch_size", false]], "chichinadze (class in pycellga.problems.single_objective.continuous.chichinadze)": [[10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze", false]], "chromosome (individual attribute)": [[4, "pycellga.individual.Individual.chromosome", false]], "combine() (blxalphacrossover method)": [[14, "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover.combine", false]], "combine() (byteuniformcrossover method)": [[14, "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover.combine", false]], "combine() (flatcrossover method)": [[14, "pycellga.recombination.flat_crossover.FlatCrossover.combine", false]], "combine() (linearcrossover method)": [[14, "pycellga.recombination.linear_crossover.LinearCrossover.combine", false]], "combine() (uniformcrossover method)": [[14, "pycellga.recombination.uniform_crossover.UniformCrossover.combine", false]], "compact13 (class in pycellga.neighborhoods.compact_13)": [[7, "pycellga.neighborhoods.compact_13.Compact13", false]], "compact21 (class in pycellga.neighborhoods.compact_21)": [[7, "pycellga.neighborhoods.compact_21.Compact21", false]], "compact25 (class in pycellga.neighborhoods.compact_25)": [[7, "pycellga.neighborhoods.compact_25.Compact25", false]], "compact9 (class in pycellga.neighborhoods.compact_9)": [[7, "pycellga.neighborhoods.compact_9.Compact9", false]], "compete() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.compete", false]], "countsat (class in pycellga.problems.single_objective.discrete.binary.count_sat)": [[12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat", false]], "dropwave (class in pycellga.problems.single_objective.continuous.dropwave)": [[10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave", false]], "ecc (class in pycellga.problems.single_objective.discrete.binary.ecc)": [[12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc", false]], "euclidean_dist() (tsp method)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.euclidean_dist", false]], "exampleproblem (class in pycellga.example.example_alpha_cga)": [[5, "pycellga.example.example_alpha_cga.ExampleProblem", false]], "exampleproblem (class in pycellga.example.example_ccga)": [[5, "pycellga.example.example_ccga.ExampleProblem", false]], "exampleproblem (class in pycellga.example.example_cga)": [[5, "pycellga.example.example_cga.ExampleProblem", false]], "exampleproblem (class in pycellga.example.example_sync_cga)": [[5, "pycellga.example.example_sync_cga.ExampleProblem", false]], "f() (abstractproblem method)": [[8, "id0", false], [8, "pycellga.problems.abstract_problem.AbstractProblem.f", false]], "f() (ackley method)": [[10, "id0", false], [10, "pycellga.problems.single_objective.continuous.ackley.Ackley.f", false]], "f() (bentcigar method)": [[10, "id1", false], [10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.f", false]], "f() (bohachevsky method)": [[10, "id2", false], [10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.f", false]], "f() (chichinadze method)": [[10, "id3", false], [10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.f", false]], "f() (countsat method)": [[12, "id0", false], [12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat.f", false]], "f() (dropwave method)": [[10, "id4", false], [10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave.f", false]], "f() (ecc method)": [[12, "id1", false], [12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc.f", false]], "f() (exampleproblem method)": [[5, "pycellga.example.example_alpha_cga.ExampleProblem.f", false], [5, "pycellga.example.example_ccga.ExampleProblem.f", false], [5, "pycellga.example.example_cga.ExampleProblem.f", false], [5, "pycellga.example.example_sync_cga.ExampleProblem.f", false]], "f() (fms method)": [[10, "id5", false], [10, "pycellga.problems.single_objective.continuous.fms.Fms.f", false], [12, "id2", false], [12, "pycellga.problems.single_objective.discrete.binary.fms.Fms.f", false]], "f() (griewank method)": [[10, "id6", false], [10, "pycellga.problems.single_objective.continuous.griewank.Griewank.f", false]], "f() (holzman method)": [[10, "id7", false], [10, "pycellga.problems.single_objective.continuous.holzman.Holzman.f", false]], "f() (levy method)": [[10, "id8", false], [10, "pycellga.problems.single_objective.continuous.levy.Levy.f", false]], "f() (matyas method)": [[10, "id9", false], [10, "pycellga.problems.single_objective.continuous.matyas.Matyas.f", false]], "f() (maxcut100 method)": [[12, "id3", false], [12, "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100.f", false]], "f() (maxcut20_01 method)": [[12, "id4", false], [12, "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01.f", false]], "f() (maxcut20_09 method)": [[12, "id5", false], [12, "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09.f", false]], "f() (mmdp method)": [[12, "id6", false], [12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp.f", false]], "f() (onemax method)": [[12, "id7", false], [12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax.f", false]], "f() (peak method)": [[12, "id8", false], [12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.f", false]], "f() (pow method)": [[10, "id10", false], [10, "pycellga.problems.single_objective.continuous.pow.Pow.f", false]], "f() (powell method)": [[10, "id11", false], [10, "pycellga.problems.single_objective.continuous.powell.Powell.f", false]], "f() (rastrigin method)": [[10, "id12", false], [10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin.f", false]], "f() (realproblem method)": [[5, "pycellga.example.example_mcccga.RealProblem.f", false]], "f() (rosenbrock method)": [[10, "id13", false], [10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock.f", false]], "f() (rothellipsoid method)": [[10, "id14", false], [10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid.f", false]], "f() (schaffer method)": [[10, "id15", false], [10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer.f", false]], "f() (schaffer2 method)": [[10, "id16", false], [10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2.f", false]], "f() (schwefel method)": [[10, "id17", false], [10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel.f", false]], "f() (sphere method)": [[10, "id18", false], [10, "pycellga.problems.single_objective.continuous.sphere.Sphere.f", false]], "f() (styblinskitang method)": [[10, "id19", false], [10, "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang.f", false]], "f() (sumofdifferentpowers method)": [[10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers.f", false]], "f() (threehumps method)": [[10, "id20", false], [10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps.f", false]], "f() (tsp method)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.f", false]], "f() (zakharov method)": [[10, "id21", false], [10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov.f", false]], "f() (zettle method)": [[10, "id22", false], [10, "pycellga.problems.single_objective.continuous.zettle.Zettle.f", false]], "fitness_value (individual attribute)": [[4, "pycellga.individual.Individual.fitness_value", false]], "flatcrossover (class in pycellga.recombination.flat_crossover)": [[14, "pycellga.recombination.flat_crossover.FlatCrossover", false]], "float_to_bits() (in module pycellga.byte_operators)": [[4, "pycellga.byte_operators.float_to_bits", false]], "floats_to_bits() (in module pycellga.byte_operators)": [[4, "pycellga.byte_operators.floats_to_bits", false]], "floatuniformmutation (class in pycellga.mutation.float_uniform_mutation)": [[6, "pycellga.mutation.float_uniform_mutation.FloatUniformMutation", false]], "fms (class in pycellga.problems.single_objective.continuous.fms)": [[10, "pycellga.problems.single_objective.continuous.fms.Fms", false]], "fms (class in pycellga.problems.single_objective.discrete.binary.fms)": [[12, "pycellga.problems.single_objective.discrete.binary.fms.Fms", false]], "gen_type (individual attribute)": [[4, "pycellga.individual.Individual.gen_type", false]], "gen_type (population attribute)": [[4, "pycellga.population.Population.gen_type", false]], "generate_candidate() (individual method)": [[4, "pycellga.individual.Individual.generate_candidate", false]], "generate_probability_vector() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.generate_probability_vector", false]], "genetype (class in pycellga.individual)": [[4, "pycellga.individual.GeneType", false]], "get_parents() (roulettewheelselection method)": [[15, "pycellga.selection.roulette_wheel_selection.RouletteWheelSelection.get_parents", false]], "get_parents() (tournamentselection method)": [[15, "pycellga.selection.tournament_selection.TournamentSelection.get_parents", false]], "get_recombinations() (arithmeticcrossover method)": [[14, "pycellga.recombination.arithmetic_crossover.ArithmeticCrossover.get_recombinations", false]], "get_recombinations() (blxalphacrossover method)": [[14, "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover.get_recombinations", false]], "get_recombinations() (byteonepointcrossover method)": [[14, "pycellga.recombination.byte_one_point_crossover.ByteOnePointCrossover.get_recombinations", false]], "get_recombinations() (byteuniformcrossover method)": [[14, "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover.get_recombinations", false]], "get_recombinations() (flatcrossover method)": [[14, "pycellga.recombination.flat_crossover.FlatCrossover.get_recombinations", false]], "get_recombinations() (linearcrossover method)": [[14, "pycellga.recombination.linear_crossover.LinearCrossover.get_recombinations", false]], "get_recombinations() (onepointcrossover method)": [[14, "pycellga.recombination.one_point_crossover.OnePointCrossover.get_recombinations", false]], "get_recombinations() (pmxcrossover method)": [[14, "pycellga.recombination.pmx_crossover.PMXCrossover.get_recombinations", false]], "get_recombinations() (twopointcrossover method)": [[14, "pycellga.recombination.two_point_crossover.TwoPointCrossover.get_recombinations", false]], "get_recombinations() (unfairavaragecrossover method)": [[14, "pycellga.recombination.unfair_avarage_crossover.UnfairAvarageCrossover.get_recombinations", false]], "get_recombinations() (uniformcrossover method)": [[14, "pycellga.recombination.uniform_crossover.UniformCrossover.get_recombinations", false]], "getneighbors() (individual method)": [[4, "pycellga.individual.Individual.getneighbors", false]], "getneighbors_positions() (individual method)": [[4, "pycellga.individual.Individual.getneighbors_positions", false]], "gographical_dist() (tsp method)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.gographical_dist", false]], "grid (class in pycellga.grid)": [[4, "pycellga.grid.Grid", false]], "griewank (class in pycellga.problems.single_objective.continuous.griewank)": [[10, "pycellga.problems.single_objective.continuous.griewank.Griewank", false]], "holzman (class in pycellga.problems.single_objective.continuous.holzman)": [[10, "pycellga.problems.single_objective.continuous.holzman.Holzman", false]], "individual (class in pycellga.individual)": [[4, "pycellga.individual.Individual", false]], "initial_population() (population method)": [[4, "pycellga.population.Population.initial_population", false]], "insertionmutation (class in pycellga.mutation.insertion_mutation)": [[6, "pycellga.mutation.insertion_mutation.InsertionMutation", false]], "levy (class in pycellga.problems.single_objective.continuous.levy)": [[10, "pycellga.problems.single_objective.continuous.levy.Levy", false]], "linear5 (class in pycellga.neighborhoods.linear_5)": [[7, "pycellga.neighborhoods.linear_5.Linear5", false]], "linear9 (class in pycellga.neighborhoods.linear_9)": [[7, "pycellga.neighborhoods.linear_9.Linear9", false]], "linearcrossover (class in pycellga.recombination.linear_crossover)": [[14, "pycellga.recombination.linear_crossover.LinearCrossover", false]], "make_2d_grid() (grid method)": [[4, "pycellga.grid.Grid.make_2d_grid", false]], "matyas (class in pycellga.problems.single_objective.continuous.matyas)": [[10, "pycellga.problems.single_objective.continuous.matyas.Matyas", false]], "maxcut100 (class in pycellga.problems.single_objective.discrete.binary.maxcut100)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100", false]], "maxcut20_01 (class in pycellga.problems.single_objective.discrete.binary.maxcut20_01)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01", false]], "maxcut20_09 (class in pycellga.problems.single_objective.discrete.binary.maxcut20_09)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09", false]], "mcccga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.MCCCGA", false]], "mcccga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.mcccga", false]], "method_name (population attribute)": [[4, "pycellga.population.Population.method_name", false]], "mmdp (class in pycellga.problems.single_objective.discrete.binary.mmdp)": [[12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp", false]], "module": [[4, "module-pycellga.byte_operators", false], [4, "module-pycellga.grid", false], [4, "module-pycellga.individual", false], [4, "module-pycellga.optimizer", false], [4, "module-pycellga.population", false], [5, "module-pycellga.example", false], [5, "module-pycellga.example.example_alpha_cga", false], [5, "module-pycellga.example.example_ccga", false], [5, "module-pycellga.example.example_cga", false], [5, "module-pycellga.example.example_mcccga", false], [5, "module-pycellga.example.example_sync_cga", false], [6, "module-pycellga.mutation.bit_flip_mutation", false], [6, "module-pycellga.mutation.byte_mutation", false], [6, "module-pycellga.mutation.byte_mutation_random", false], [6, "module-pycellga.mutation.float_uniform_mutation", false], [6, "module-pycellga.mutation.insertion_mutation", false], [6, "module-pycellga.mutation.shuffle_mutation", false], [6, "module-pycellga.mutation.swap_mutation", false], [6, "module-pycellga.mutation.two_opt_mutation", false], [7, "module-pycellga.neighborhoods.compact_13", false], [7, "module-pycellga.neighborhoods.compact_21", false], [7, "module-pycellga.neighborhoods.compact_25", false], [7, "module-pycellga.neighborhoods.compact_9", false], [7, "module-pycellga.neighborhoods.linear_5", false], [7, "module-pycellga.neighborhoods.linear_9", false], [8, "module-pycellga.problems.abstract_problem", false], [10, "module-pycellga.problems.single_objective.continuous.ackley", false], [10, "module-pycellga.problems.single_objective.continuous.bentcigar", false], [10, "module-pycellga.problems.single_objective.continuous.bohachevsky", false], [10, "module-pycellga.problems.single_objective.continuous.chichinadze", false], [10, "module-pycellga.problems.single_objective.continuous.dropwave", false], [10, "module-pycellga.problems.single_objective.continuous.fms", false], [10, "module-pycellga.problems.single_objective.continuous.griewank", false], [10, "module-pycellga.problems.single_objective.continuous.holzman", false], [10, "module-pycellga.problems.single_objective.continuous.levy", false], [10, "module-pycellga.problems.single_objective.continuous.matyas", false], [10, "module-pycellga.problems.single_objective.continuous.pow", false], [10, "module-pycellga.problems.single_objective.continuous.powell", false], [10, "module-pycellga.problems.single_objective.continuous.rastrigin", false], [10, "module-pycellga.problems.single_objective.continuous.rosenbrock", false], [10, "module-pycellga.problems.single_objective.continuous.rothellipsoid", false], [10, "module-pycellga.problems.single_objective.continuous.schaffer", false], [10, "module-pycellga.problems.single_objective.continuous.schaffer2", false], [10, "module-pycellga.problems.single_objective.continuous.schwefel", false], [10, "module-pycellga.problems.single_objective.continuous.sphere", false], [10, "module-pycellga.problems.single_objective.continuous.styblinskitang", false], [10, "module-pycellga.problems.single_objective.continuous.sumofdifferentpowers", false], [10, "module-pycellga.problems.single_objective.continuous.threehumps", false], [10, "module-pycellga.problems.single_objective.continuous.zakharov", false], [10, "module-pycellga.problems.single_objective.continuous.zettle", false], [12, "module-pycellga.problems.single_objective.discrete.binary.count_sat", false], [12, "module-pycellga.problems.single_objective.discrete.binary.ecc", false], [12, "module-pycellga.problems.single_objective.discrete.binary.fms", false], [12, "module-pycellga.problems.single_objective.discrete.binary.maxcut100", false], [12, "module-pycellga.problems.single_objective.discrete.binary.maxcut20_01", false], [12, "module-pycellga.problems.single_objective.discrete.binary.maxcut20_09", false], [12, "module-pycellga.problems.single_objective.discrete.binary.mmdp", false], [12, "module-pycellga.problems.single_objective.discrete.binary.one_max", false], [12, "module-pycellga.problems.single_objective.discrete.binary.peak", false], [13, "module-pycellga.problems.single_objective.discrete.permutation.tsp", false], [14, "module-pycellga.recombination.arithmetic_crossover", false], [14, "module-pycellga.recombination.blxalpha_crossover", false], [14, "module-pycellga.recombination.byte_one_point_crossover", false], [14, "module-pycellga.recombination.byte_uniform_crossover", false], [14, "module-pycellga.recombination.flat_crossover", false], [14, "module-pycellga.recombination.linear_crossover", false], [14, "module-pycellga.recombination.one_point_crossover", false], [14, "module-pycellga.recombination.pmx_crossover", false], [14, "module-pycellga.recombination.two_point_crossover", false], [14, "module-pycellga.recombination.unfair_avarage_crossover", false], [14, "module-pycellga.recombination.uniform_crossover", false], [15, "module-pycellga.selection.roulette_wheel_selection", false], [15, "module-pycellga.selection.tournament_selection", false]], "mutate() (bitflipmutation method)": [[6, "pycellga.mutation.bit_flip_mutation.BitFlipMutation.mutate", false]], "mutate() (bytemutation method)": [[6, "pycellga.mutation.byte_mutation.ByteMutation.mutate", false]], "mutate() (bytemutationrandom method)": [[6, "pycellga.mutation.byte_mutation_random.ByteMutationRandom.mutate", false]], "mutate() (floatuniformmutation method)": [[6, "pycellga.mutation.float_uniform_mutation.FloatUniformMutation.mutate", false]], "mutate() (insertionmutation method)": [[6, "pycellga.mutation.insertion_mutation.InsertionMutation.mutate", false]], "mutate() (shufflemutation method)": [[6, "pycellga.mutation.shuffle_mutation.ShuffleMutation.mutate", false]], "mutate() (swapmutation method)": [[6, "pycellga.mutation.swap_mutation.SwapMutation.mutate", false]], "mutate() (twooptmutation method)": [[6, "pycellga.mutation.two_opt_mutation.TwoOptMutation.mutate", false]], "n_cols (grid attribute)": [[4, "pycellga.grid.Grid.n_cols", false]], "n_cols (population attribute)": [[4, "pycellga.population.Population.n_cols", false]], "n_rows (grid attribute)": [[4, "pycellga.grid.Grid.n_rows", false]], "n_rows (population attribute)": [[4, "pycellga.population.Population.n_rows", false]], "neighbors (individual attribute)": [[4, "pycellga.individual.Individual.neighbors", false]], "neighbors_positions (individual attribute)": [[4, "pycellga.individual.Individual.neighbors_positions", false]], "none (ackley attribute)": [[10, "pycellga.problems.single_objective.continuous.ackley.Ackley.None", false]], "none (bentcigar attribute)": [[10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.None", false]], "none (bohachevsky attribute)": [[10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.None", false]], "none (chichinadze attribute)": [[10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.None", false]], "none (countsat attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat.None", false]], "none (ecc attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc.None", false]], "none (fms attribute)": [[10, "pycellga.problems.single_objective.continuous.fms.Fms.None", false], [12, "pycellga.problems.single_objective.discrete.binary.fms.Fms.None", false]], "none (holzman attribute)": [[10, "pycellga.problems.single_objective.continuous.holzman.Holzman.None", false]], "none (levy attribute)": [[10, "pycellga.problems.single_objective.continuous.levy.Levy.None", false]], "none (matyas attribute)": [[10, "pycellga.problems.single_objective.continuous.matyas.Matyas.None", false]], "none (maxcut100 attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100.None", false]], "none (maxcut20_01 attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01.None", false]], "none (maxcut20_09 attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09.None", false]], "none (mmdp attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp.None", false]], "none (onemax attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax.None", false]], "none (peak attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.None", false]], "none (pow attribute)": [[10, "pycellga.problems.single_objective.continuous.pow.Pow.None", false]], "none (powell attribute)": [[10, "pycellga.problems.single_objective.continuous.powell.Powell.None", false]], "none (rastrigin attribute)": [[10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin.None", false]], "none (rosenbrock attribute)": [[10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock.None", false]], "none (rothellipsoid attribute)": [[10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid.None", false]], "none (schaffer2 attribute)": [[10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2.None", false]], "none (schwefel attribute)": [[10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel.None", false]], "none (sphere attribute)": [[10, "pycellga.problems.single_objective.continuous.sphere.Sphere.None", false]], "none (styblinskitang attribute)": [[10, "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang.None", false]], "none (threehumps attribute)": [[10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps.None", false]], "none (zakharov attribute)": [[10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov.None", false]], "none (zettle attribute)": [[10, "pycellga.problems.single_objective.continuous.zettle.Zettle.None", false]], "onemax (class in pycellga.problems.single_objective.discrete.binary.one_max)": [[12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax", false]], "onepointcrossover (class in pycellga.recombination.one_point_crossover)": [[14, "pycellga.recombination.one_point_crossover.OnePointCrossover", false]], "optimizationmethod (class in pycellga.population)": [[4, "pycellga.population.OptimizationMethod", false]], "peak (class in pycellga.problems.single_objective.discrete.binary.peak)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak", false]], "permutation (genetype attribute)": [[4, "pycellga.individual.GeneType.PERMUTATION", false]], "pmxcrossover (class in pycellga.recombination.pmx_crossover)": [[14, "pycellga.recombination.pmx_crossover.PMXCrossover", false]], "population (class in pycellga.population)": [[4, "pycellga.population.Population", false]], "position (individual attribute)": [[4, "pycellga.individual.Individual.position", false]], "pow (class in pycellga.problems.single_objective.continuous.pow)": [[10, "pycellga.problems.single_objective.continuous.pow.Pow", false]], "powell (class in pycellga.problems.single_objective.continuous.powell)": [[10, "pycellga.problems.single_objective.continuous.powell.Powell", false]], "problem (population attribute)": [[4, "pycellga.population.Population.problem", false]], "pycellga.byte_operators": [[4, "module-pycellga.byte_operators", false]], "pycellga.example": [[5, "module-pycellga.example", false]], "pycellga.example.example_alpha_cga": [[5, "module-pycellga.example.example_alpha_cga", false]], "pycellga.example.example_ccga": [[5, "module-pycellga.example.example_ccga", false]], "pycellga.example.example_cga": [[5, "module-pycellga.example.example_cga", false]], "pycellga.example.example_mcccga": [[5, "module-pycellga.example.example_mcccga", false]], "pycellga.example.example_sync_cga": [[5, "module-pycellga.example.example_sync_cga", false]], "pycellga.grid": [[4, "module-pycellga.grid", false]], "pycellga.individual": [[4, "module-pycellga.individual", false]], "pycellga.mutation.bit_flip_mutation": [[6, "module-pycellga.mutation.bit_flip_mutation", false]], "pycellga.mutation.byte_mutation": [[6, "module-pycellga.mutation.byte_mutation", false]], "pycellga.mutation.byte_mutation_random": [[6, "module-pycellga.mutation.byte_mutation_random", false]], "pycellga.mutation.float_uniform_mutation": [[6, "module-pycellga.mutation.float_uniform_mutation", false]], "pycellga.mutation.insertion_mutation": [[6, "module-pycellga.mutation.insertion_mutation", false]], "pycellga.mutation.shuffle_mutation": [[6, "module-pycellga.mutation.shuffle_mutation", false]], "pycellga.mutation.swap_mutation": [[6, "module-pycellga.mutation.swap_mutation", false]], "pycellga.mutation.two_opt_mutation": [[6, "module-pycellga.mutation.two_opt_mutation", false]], "pycellga.neighborhoods.compact_13": [[7, "module-pycellga.neighborhoods.compact_13", false]], "pycellga.neighborhoods.compact_21": [[7, "module-pycellga.neighborhoods.compact_21", false]], "pycellga.neighborhoods.compact_25": [[7, "module-pycellga.neighborhoods.compact_25", false]], "pycellga.neighborhoods.compact_9": [[7, "module-pycellga.neighborhoods.compact_9", false]], "pycellga.neighborhoods.linear_5": [[7, "module-pycellga.neighborhoods.linear_5", false]], "pycellga.neighborhoods.linear_9": [[7, "module-pycellga.neighborhoods.linear_9", false]], "pycellga.optimizer": [[4, "module-pycellga.optimizer", false]], "pycellga.population": [[4, "module-pycellga.population", false]], "pycellga.problems.abstract_problem": [[8, "module-pycellga.problems.abstract_problem", false]], "pycellga.problems.single_objective.continuous.ackley": [[10, "module-pycellga.problems.single_objective.continuous.ackley", false]], "pycellga.problems.single_objective.continuous.bentcigar": [[10, "module-pycellga.problems.single_objective.continuous.bentcigar", false]], "pycellga.problems.single_objective.continuous.bohachevsky": [[10, "module-pycellga.problems.single_objective.continuous.bohachevsky", false]], "pycellga.problems.single_objective.continuous.chichinadze": [[10, "module-pycellga.problems.single_objective.continuous.chichinadze", false]], "pycellga.problems.single_objective.continuous.dropwave": [[10, "module-pycellga.problems.single_objective.continuous.dropwave", false]], "pycellga.problems.single_objective.continuous.fms": [[10, "module-pycellga.problems.single_objective.continuous.fms", false]], "pycellga.problems.single_objective.continuous.griewank": [[10, "module-pycellga.problems.single_objective.continuous.griewank", false]], "pycellga.problems.single_objective.continuous.holzman": [[10, "module-pycellga.problems.single_objective.continuous.holzman", false]], "pycellga.problems.single_objective.continuous.levy": [[10, "module-pycellga.problems.single_objective.continuous.levy", false]], "pycellga.problems.single_objective.continuous.matyas": [[10, "module-pycellga.problems.single_objective.continuous.matyas", false]], "pycellga.problems.single_objective.continuous.pow": [[10, "module-pycellga.problems.single_objective.continuous.pow", false]], "pycellga.problems.single_objective.continuous.powell": [[10, "module-pycellga.problems.single_objective.continuous.powell", false]], "pycellga.problems.single_objective.continuous.rastrigin": [[10, "module-pycellga.problems.single_objective.continuous.rastrigin", false]], "pycellga.problems.single_objective.continuous.rosenbrock": [[10, "module-pycellga.problems.single_objective.continuous.rosenbrock", false]], "pycellga.problems.single_objective.continuous.rothellipsoid": [[10, "module-pycellga.problems.single_objective.continuous.rothellipsoid", false]], "pycellga.problems.single_objective.continuous.schaffer": [[10, "module-pycellga.problems.single_objective.continuous.schaffer", false]], "pycellga.problems.single_objective.continuous.schaffer2": [[10, "module-pycellga.problems.single_objective.continuous.schaffer2", false]], "pycellga.problems.single_objective.continuous.schwefel": [[10, "module-pycellga.problems.single_objective.continuous.schwefel", false]], "pycellga.problems.single_objective.continuous.sphere": [[10, "module-pycellga.problems.single_objective.continuous.sphere", false]], "pycellga.problems.single_objective.continuous.styblinskitang": [[10, "module-pycellga.problems.single_objective.continuous.styblinskitang", false]], "pycellga.problems.single_objective.continuous.sumofdifferentpowers": [[10, "module-pycellga.problems.single_objective.continuous.sumofdifferentpowers", false]], "pycellga.problems.single_objective.continuous.threehumps": [[10, "module-pycellga.problems.single_objective.continuous.threehumps", false]], "pycellga.problems.single_objective.continuous.zakharov": [[10, "module-pycellga.problems.single_objective.continuous.zakharov", false]], "pycellga.problems.single_objective.continuous.zettle": [[10, "module-pycellga.problems.single_objective.continuous.zettle", false]], "pycellga.problems.single_objective.discrete.binary.count_sat": [[12, "module-pycellga.problems.single_objective.discrete.binary.count_sat", false]], "pycellga.problems.single_objective.discrete.binary.ecc": [[12, "module-pycellga.problems.single_objective.discrete.binary.ecc", false]], "pycellga.problems.single_objective.discrete.binary.fms": [[12, "module-pycellga.problems.single_objective.discrete.binary.fms", false]], "pycellga.problems.single_objective.discrete.binary.maxcut100": [[12, "module-pycellga.problems.single_objective.discrete.binary.maxcut100", false]], "pycellga.problems.single_objective.discrete.binary.maxcut20_01": [[12, "module-pycellga.problems.single_objective.discrete.binary.maxcut20_01", false]], "pycellga.problems.single_objective.discrete.binary.maxcut20_09": [[12, "module-pycellga.problems.single_objective.discrete.binary.maxcut20_09", false]], "pycellga.problems.single_objective.discrete.binary.mmdp": [[12, "module-pycellga.problems.single_objective.discrete.binary.mmdp", false]], "pycellga.problems.single_objective.discrete.binary.one_max": [[12, "module-pycellga.problems.single_objective.discrete.binary.one_max", false]], "pycellga.problems.single_objective.discrete.binary.peak": [[12, "module-pycellga.problems.single_objective.discrete.binary.peak", false]], "pycellga.problems.single_objective.discrete.permutation.tsp": [[13, "module-pycellga.problems.single_objective.discrete.permutation.tsp", false]], "pycellga.recombination.arithmetic_crossover": [[14, "module-pycellga.recombination.arithmetic_crossover", false]], "pycellga.recombination.blxalpha_crossover": [[14, "module-pycellga.recombination.blxalpha_crossover", false]], "pycellga.recombination.byte_one_point_crossover": [[14, "module-pycellga.recombination.byte_one_point_crossover", false]], "pycellga.recombination.byte_uniform_crossover": [[14, "module-pycellga.recombination.byte_uniform_crossover", false]], "pycellga.recombination.flat_crossover": [[14, "module-pycellga.recombination.flat_crossover", false]], "pycellga.recombination.linear_crossover": [[14, "module-pycellga.recombination.linear_crossover", false]], "pycellga.recombination.one_point_crossover": [[14, "module-pycellga.recombination.one_point_crossover", false]], "pycellga.recombination.pmx_crossover": [[14, "module-pycellga.recombination.pmx_crossover", false]], "pycellga.recombination.two_point_crossover": [[14, "module-pycellga.recombination.two_point_crossover", false]], "pycellga.recombination.unfair_avarage_crossover": [[14, "module-pycellga.recombination.unfair_avarage_crossover", false]], "pycellga.recombination.uniform_crossover": [[14, "module-pycellga.recombination.uniform_crossover", false]], "pycellga.selection.roulette_wheel_selection": [[15, "module-pycellga.selection.roulette_wheel_selection", false]], "pycellga.selection.tournament_selection": [[15, "module-pycellga.selection.tournament_selection", false]], "random_vector_between() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.random_vector_between", false]], "randomize() (individual method)": [[4, "pycellga.individual.Individual.randomize", false]], "rastrigin (class in pycellga.problems.single_objective.continuous.rastrigin)": [[10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin", false]], "real (genetype attribute)": [[4, "pycellga.individual.GeneType.REAL", false]], "realproblem (class in pycellga.example.example_mcccga)": [[5, "pycellga.example.example_mcccga.RealProblem", false]], "rosenbrock (class in pycellga.problems.single_objective.continuous.rosenbrock)": [[10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock", false]], "rothellipsoid (class in pycellga.problems.single_objective.continuous.rothellipsoid)": [[10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid", false]], "roulettewheelselection (class in pycellga.selection.roulette_wheel_selection)": [[15, "pycellga.selection.roulette_wheel_selection.RouletteWheelSelection", false]], "run_alpha_cga_example() (in module pycellga.example.example_alpha_cga)": [[5, "pycellga.example.example_alpha_cga.run_alpha_cga_example", false]], "run_ccga_example() (in module pycellga.example.example_ccga)": [[5, "pycellga.example.example_ccga.run_ccga_example", false]], "run_cga_example() (in module pycellga.example.example_cga)": [[5, "pycellga.example.example_cga.run_cga_example", false]], "run_mcccga_example() (in module pycellga.example.example_mcccga)": [[5, "pycellga.example.example_mcccga.run_mcccga_example", false]], "run_sync_cga_example() (in module pycellga.example.example_sync_cga)": [[5, "pycellga.example.example_sync_cga.run_sync_cga_example", false]], "sample() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.sample", false]], "schaffer (class in pycellga.problems.single_objective.continuous.schaffer)": [[10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer", false]], "schaffer2 (class in pycellga.problems.single_objective.continuous.schaffer2)": [[10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2", false]], "schwefel (class in pycellga.problems.single_objective.continuous.schwefel)": [[10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel", false]], "setneighbors() (individual method)": [[4, "pycellga.individual.Individual.setneighbors", false]], "setneighbors_positions() (individual method)": [[4, "pycellga.individual.Individual.setneighbors_positions", false]], "shufflemutation (class in pycellga.mutation.shuffle_mutation)": [[6, "pycellga.mutation.shuffle_mutation.ShuffleMutation", false]], "sphere (class in pycellga.problems.single_objective.continuous.sphere)": [[10, "pycellga.problems.single_objective.continuous.sphere.Sphere", false]], "styblinskitang (class in pycellga.problems.single_objective.continuous.styblinskitang)": [[10, "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang", false]], "sumofdifferentpowers (class in pycellga.problems.single_objective.continuous.sumofdifferentpowers)": [[10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers", false]], "swapmutation (class in pycellga.mutation.swap_mutation)": [[6, "pycellga.mutation.swap_mutation.SwapMutation", false]], "sync_cga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.sync_cga", false]], "syncga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.SYNCGA", false]], "threehumps (class in pycellga.problems.single_objective.continuous.threehumps)": [[10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps", false]], "tournamentselection (class in pycellga.selection.tournament_selection)": [[15, "pycellga.selection.tournament_selection.TournamentSelection", false]], "tsp (class in pycellga.problems.single_objective.discrete.permutation.tsp)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp", false]], "twooptmutation (class in pycellga.mutation.two_opt_mutation)": [[6, "pycellga.mutation.two_opt_mutation.TwoOptMutation", false]], "twopointcrossover (class in pycellga.recombination.two_point_crossover)": [[14, "pycellga.recombination.two_point_crossover.TwoPointCrossover", false]], "unfairavaragecrossover (class in pycellga.recombination.unfair_avarage_crossover)": [[14, "pycellga.recombination.unfair_avarage_crossover.UnfairAvarageCrossover", false]], "uniformcrossover (class in pycellga.recombination.uniform_crossover)": [[14, "pycellga.recombination.uniform_crossover.UniformCrossover", false]], "update_vector() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.update_vector", false]], "vector (population attribute)": [[4, "pycellga.population.Population.vector", false]], "zakharov (class in pycellga.problems.single_objective.continuous.zakharov)": [[10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov", false]], "zettle (class in pycellga.problems.single_objective.continuous.zettle)": [[10, "pycellga.problems.single_objective.continuous.zettle.Zettle", false]]}, "objects": {"pycellga": [[4, 0, 0, "-", "byte_operators"], [5, 0, 0, "-", "example"], [4, 0, 0, "-", "grid"], [4, 0, 0, "-", "individual"], [4, 0, 0, "-", "optimizer"], [4, 0, 0, "-", "population"]], "pycellga.byte_operators": [[4, 1, 1, "", "bits_to_float"], [4, 1, 1, "", "bits_to_floats"], [4, 1, 1, "", "float_to_bits"], [4, 1, 1, "", "floats_to_bits"]], "pycellga.example": [[5, 0, 0, "-", "example_alpha_cga"], [5, 0, 0, "-", "example_ccga"], [5, 0, 0, "-", "example_cga"], [5, 0, 0, "-", "example_mcccga"], [5, 0, 0, "-", "example_sync_cga"]], "pycellga.example.example_alpha_cga": [[5, 2, 1, "", "ExampleProblem"], [5, 1, 1, "", "run_alpha_cga_example"]], "pycellga.example.example_alpha_cga.ExampleProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.example.example_ccga": [[5, 2, 1, "", "ExampleProblem"], [5, 1, 1, "", "run_ccga_example"]], "pycellga.example.example_ccga.ExampleProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.example.example_cga": [[5, 2, 1, "", "ExampleProblem"], [5, 1, 1, "", "run_cga_example"]], "pycellga.example.example_cga.ExampleProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.example.example_mcccga": [[5, 2, 1, "", "RealProblem"], [5, 1, 1, "", "run_mcccga_example"]], "pycellga.example.example_mcccga.RealProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.example.example_sync_cga": [[5, 2, 1, "", "ExampleProblem"], [5, 1, 1, "", "run_sync_cga_example"]], "pycellga.example.example_sync_cga.ExampleProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.grid": [[4, 2, 1, "", "Grid"]], "pycellga.grid.Grid": [[4, 3, 1, "", "__init__"], [4, 3, 1, "", "make_2d_grid"], [4, 4, 1, "", "n_cols"], [4, 4, 1, "", "n_rows"]], "pycellga.individual": [[4, 2, 1, "", "GeneType"], [4, 2, 1, "", "Individual"]], "pycellga.individual.GeneType": [[4, 4, 1, "", "BINARY"], [4, 4, 1, "", "PERMUTATION"], [4, 4, 1, "", "REAL"]], "pycellga.individual.Individual": [[4, 3, 1, "", "__init__"], [4, 4, 1, "", "ch_size"], [4, 4, 1, "", "chromosome"], [4, 4, 1, "", "fitness_value"], [4, 4, 1, "", "gen_type"], [4, 3, 1, "", "generate_candidate"], [4, 3, 1, "", "getneighbors"], [4, 3, 1, "", "getneighbors_positions"], [4, 4, 1, "", "neighbors"], [4, 4, 1, "", "neighbors_positions"], [4, 4, 1, "", "position"], [4, 3, 1, "", "randomize"], [4, 3, 1, "", "setneighbors"], [4, 3, 1, "", "setneighbors_positions"]], "pycellga.mutation": [[6, 0, 0, "-", "bit_flip_mutation"], [6, 0, 0, "-", "byte_mutation"], [6, 0, 0, "-", "byte_mutation_random"], [6, 0, 0, "-", "float_uniform_mutation"], [6, 0, 0, "-", "insertion_mutation"], [6, 0, 0, "-", "shuffle_mutation"], [6, 0, 0, "-", "swap_mutation"], [6, 0, 0, "-", "two_opt_mutation"]], "pycellga.mutation.bit_flip_mutation": [[6, 2, 1, "", "BitFlipMutation"]], "pycellga.mutation.bit_flip_mutation.BitFlipMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.byte_mutation": [[6, 2, 1, "", "ByteMutation"]], "pycellga.mutation.byte_mutation.ByteMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.byte_mutation_random": [[6, 2, 1, "", "ByteMutationRandom"]], "pycellga.mutation.byte_mutation_random.ByteMutationRandom": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.float_uniform_mutation": [[6, 2, 1, "", "FloatUniformMutation"]], "pycellga.mutation.float_uniform_mutation.FloatUniformMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.insertion_mutation": [[6, 2, 1, "", "InsertionMutation"]], "pycellga.mutation.insertion_mutation.InsertionMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.shuffle_mutation": [[6, 2, 1, "", "ShuffleMutation"]], "pycellga.mutation.shuffle_mutation.ShuffleMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.swap_mutation": [[6, 2, 1, "", "SwapMutation"]], "pycellga.mutation.swap_mutation.SwapMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.two_opt_mutation": [[6, 2, 1, "", "TwoOptMutation"]], "pycellga.mutation.two_opt_mutation.TwoOptMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.neighborhoods": [[7, 0, 0, "-", "compact_13"], [7, 0, 0, "-", "compact_21"], [7, 0, 0, "-", "compact_25"], [7, 0, 0, "-", "compact_9"], [7, 0, 0, "-", "linear_5"], [7, 0, 0, "-", "linear_9"]], "pycellga.neighborhoods.compact_13": [[7, 2, 1, "", "Compact13"]], "pycellga.neighborhoods.compact_13.Compact13": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.compact_21": [[7, 2, 1, "", "Compact21"]], "pycellga.neighborhoods.compact_21.Compact21": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.compact_25": [[7, 2, 1, "", "Compact25"]], "pycellga.neighborhoods.compact_25.Compact25": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.compact_9": [[7, 2, 1, "", "Compact9"]], "pycellga.neighborhoods.compact_9.Compact9": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.linear_5": [[7, 2, 1, "", "Linear5"]], "pycellga.neighborhoods.linear_5.Linear5": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.linear_9": [[7, 2, 1, "", "Linear9"]], "pycellga.neighborhoods.linear_9.Linear9": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.optimizer": [[4, 1, 1, "", "alpha_cga"], [4, 1, 1, "", "ccga"], [4, 1, 1, "", "cga"], [4, 1, 1, "", "compete"], [4, 1, 1, "", "generate_probability_vector"], [4, 1, 1, "", "mcccga"], [4, 1, 1, "", "random_vector_between"], [4, 1, 1, "", "sample"], [4, 1, 1, "", "sync_cga"], [4, 1, 1, "", "update_vector"]], "pycellga.population": [[4, 2, 1, "", "OptimizationMethod"], [4, 2, 1, "", "Population"]], "pycellga.population.OptimizationMethod": [[4, 4, 1, "", "ALPHA_CGA"], [4, 4, 1, "", "CCGA"], [4, 4, 1, "", "CGA"], [4, 4, 1, "", "MCCCGA"], [4, 4, 1, "", "SYNCGA"]], "pycellga.population.Population": [[4, 3, 1, "", "__init__"], [4, 4, 1, "", "ch_size"], [4, 4, 1, "", "gen_type"], [4, 3, 1, "", "initial_population"], [4, 4, 1, "", "method_name"], [4, 4, 1, "", "n_cols"], [4, 4, 1, "", "n_rows"], [4, 4, 1, "", "problem"], [4, 4, 1, "", "vector"]], "pycellga.problems": [[8, 0, 0, "-", "abstract_problem"]], "pycellga.problems.abstract_problem": [[8, 2, 1, "", "AbstractProblem"]], "pycellga.problems.abstract_problem.AbstractProblem": [[8, 3, 1, "id0", "f"]], "pycellga.problems.single_objective.continuous": [[10, 0, 0, "-", "ackley"], [10, 0, 0, "-", "bentcigar"], [10, 0, 0, "-", "bohachevsky"], [10, 0, 0, "-", "chichinadze"], [10, 0, 0, "-", "dropwave"], [10, 0, 0, "-", "fms"], [10, 0, 0, "-", "griewank"], [10, 0, 0, "-", "holzman"], [10, 0, 0, "-", "levy"], [10, 0, 0, "-", "matyas"], [10, 0, 0, "-", "pow"], [10, 0, 0, "-", "powell"], [10, 0, 0, "-", "rastrigin"], [10, 0, 0, "-", "rosenbrock"], [10, 0, 0, "-", "rothellipsoid"], [10, 0, 0, "-", "schaffer"], [10, 0, 0, "-", "schaffer2"], [10, 0, 0, "-", "schwefel"], [10, 0, 0, "-", "sphere"], [10, 0, 0, "-", "styblinskitang"], [10, 0, 0, "-", "sumofdifferentpowers"], [10, 0, 0, "-", "threehumps"], [10, 0, 0, "-", "zakharov"], [10, 0, 0, "-", "zettle"]], "pycellga.problems.single_objective.continuous.ackley": [[10, 2, 1, "", "Ackley"]], "pycellga.problems.single_objective.continuous.ackley.Ackley": [[10, 4, 1, "", "None"], [10, 3, 1, "id0", "f"]], "pycellga.problems.single_objective.continuous.bentcigar": [[10, 2, 1, "", "Bentcigar"]], "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar": [[10, 4, 1, "", "None"], [10, 3, 1, "id1", "f"]], "pycellga.problems.single_objective.continuous.bohachevsky": [[10, 2, 1, "", "Bohachevsky"]], "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky": [[10, 4, 1, "", "None"], [10, 3, 1, "id2", "f"]], "pycellga.problems.single_objective.continuous.chichinadze": [[10, 2, 1, "", "Chichinadze"]], "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze": [[10, 4, 1, "", "None"], [10, 3, 1, "id3", "f"]], "pycellga.problems.single_objective.continuous.dropwave": [[10, 2, 1, "", "Dropwave"]], "pycellga.problems.single_objective.continuous.dropwave.Dropwave": [[10, 3, 1, "id4", "f"]], "pycellga.problems.single_objective.continuous.fms": [[10, 2, 1, "", "Fms"]], "pycellga.problems.single_objective.continuous.fms.Fms": [[10, 4, 1, "", "None"], [10, 3, 1, "id5", "f"]], "pycellga.problems.single_objective.continuous.griewank": [[10, 2, 1, "", "Griewank"]], "pycellga.problems.single_objective.continuous.griewank.Griewank": [[10, 3, 1, "id6", "f"]], "pycellga.problems.single_objective.continuous.holzman": [[10, 2, 1, "", "Holzman"]], "pycellga.problems.single_objective.continuous.holzman.Holzman": [[10, 4, 1, "", "None"], [10, 3, 1, "id7", "f"]], "pycellga.problems.single_objective.continuous.levy": [[10, 2, 1, "", "Levy"]], "pycellga.problems.single_objective.continuous.levy.Levy": [[10, 4, 1, "", "None"], [10, 3, 1, "id8", "f"]], "pycellga.problems.single_objective.continuous.matyas": [[10, 2, 1, "", "Matyas"]], "pycellga.problems.single_objective.continuous.matyas.Matyas": [[10, 4, 1, "", "None"], [10, 3, 1, "id9", "f"]], "pycellga.problems.single_objective.continuous.pow": [[10, 2, 1, "", "Pow"]], "pycellga.problems.single_objective.continuous.pow.Pow": [[10, 4, 1, "", "None"], [10, 3, 1, "id10", "f"]], "pycellga.problems.single_objective.continuous.powell": [[10, 2, 1, "", "Powell"]], "pycellga.problems.single_objective.continuous.powell.Powell": [[10, 4, 1, "", "None"], [10, 3, 1, "id11", "f"]], "pycellga.problems.single_objective.continuous.rastrigin": [[10, 2, 1, "", "Rastrigin"]], "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin": [[10, 4, 1, "", "None"], [10, 3, 1, "id12", "f"]], "pycellga.problems.single_objective.continuous.rosenbrock": [[10, 2, 1, "", "Rosenbrock"]], "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock": [[10, 4, 1, "", "None"], [10, 3, 1, "id13", "f"]], "pycellga.problems.single_objective.continuous.rothellipsoid": [[10, 2, 1, "", "Rothellipsoid"]], "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid": [[10, 4, 1, "", "None"], [10, 3, 1, "id14", "f"]], "pycellga.problems.single_objective.continuous.schaffer": [[10, 2, 1, "", "Schaffer"]], "pycellga.problems.single_objective.continuous.schaffer.Schaffer": [[10, 3, 1, "id15", "f"]], "pycellga.problems.single_objective.continuous.schaffer2": [[10, 2, 1, "", "Schaffer2"]], "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2": [[10, 4, 1, "", "None"], [10, 3, 1, "id16", "f"]], "pycellga.problems.single_objective.continuous.schwefel": [[10, 2, 1, "", "Schwefel"]], "pycellga.problems.single_objective.continuous.schwefel.Schwefel": [[10, 4, 1, "", "None"], [10, 3, 1, "id17", "f"]], "pycellga.problems.single_objective.continuous.sphere": [[10, 2, 1, "", "Sphere"]], "pycellga.problems.single_objective.continuous.sphere.Sphere": [[10, 4, 1, "", "None"], [10, 3, 1, "id18", "f"]], "pycellga.problems.single_objective.continuous.styblinskitang": [[10, 2, 1, "", "StyblinskiTang"]], "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang": [[10, 4, 1, "", "None"], [10, 3, 1, "id19", "f"]], "pycellga.problems.single_objective.continuous.sumofdifferentpowers": [[10, 2, 1, "", "Sumofdifferentpowers"]], "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers": [[10, 3, 1, "", "f"]], "pycellga.problems.single_objective.continuous.threehumps": [[10, 2, 1, "", "Threehumps"]], "pycellga.problems.single_objective.continuous.threehumps.Threehumps": [[10, 4, 1, "", "None"], [10, 3, 1, "id20", "f"]], "pycellga.problems.single_objective.continuous.zakharov": [[10, 2, 1, "", "Zakharov"]], "pycellga.problems.single_objective.continuous.zakharov.Zakharov": [[10, 4, 1, "", "None"], [10, 3, 1, "id21", "f"]], "pycellga.problems.single_objective.continuous.zettle": [[10, 2, 1, "", "Zettle"]], "pycellga.problems.single_objective.continuous.zettle.Zettle": [[10, 4, 1, "", "None"], [10, 3, 1, "id22", "f"]], "pycellga.problems.single_objective.discrete.binary": [[12, 0, 0, "-", "count_sat"], [12, 0, 0, "-", "ecc"], [12, 0, 0, "-", "fms"], [12, 0, 0, "-", "maxcut100"], [12, 0, 0, "-", "maxcut20_01"], [12, 0, 0, "-", "maxcut20_09"], [12, 0, 0, "-", "mmdp"], [12, 0, 0, "-", "one_max"], [12, 0, 0, "-", "peak"]], "pycellga.problems.single_objective.discrete.binary.count_sat": [[12, 2, 1, "", "CountSat"]], "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat": [[12, 4, 1, "", "None"], [12, 3, 1, "id0", "f"]], "pycellga.problems.single_objective.discrete.binary.ecc": [[12, 2, 1, "", "Ecc"]], "pycellga.problems.single_objective.discrete.binary.ecc.Ecc": [[12, 4, 1, "", "None"], [12, 3, 1, "id1", "f"]], "pycellga.problems.single_objective.discrete.binary.fms": [[12, 2, 1, "", "Fms"]], "pycellga.problems.single_objective.discrete.binary.fms.Fms": [[12, 4, 1, "", "None"], [12, 3, 1, "id2", "f"]], "pycellga.problems.single_objective.discrete.binary.maxcut100": [[12, 2, 1, "", "Maxcut100"]], "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100": [[12, 4, 1, "", "None"], [12, 3, 1, "id3", "f"]], "pycellga.problems.single_objective.discrete.binary.maxcut20_01": [[12, 2, 1, "", "Maxcut20_01"]], "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01": [[12, 4, 1, "", "None"], [12, 3, 1, "id4", "f"]], "pycellga.problems.single_objective.discrete.binary.maxcut20_09": [[12, 2, 1, "", "Maxcut20_09"]], "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09": [[12, 4, 1, "", "None"], [12, 3, 1, "id5", "f"]], "pycellga.problems.single_objective.discrete.binary.mmdp": [[12, 2, 1, "", "Mmdp"]], "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp": [[12, 4, 1, "", "None"], [12, 3, 1, "id6", "f"]], "pycellga.problems.single_objective.discrete.binary.one_max": [[12, 2, 1, "", "OneMax"]], "pycellga.problems.single_objective.discrete.binary.one_max.OneMax": [[12, 4, 1, "", "None"], [12, 3, 1, "id7", "f"]], "pycellga.problems.single_objective.discrete.binary.peak": [[12, 2, 1, "", "Peak"]], "pycellga.problems.single_objective.discrete.binary.peak.Peak": [[12, 4, 1, "", "None"], [12, 3, 1, "id8", "f"]], "pycellga.problems.single_objective.discrete.permutation": [[13, 0, 0, "-", "tsp"]], "pycellga.problems.single_objective.discrete.permutation.tsp": [[13, 2, 1, "", "Tsp"]], "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp": [[13, 3, 1, "", "euclidean_dist"], [13, 3, 1, "", "f"], [13, 3, 1, "", "gographical_dist"]], "pycellga.recombination": [[14, 0, 0, "-", "arithmetic_crossover"], [14, 0, 0, "-", "blxalpha_crossover"], [14, 0, 0, "-", "byte_one_point_crossover"], [14, 0, 0, "-", "byte_uniform_crossover"], [14, 0, 0, "-", "flat_crossover"], [14, 0, 0, "-", "linear_crossover"], [14, 0, 0, "-", "one_point_crossover"], [14, 0, 0, "-", "pmx_crossover"], [14, 0, 0, "-", "two_point_crossover"], [14, 0, 0, "-", "unfair_avarage_crossover"], [14, 0, 0, "-", "uniform_crossover"]], "pycellga.recombination.arithmetic_crossover": [[14, 2, 1, "", "ArithmeticCrossover"]], "pycellga.recombination.arithmetic_crossover.ArithmeticCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.blxalpha_crossover": [[14, 2, 1, "", "BlxalphaCrossover"]], "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.byte_one_point_crossover": [[14, 2, 1, "", "ByteOnePointCrossover"]], "pycellga.recombination.byte_one_point_crossover.ByteOnePointCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.byte_uniform_crossover": [[14, 2, 1, "", "ByteUniformCrossover"]], "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.flat_crossover": [[14, 2, 1, "", "FlatCrossover"]], "pycellga.recombination.flat_crossover.FlatCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.linear_crossover": [[14, 2, 1, "", "LinearCrossover"]], "pycellga.recombination.linear_crossover.LinearCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.one_point_crossover": [[14, 2, 1, "", "OnePointCrossover"]], "pycellga.recombination.one_point_crossover.OnePointCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.pmx_crossover": [[14, 2, 1, "", "PMXCrossover"]], "pycellga.recombination.pmx_crossover.PMXCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.two_point_crossover": [[14, 2, 1, "", "TwoPointCrossover"]], "pycellga.recombination.two_point_crossover.TwoPointCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.unfair_avarage_crossover": [[14, 2, 1, "", "UnfairAvarageCrossover"]], "pycellga.recombination.unfair_avarage_crossover.UnfairAvarageCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.uniform_crossover": [[14, 2, 1, "", "UniformCrossover"]], "pycellga.recombination.uniform_crossover.UniformCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.selection": [[15, 0, 0, "-", "roulette_wheel_selection"], [15, 0, 0, "-", "tournament_selection"]], "pycellga.selection.roulette_wheel_selection": [[15, 2, 1, "", "RouletteWheelSelection"]], "pycellga.selection.roulette_wheel_selection.RouletteWheelSelection": [[15, 3, 1, "", "__init__"], [15, 3, 1, "", "get_parents"]], "pycellga.selection.tournament_selection": [[15, 2, 1, "", "TournamentSelection"]], "pycellga.selection.tournament_selection.TournamentSelection": [[15, 3, 1, "", "__init__"], [15, 3, 1, "", "get_parents"]]}, "objnames": {"0": ["py", "module", "Python module"], "1": ["py", "function", "Python function"], "2": ["py", "class", "Python class"], "3": ["py", "method", "Python method"], "4": ["py", "attribute", "Python attribute"]}, "objtypes": {"0": "py:module", "1": "py:function", "2": "py:class", "3": "py:method", "4": "py:attribute"}, "terms": {"": [0, 1, 4, 6, 9, 10, 12, 15, 17], "0": [4, 5, 6, 10, 11, 15, 17], "001": 10, "003791": 10, "01": [10, 12], "028": 10, "0299": 10, "0674": 12, "1": [0, 1, 4, 5, 6, 10, 11, 17], "10": [5, 10, 12], "100": [5, 10, 11, 17], "1077": 12, "119812": 12, "12": [7, 10], "13": 0, "14": 13, "144": 12, "15": 10, "192": 12, "2": [1, 4, 6, 10, 12, 15, 17], "20": [7, 11], "2013": [6, 14], "2024": 0, "24": 7, "240": 12, "2500": 0, "2514": 0, "2d": [4, 7], "3": [1, 3, 4, 10], "30": 10, "3159": 10, "32": [4, 10, 17], "332": 10, "3323": 13, "35": 10, "4": [1, 4, 7, 10], "40": 12, "420": 10, "43": 10, "5": [4, 5, 6, 10, 17], "500": 10, "554": 10, "56": 12, "5x5": 5, "6": [10, 12], "600": 10, "6860": 12, "7": [3, 10], "740064": 12, "754": 17, "768": [10, 17], "78": 10, "8": [1, 7], "9": [10, 11, 17], "90133": 10, "903534": 10, "9687": 10, "A": [0, 2, 5, 6, 7, 8, 10, 12, 13, 14, 15], "Be": 1, "By": 8, "For": [0, 1, 3, 5], "If": [0, 1, 3, 4, 8, 17], "In": [4, 17], "It": [4, 6, 10], "One": 11, "The": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "These": [4, 5, 7, 8, 9, 10, 11, 12, 13], "To": [1, 3, 17], "__init__": [4, 5, 6, 7, 14, 15, 17], "__version__": 3, "abil": [10, 12], "abov": 17, "abstractproblem": [4, 6, 8, 10, 12, 13, 14], "account": 1, "accuraci": [8, 9, 10], "achiev": 5, "acklei": 9, "acknowledg": 0, "across": [6, 7, 8], "act": 15, "ad": [1, 6], "add": 1, "addit": 3, "address": [9, 10], "adher": 1, "adjust": 6, "akten": 0, "algorithm": [0, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], "all": [1, 5, 10, 12, 17], "allow": [2, 4, 6, 7, 14], "along": [7, 17], "alpha": [2, 4, 5], "alpha_cga": [4, 5], "also": 0, "alter": 6, "altern": 5, "among": 7, "an": [0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 17], "ani": [1, 3], "annot": 1, "apa": 0, "appli": [0, 6, 8, 14, 17], "applic": [5, 7], "approach": [6, 10], "ar": [1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 17], "argument": 1, "arithmet": 17, "arithmeticcrossov": 14, "around": [6, 14], "arrai": 5, "arrang": 7, "articl": 0, "aspect": 10, "assess": [9, 12], "attribut": 4, "author": 0, "automata": 2, "avail": [10, 17], "b": [1, 13], "back": 4, "balanc": [2, 10, 15], "base": [4, 5, 7, 9, 10, 12, 14, 15], "basic": [5, 17], "befor": [1, 3], "begin": 1, "being": [5, 15], "below": [5, 10, 17], "benchmark": [8, 9, 10, 11, 12, 13], "benefici": [7, 15], "bent": 9, "bentcigar": 10, "besid": 2, "best": [4, 5, 13, 15, 17], "better": [1, 4, 17], "between": [2, 4, 10, 12, 13, 14], "bia": 14, "bibtex": 0, "binari": [4, 5, 6, 9, 14, 17], "bit": [4, 12], "bit_list": 4, "bitflipmut": 6, "bits_to_float": 4, "bitwis": 6, "block": 4, "blxalphacrossov": 14, "bohachevski": 9, "both": [4, 8, 10, 11, 14], "bound": 10, "boundari": 4, "branch": 1, "bring": 1, "broader": [6, 7], "brows": 1, "bug": 1, "bugfix": 1, "build": 4, "burma14": 13, "button": 1, "byte": [2, 5, 17], "bytemut": 6, "bytemutationrandom": [6, 17], "byteonepointcrossov": [14, 17], "byteuniformcrossov": 14, "c": 15, "calcul": [4, 7, 10, 12, 13, 14], "calculate_neighbors_posit": 7, "callabl": 4, "camel": 10, "can": [1, 3, 7, 8, 17], "candid": [4, 6, 8], "capabl": 10, "case": 4, "ccga": [4, 5], "cd": [1, 3], "cdot": 10, "cell": [4, 7], "cellular": [0, 2, 4, 5, 7], "center": 10, "certain": 3, "cga": [2, 4, 5, 7], "ch_size": [4, 17], "challeng": [9, 10, 12], "chanc": 15, "chang": [1, 6], "character": [10, 12], "checkout": 1, "chicago": 0, "chichinadz": 9, "choic": 6, "chosen": [14, 15], "chromosom": [4, 5, 6, 10, 12, 13, 14, 17], "cigar": 9, "citat": 0, "cite": 2, "citi": 13, "clarifi": 1, "class": [1, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15], "classic": [6, 12, 13, 14], "clear": 1, "click": [1, 17], "clone": [1, 3], "cluster": 7, "co": 10, "code": [0, 2, 4, 5, 12, 14, 17], "codebas": 1, "collect": [8, 9], "column": [4, 7], "com": [1, 3], "combin": [2, 4, 14], "combinatori": [6, 9, 11, 13], "command": 3, "commit": 1, "common": [8, 10], "commonli": [6, 8, 9, 10, 12, 14], "commun": [0, 1, 12], "compact": [2, 4, 5], "compact13": 7, "compact21": 7, "compact25": 7, "compact9": 7, "compat": 8, "compet": [4, 15], "complex": [2, 10], "compon": 8, "comprehens": [2, 5, 6], "comput": [5, 10, 13, 17], "configur": [5, 6], "connect": 12, "consid": [1, 7], "consist": [1, 8], "constrain": 5, "constraint": [8, 12], "contain": [4, 5, 11, 14, 15], "continu": [0, 6, 8, 17], "contribut": [0, 2], "control": [4, 14], "converg": [5, 7, 8, 9, 10, 15, 17], "convert": 4, "coordin": [10, 13], "copi": [1, 14], "core": 5, "corner": 1, "correct": 12, "correctli": 3, "correspond": [5, 17], "count": 11, "countsat": 12, "cover": 1, "creat": [0, 1, 4, 6, 8, 14], "crossov": [4, 15, 17], "custom": 8, "cut": 11, "d": 10, "data": 4, "date": 3, "deal": 10, "deceiv": 12, "decept": 11, "decim": [6, 10, 12, 13], "decod": [4, 17], "decrement": 6, "def": 17, "default": [4, 6], "defin": [4, 6, 7, 8, 10, 14, 17], "definit": 4, "degre": 6, "demonstr": 5, "dens": 7, "denser": 12, "densiti": 11, "depend": [1, 7], "depth": 4, "descript": [1, 4], "design": [6, 8, 9, 11, 12, 13, 14], "desir": [6, 7], "detail": [1, 3], "determin": [4, 7, 15], "develop": 0, "differ": [4, 5, 7, 9, 10, 11, 14], "differenti": [9, 10], "difficulti": 10, "directli": [3, 15, 17], "directori": [1, 3], "discret": [8, 12, 13], "distanc": [12, 13], "divers": [2, 4, 6, 7, 9, 14, 15, 17], "docstr": 1, "document": [1, 5], "drive": [1, 12], "drop": 9, "dropwav": 10, "dure": [1, 2, 3, 4, 6, 15], "e": [4, 6], "each": [1, 2, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "easiest": 3, "ecc": 11, "edg": 7, "edge_weight_typ": 13, "effect": [4, 6, 14, 15], "effici": [4, 5, 10, 12, 13], "either": 6, "element": [4, 5, 6, 10, 11, 12, 13, 17], "ellipsoid": 10, "empti": 4, "enabl": 6, "encapsul": 4, "encod": [4, 5, 6, 11, 12, 14, 17], "encount": [1, 3, 12], "encourag": 7, "engin": 0, "enhanc": [1, 4, 5, 6, 7], "ensur": [1, 3, 4, 8, 17], "entri": 0, "enum": 4, "enumer": 4, "environ": 1, "equal": [5, 17], "error": [3, 10, 12], "escap": [10, 12], "essenti": 7, "euclidean": 13, "euclidean_dist": 13, "evalu": [4, 8, 9, 10, 11, 12, 13], "even": 1, "evolutionari": 4, "evolv": 4, "exactli": 13, "exampl": [0, 1, 2, 3, 4, 8, 10], "example_alpha_cga": 5, "example_ccga": 5, "example_cga": 5, "example_mcccga": 5, "example_sync_cga": 5, "exampleproblem": 5, "exchang": [4, 14], "excit": 1, "execut": 4, "experiment": 10, "explain": 17, "exploit": [2, 10, 15], "explor": [2, 4, 5, 6, 7, 10, 14, 15, 17], "extend": 7, "f": [5, 8, 10, 12, 13, 17], "facilit": 7, "factor": 12, "featur": [1, 3, 12], "feedback": 1, "find": [12, 13, 17], "fine": [10, 14], "first": [4, 13, 14], "fit": [4, 6, 8, 10, 12, 13, 14, 15], "fitness_valu": 4, "five": 4, "fix": 1, "flat": 10, "flatcrossov": 14, "fletcher": 11, "flexibl": 8, "float": [4, 5, 8, 10, 12, 13, 17], "float_list": 4, "float_numb": 4, "float_to_bit": 4, "floats_to_bit": 4, "floatuniformmut": 6, "flow": 7, "fm": [9, 11], "focus": 11, "folder": [1, 17], "follow": [0, 1, 3, 6, 17], "fork": 1, "form": [4, 11], "format": 0, "found": 4, "framework": [4, 5, 8], "frequenc": [9, 12], "frequent": 6, "from": [1, 4, 6, 8, 14, 15, 17], "full": 5, "function": [1, 4, 5, 6, 8, 9, 12, 13, 14, 17], "fundament": 4, "g": 4, "gap": 4, "gen_typ": [4, 17], "gene": [4, 5, 6, 14, 17], "gener": [4, 5, 12, 14, 17], "generate_candid": 4, "generate_probability_vector": 4, "genet": [0, 2, 4, 5, 6, 7, 8, 12, 14, 15], "genetyp": [4, 17], "genom": 4, "geo": 13, "geodes": 13, "geograph": 13, "get": [4, 15], "get_par": 15, "get_recombin": 14, "getneighbor": 4, "getneighbors_posit": 4, "git": [1, 3], "github": [1, 3], "given": [4, 5, 7, 8, 10, 12, 13], "global": [5, 10, 17], "goal": [5, 13, 17], "gographical_dist": 13, "googl": 1, "graph": 12, "grid": [2, 5, 7, 17], "griewank": 9, "guid": [1, 2], "h": 0, "ha": [2, 3, 10], "hakan": 0, "handl": [4, 9, 13], "harvard": 0, "have": [1, 3, 7, 12, 17], "help": [0, 1, 4, 17], "here": [1, 17], "high": 6, "higher": [3, 7, 14], "highlight": 5, "hint": 1, "hole": 10, "holzman": 9, "how": [5, 7, 15, 17], "http": [1, 3], "hump": 10, "hyper": 10, "hypercub": 10, "i": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "icga": 17, "idea": 1, "ideal": [6, 7, 9, 10], "identifi": 0, "ieee": 17, "ight": 10, "illustr": 5, "immedi": 7, "impact": [0, 15], "implement": [1, 2, 4, 8, 10, 12, 13, 15], "import": [3, 17], "improv": [0, 1, 2, 5, 17], "includ": [1, 4, 5, 6, 7, 8, 9, 11, 14, 17], "incorpor": 5, "increment": 6, "index": [3, 13, 15], "individu": [2, 5, 6, 7, 14, 15, 17], "inform": [7, 14], "inherit": 8, "initi": [4, 6, 7, 14, 15], "initial_popul": 4, "innov": 1, "input": [5, 10], "insertionmut": 6, "insight": 5, "instal": [1, 2], "instanc": [4, 5, 6, 14, 17], "instruct": 3, "int": [4, 5, 7, 15], "integ": 4, "interact": [2, 4, 7, 17], "interest": 17, "interfac": [4, 8], "intermedi": 14, "introduc": 6, "invalu": 1, "invari": 10, "involv": [12, 13], "issu": [1, 3], "its": [2, 3, 4, 5, 7, 10, 12, 15, 17], "journal": 0, "jupyt": 3, "k": 15, "k_tournament": 4, "karakaya": 0, "karakaya2024improv": 0, "kei": [1, 8, 15], "known": [4, 10, 13], "known_best": 4, "landscap": [9, 10, 12, 15], "larg": 10, "larger": 7, "latex": 0, "layout": [4, 7], "lead": 14, "least": 10, "left": 10, "length": [10, 12, 13], "level": [4, 5, 7, 10, 14], "leverag": 6, "levi": 9, "librari": 4, "like": [2, 4], "limit": [7, 12], "line": 7, "linear5": 7, "linear9": 7, "linearcrossov": 14, "linearli": 14, "list": [4, 5, 7, 8, 10, 12, 13, 14, 15], "ll": [1, 17], "local": [1, 7, 10, 12], "locationsourc": 14, "look": 4, "lose": 4, "loser": 4, "low": 4, "m": 0, "machin": [0, 1, 2, 4, 5, 14, 17], "mai": 3, "main": [1, 4, 9], "maintain": [1, 2, 4, 7, 14, 15, 17], "make": [1, 3, 10], "make_2d_grid": 4, "male": [2, 4, 5], "manag": [3, 7, 8, 12], "manipul": 6, "map": 14, "massiv": 12, "matplotlib": 3, "matya": 9, "max": [4, 5, 11, 17], "maxcut": 12, "maxcut100": 12, "maxcut20_01": 12, "maxcut20_09": 12, "maxim": [5, 12], "maximum": [4, 10, 12, 17], "mcc": 5, "mcccga": [4, 5], "mccga": 4, "meaning": 1, "mechan": [4, 5, 15], "mehmet": 0, "memori": [4, 5], "merg": 1, "messag": 1, "method": [4, 5, 8, 10, 13, 14, 15, 17], "method_nam": 4, "min": [4, 5, 17], "minim": [5, 17], "minima": 10, "minimum": [4, 5, 10, 17], "minumum": 13, "mix": 14, "mla": 0, "mmdp": 11, "modal": 11, "moder": 7, "modifi": 10, "modul": [6, 7, 8, 9, 12, 13], "more": [4, 7, 14, 17], "move": 6, "mpmath": 17, "multi": [4, 8, 11], "multidimension": 10, "multimod": [10, 12, 15], "multipl": 12, "must": 4, "mutat": [4, 17], "mutation_cand": 6, "mutationoper": [4, 6], "n": 10, "n_col": [4, 7, 17], "n_gen": [4, 17], "n_row": [4, 7, 17], "name": [1, 4], "navig": [1, 3], "nbest": 17, "ndarrai": 5, "nearli": 10, "necessari": 6, "need": [3, 8, 17], "neighbor": [2, 4, 7, 15, 17], "neighborhood": 4, "neighbors_posit": 4, "new": [1, 6], "node": [11, 13], "none": [4, 6, 10, 12], "nonlinear": 10, "normal": 12, "note": [10, 12, 13], "notebook": 3, "notimplementederror": [4, 8], "ntri": 4, "number": [0, 4, 5, 6, 7, 10, 12, 15, 17], "numer": [10, 12], "numpi": 5, "object": [4, 5, 6, 7, 10, 11, 12, 14, 15], "occur": 3, "offer": [4, 6, 7, 10], "offspr": [4, 14], "often": [10, 12, 14], "onc": 13, "one": [1, 4, 6, 8, 13, 14], "onemax": 12, "onepointcrossov": 14, "ones": 12, "onli": [2, 8, 17], "open": 1, "oper": [0, 2, 17], "optim": [2, 3, 5, 6, 8, 14, 15, 17], "optima": [10, 12], "optimis": 0, "optimizationmethod": 4, "optimum": 12, "option": [4, 6], "order": [6, 11, 13, 14], "organ": [2, 9], "origin": 13, "other": [0, 17], "our": 1, "outer": 10, "over": [10, 14], "overview": 5, "own": 1, "p1": [4, 14], "p2": [4, 14], "p_crossov": [4, 17], "p_mutat": [4, 17], "packag": [0, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 17], "page": [0, 1], "pair": 14, "paramet": [4, 5, 6, 7, 8, 10, 12, 13, 14, 15], "parent": [4, 14, 15], "particularli": [6, 9, 11, 12, 13], "partit": 12, "pass": [1, 17], "path": 6, "pattern": 4, "peak": 11, "pep": 1, "perform": [4, 6, 9, 10, 11, 12, 14, 15], "permut": [4, 6, 9, 14, 17], "persist": 3, "pick": 1, "pip": [1, 3], "place": [6, 10, 12, 13], "plai": 15, "plan": 3, "pleas": [0, 1], "pmxcrossov": 14, "point": [6, 7, 10, 17], "pop_list": 15, "pop_siz": 4, "popul": [2, 5, 6, 7, 15, 17], "posit": [4, 6, 7, 14], "possibl": 13, "pow": 9, "powel": [9, 11], "power": [10, 17], "pp": 0, "practic": 5, "precis": 6, "prematur": 17, "present": 12, "preserv": 6, "prevent": 17, "principl": [2, 5], "print": [3, 17], "probabl": 4, "problem": [0, 2, 4, 5, 6, 7, 14, 15], "probvector": 4, "process": [1, 2, 4, 6, 15], "produc": 14, "project": [0, 1], "promot": [2, 6, 7], "proport": 15, "proportion": 15, "provid": [1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 17], "purpos": [6, 13, 14], "push": 1, "pw": 17, "pycellga": [0, 1, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "pytest": 1, "python": [1, 2, 3, 4, 17], "qualnam": 4, "r": 1, "rac": 10, "rais": [4, 8], "random": [4, 14, 15, 17], "random_vector_between": 4, "randomli": [4, 6, 12, 14], "rang": [4, 6, 10, 12, 14], "rapid": 7, "rastrigin": 9, "re": [1, 17], "reach": 17, "readabl": 1, "readi": [1, 17], "real": [0, 2, 4, 5, 6, 14, 17], "realproblem": 5, "rearrang": 6, "recombin": [4, 17], "recombinationoper": [4, 14], "recommend": 1, "refer": [0, 3, 5], "region": 10, "relat": 12, "relev": 4, "repeat": [4, 17], "replac": [4, 17], "repo": 1, "report": 1, "reposit": 6, "repositori": [1, 3, 17], "repres": [4, 5, 7, 8, 9, 10, 11, 12, 13], "represent": [6, 14, 17], "requir": [1, 6, 7, 12], "research": 0, "respect": 4, "respond": 1, "respons": 1, "rest": 8, "restrict": 4, "result": [3, 14, 17], "retain": 14, "return": [1, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15, 17], "revers": 6, "review": 1, "right": 1, "roadmap": 1, "robust": [8, 9, 10, 12], "role": 15, "rosenbrock": 9, "rotat": 10, "rotation": 10, "rothellipsoid": 9, "roulettewheelselect": 15, "round": [6, 10, 12, 13], "rout": 13, "row": [4, 7], "rug": 12, "run": [3, 4, 5, 17], "run_alpha_cga_exampl": 5, "run_ccga_exampl": 5, "run_cga_exampl": 5, "run_mcccga_exampl": 5, "run_sync_cga_exampl": 5, "salesman": [6, 11], "sampl": [4, 6], "sat": 11, "satisfact": 12, "satisfi": 12, "satman": [0, 6, 14], "scenario": 8, "schaffer": 9, "schaffer2": 9, "schedul": 6, "schwefel": 9, "scienc": 0, "scientif": 0, "search": [9, 10, 11, 12], "second": [4, 13, 14], "section": [3, 17], "see": [1, 17], "seed_par": [4, 17], "segment": [6, 14], "select": [1, 4, 6, 7, 17], "selectionoper": [4, 15], "self": 17, "sequenc": [6, 11, 13, 14], "sequenti": 7, "serv": [4, 6, 8, 14], "set": [1, 4, 5, 6, 8, 9, 11, 12, 13], "setneighbor": 4, "setneighbors_posit": 4, "sevgi": 0, "sevgiakten": 3, "share": 7, "shortest": 13, "should": [1, 4, 10], "shufflemut": 6, "signific": 6, "simpl": [5, 6, 10, 12, 17], "simplic": 15, "simultan": 5, "sin": 10, "singl": [6, 10, 11, 12, 14], "single_object": [8, 9, 10, 11, 12, 13], "size": [4, 5, 7], "slight": 14, "small": 6, "smooth": [1, 9, 10], "smoothli": 1, "softwar": [0, 1], "solut": [1, 4, 5, 6, 8, 9, 11, 12, 13, 17], "solv": [5, 12, 13], "some": [1, 10], "sound": [9, 12], "sourc": [4, 5, 6, 7, 8, 10, 12, 13, 14, 15], "space": [6, 9, 11, 12], "spars": 12, "sparsiti": 12, "spatial": [2, 7], "special": 17, "specif": [4, 6, 7, 10, 11, 14], "specifi": [4, 5, 14], "speed": [4, 8, 9, 10], "sphere": 9, "sqrt": 10, "squar": [5, 17], "standard": [5, 8, 13, 17], "start": [4, 15], "steep": 10, "step": [1, 3], "str": 4, "strategi": 6, "string": [4, 11, 12], "structur": [2, 5, 7, 8, 9, 10, 17], "styblinski": 10, "styblinskitang": 9, "style": [0, 1], "subclass": 8, "submit": [1, 3], "subpackag": [8, 9, 11], "subproblem": 12, "subsequ": 6, "subset": [6, 15], "subtl": 6, "subtract": 6, "success": 3, "suggest": 1, "suitabl": [6, 7, 10, 12, 14], "sum": [5, 10, 12, 17], "sum_": 10, "sumofdifferentpow": 9, "support": [0, 1, 4], "suppos": 17, "sure": 3, "swap": 14, "swapmut": 6, "sync": [4, 5], "sync_cga": [4, 5], "syncga": 4, "synchron": [4, 5], "system": 12, "tailor": [6, 11], "take": 4, "tang": 10, "target": 12, "task": [6, 8, 11, 13], "techniqu": 14, "term": [8, 9, 10], "test": [4, 8, 9, 10, 11, 12, 13], "thank": 1, "thi": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "third": 4, "those": [10, 12], "three": [4, 10, 12], "threehump": 9, "thrill": 1, "tightli": 7, "tip": 3, "titl": 0, "topologi": [2, 17], "total": 13, "tournament": 4, "tournamentselect": [15, 17], "toward": 12, "tracker": 1, "tradit": 2, "trait": 14, "trap": 12, "travel": [6, 11], "trial": 4, "try": 3, "tsp": 11, "tune": 10, "tupl": [4, 5, 7], "tutori": 3, "two": [4, 9, 10, 13], "twooptmut": 6, "twopointcrossov": 14, "txt": 1, "type": [1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "typic": 11, "typo": 1, "u": 1, "understand": [1, 4], "unfairavaragecrossov": 14, "uniformcrossov": 14, "uniformli": 6, "unimod": 10, "uniqu": [6, 10, 12, 14], "up": [1, 3, 5], "updat": [4, 5], "update_vector": 4, "upgrad": 3, "upper": 1, "us": [0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "usag": [2, 4, 5], "user": [0, 1, 4, 5, 7, 8], "usernam": 1, "usual": 10, "util": [2, 4, 5], "v": 1, "valu": [0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 17], "variabl": [8, 10, 12], "variant": [4, 5], "variat": 6, "variou": [0, 5, 7, 8, 10, 14, 15, 17], "vector": [4, 17], "verifi": 1, "version": [3, 5, 12], "via": 3, "visibl": 0, "visit": [1, 13], "visual": 3, "volum": 0, "wa": 4, "wai": 3, "want": 17, "wave": 9, "we": [1, 17], "went": 0, "what": 1, "when": [1, 5, 6, 17], "where": [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "whether": 1, "which": [4, 5, 8, 10, 12, 14], "while": [6, 7, 17], "whose": 7, "why": 0, "wide": [10, 11, 13, 14, 15], "win": 4, "winner": 4, "wise": 6, "within": [4, 6, 7, 10, 12, 14], "without": 6, "work": [0, 11], "wrap": [6, 7], "write": 1, "x": [4, 5, 7, 8, 10, 12, 13, 17], "x1": 10, "x2": 10, "x_": 10, "x_i": 10, "xi": [10, 17], "y": [4, 7, 10], "year": 0, "yet": 6, "yield": 17, "you": [0, 1, 3, 17], "your": [0, 1], "zakharov": 9, "zettl": 9}, "titles": ["Citing", "Contributing", "PYCELLGA Documentation", "Installation", "pycellga: A Comprehensive Guide", "Example Implementations in pycellga", "Mutation Operators", "Neighborhood Operators", "Problem Definitions", "Single-Objective Optimization Problems", "Continuous Optimization Problems", "Discrete Optimization Problems", "Binary Optimization Problems", "Permutation-Based Optimization Problems", "Recombination Operators", "Selection Operators", "setup module", "Usage Examples"], "titleterms": {"0": 12, "1": 12, "100": 12, "13": 7, "20": 12, "21": 7, "25": 7, "5": 7, "9": [7, 12], "A": 4, "One": [12, 14], "abstract": 8, "acklei": 10, "algorithm": 17, "alpha": 14, "arithmet": 14, "avail": 5, "averag": 14, "base": [6, 8, 11, 13], "bent": 10, "binari": [11, 12], "bit": 6, "blx": 14, "bohachevski": 10, "byte": [4, 6, 14], "cellular": 17, "cga": 17, "chichinadz": 10, "cigar": 10, "cite": 0, "class": 17, "code": 1, "compact": 7, "comprehens": 4, "content": 2, "continu": [9, 10], "contribut": 1, "core": 4, "count": 12, "crossov": 14, "cut": 12, "decept": 12, "definit": 8, "densiti": 12, "depend": 3, "develop": 1, "discret": [9, 11], "document": 2, "drop": 10, "ecc": 12, "exampl": [5, 17], "exampleproblem": 17, "flat": 14, "fletcher": 12, "flip": 6, "float": 6, "fm": [10, 12], "frequenc": 10, "from": 3, "function": 10, "genet": 17, "grid": 4, "griewank": 10, "guid": 4, "guidelin": 1, "holzman": 10, "implement": 5, "individu": 4, "insert": 6, "instal": 3, "level": 6, "levi": 10, "linear": [7, 14], "manag": 4, "match": 14, "matya": 10, "max": 12, "mmdp": 12, "modal": 12, "modul": [4, 5, 10, 16], "multi": 12, "mutat": 6, "neighborhood": 7, "node": 12, "object": [8, 9], "oper": [4, 6, 7, 14, 15], "opt": 6, "optim": [4, 9, 10, 11, 12, 13], "option": 3, "partial": 14, "peak": 12, "permut": [11, 13], "pmx": 14, "point": 14, "popul": 4, "pow": 10, "powel": [10, 12], "problem": [8, 9, 10, 11, 12, 13, 17], "pull": 1, "pycellga": [2, 4, 5], "pypi": 3, "random": 6, "rastrigin": 10, "recombin": 14, "represent": 4, "request": 1, "requir": 3, "rosenbrock": 10, "rothellipsoid": 10, "roulett": 15, "run": 1, "salesman": 13, "sat": 12, "schaffer": 10, "schaffer2": 10, "schwefel": 10, "select": 15, "setup": [1, 16], "shuffl": 6, "singl": [8, 9], "sound": 10, "sourc": 3, "sphere": 10, "standard": 1, "structur": 4, "styblinskitang": 10, "sumofdifferentpow": 10, "swap": 6, "tabl": 2, "test": 1, "threehump": 10, "tournament": 15, "travel": 13, "troubleshoot": 3, "tsp": 13, "two": [6, 14], "unfair": 14, "uniform": [6, 14], "uninstal": 3, "usag": 17, "verifi": 3, "wai": 1, "wave": 10, "wheel": 15, "zakharov": 10, "zettl": 10}}) \ No newline at end of file +Search.setIndex({"alltitles": {"Abstract Problem Base": [[8, "abstract-problem-base"]], "Ackley Function": [[10, "ackley-function"]], "Arithmetic Crossover": [[14, "arithmetic-crossover"]], "Available Example Modules": [[5, "available-example-modules"]], "BLX-Alpha Crossover": [[14, "blx-alpha-crossover"]], "Bent Cigar Function": [[10, "bent-cigar-function"]], "Binary Optimization Problems": [[12, null]], "Binary-Based Problems": [[11, "binary-based-problems"]], "Bit Flip Mutation": [[6, "bit-flip-mutation"]], "Bohachevsky Function": [[10, "bohachevsky-function"]], "Byte One-Point Crossover": [[14, "byte-one-point-crossover"]], "Byte Operators": [[4, "byte-operators"]], "Byte Uniform Crossover": [[14, "byte-uniform-crossover"]], "Byte-Level Mutation": [[6, "byte-level-mutation"]], "Chichinadze Function": [[10, "chichinadze-function"]], "Citing": [[0, null]], "Coding Standards": [[1, "coding-standards"]], "Compact 13": [[7, "compact-13"]], "Compact 21": [[7, "compact-21"]], "Compact 25": [[7, "compact-25"]], "Compact 9": [[7, "compact-9"]], "Continuous Optimization Problems": [[9, "continuous-optimization-problems"], [10, null]], "Contributing": [[1, null]], "Core Modules": [[4, "core-modules"]], "Count SAT": [[12, "count-sat"]], "Development Setup": [[1, "development-setup"]], "Discrete Optimization Problems": [[9, "discrete-optimization-problems"], [11, null]], "Drop Wave Function": [[10, "drop-wave-function"]], "ECC Problem": [[12, "ecc-problem"]], "Example Implementations in pycellga": [[5, null]], "Example Problem": [[17, "example-problem"]], "ExampleProblem Class": [[17, "exampleproblem-class"]], "Flat Crossover": [[14, "flat-crossover"]], "Fletcher-Powell (FMS) Binary Problem": [[12, "fletcher-powell-fms-binary-problem"]], "Frequency Modulation Sound Function (FMS)": [[10, "frequency-modulation-sound-function-fms"]], "Grid Structure": [[4, "grid-structure"]], "Griewank Function": [[10, "griewank-function"]], "Holzman Function": [[10, "holzman-function"]], "Individual Representation": [[4, "individual-representation"]], "Insertion-Based Mutation": [[6, "insertion-based-mutation"]], "Installation": [[3, null]], "Installing from PyPI": [[3, "installing-from-pypi"]], "Installing from Source": [[3, "installing-from-source"]], "Levy Function": [[10, "levy-function"]], "Linear 5": [[7, "linear-5"]], "Linear 9": [[7, "linear-9"]], "Linear Crossover": [[14, "linear-crossover"]], "Matyas Function": [[10, "matyas-function"]], "Max-Cut (100 nodes)": [[12, "max-cut-100-nodes"]], "Max-Cut (20 nodes, Density 0.1)": [[12, "max-cut-20-nodes-density-0-1"]], "Max-Cut (20 nodes, Density 0.9)": [[12, "max-cut-20-nodes-density-0-9"]], "Multi-modal Deceptive Problem (MMDP)": [[12, "multi-modal-deceptive-problem-mmdp"]], "Mutation Operators": [[6, null]], "Neighborhood Operators": [[7, null]], "One-Max Problem": [[12, "one-max-problem"]], "One-Point Crossover": [[14, "one-point-crossover"]], "Optimizer": [[4, "optimizer"]], "Optional Dependencies": [[3, "optional-dependencies"]], "PYCELLGA Documentation": [[2, null]], "Partially Matched Crossover (PMX)": [[14, "partially-matched-crossover-pmx"]], "Peak Problem": [[12, "peak-problem"]], "Permutation-Based Optimization Problems": [[13, null]], "Permutation-Based Problems": [[11, "permutation-based-problems"]], "Population Management": [[4, "population-management"]], "Pow Function": [[10, "pow-function"]], "Powell Function": [[10, "powell-function"]], "Problem Definitions": [[8, null]], "Pull Request Guidelines": [[1, "pull-request-guidelines"]], "Randomized Byte Mutation": [[6, "randomized-byte-mutation"]], "Rastrigin Function": [[10, "rastrigin-function"]], "Recombination Operators": [[14, null]], "Requirements": [[3, "requirements"]], "Rosenbrock Function": [[10, "rosenbrock-function"]], "Rothellipsoid Function": [[10, "rothellipsoid-function"]], "Roulette Wheel Selection": [[15, "roulette-wheel-selection"]], "Running Tests": [[1, "running-tests"]], "Schaffer Function": [[10, "schaffer-function"]], "Schaffer2 Function": [[10, "schaffer2-function"]], "Schwefel Function": [[10, "schwefel-function"]], "Selection Operators": [[15, null]], "Shuffle Mutation": [[6, "shuffle-mutation"]], "Single-Objective Optimization Problems": [[9, null]], "Single-Objective Problems": [[8, "single-objective-problems"]], "Sphere Function": [[10, "sphere-function"]], "Styblinskitang Function": [[10, "styblinskitang-function"]], "Sumofdifferentpowers Function": [[10, "sumofdifferentpowers-function"]], "Swap Mutation": [[6, "swap-mutation"]], "Table of Contents :": [[2, null]], "Threehumps Function": [[10, "threehumps-function"]], "Tournament Selection": [[15, "tournament-selection"]], "Traveling Salesman Problem (TSP)": [[13, "traveling-salesman-problem-tsp"]], "Troubleshooting": [[3, "troubleshooting"]], "Two-Opt Mutation": [[6, "two-opt-mutation"]], "Two-Point Crossover": [[14, "two-point-crossover"]], "Unfair Average Crossover": [[14, "unfair-average-crossover"]], "Uniform Crossover": [[14, "uniform-crossover"]], "Uniform Float Mutation": [[6, "uniform-float-mutation"]], "Uninstallation": [[3, "uninstallation"]], "Usage": [[17, "usage"]], "Usage Examples": [[17, null]], "Verifying the Installation": [[3, "verifying-the-installation"]], "Ways to Contribute": [[1, "ways-to-contribute"]], "Zakharov Function": [[10, "zakharov-function"]], "Zettle Function": [[10, "zettle-function"]], "cga (Cellular Genetic Algorithm)": [[17, "cga-cellular-genetic-algorithm"]], "pycellga: A Comprehensive Guide": [[4, null]], "setup module": [[16, null]]}, "docnames": ["citing", "contributing", "index", "installation", "pycellga", "pycellga.example", "pycellga.mutation", "pycellga.neighborhoods", "pycellga.problems", "pycellga.problems.single_objective", "pycellga.problems.single_objective.continuous", "pycellga.problems.single_objective.discrete", "pycellga.problems.single_objective.discrete.binary", "pycellga.problems.single_objective.discrete.permutation", "pycellga.recombination", "pycellga.selection", "setup", "usage_examples"], "envversion": {"sphinx": 62, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.todo": 2, "sphinx.ext.viewcode": 1}, "filenames": ["citing.rst", "contributing.rst", "index.rst", "installation.rst", "pycellga.rst", "pycellga.example.rst", "pycellga.mutation.rst", "pycellga.neighborhoods.rst", "pycellga.problems.rst", "pycellga.problems.single_objective.rst", "pycellga.problems.single_objective.continuous.rst", "pycellga.problems.single_objective.discrete.rst", "pycellga.problems.single_objective.discrete.binary.rst", "pycellga.problems.single_objective.discrete.permutation.rst", "pycellga.recombination.rst", "pycellga.selection.rst", "setup.rst", "usage_examples.rst"], "indexentries": {"__init__() (abstractproblem method)": [[8, "pycellga.problems.abstract_problem.AbstractProblem.__init__", false]], "__init__() (ackley method)": [[10, "pycellga.problems.single_objective.continuous.ackley.Ackley.__init__", false]], "__init__() (arithmeticcrossover method)": [[14, "pycellga.recombination.arithmetic_crossover.ArithmeticCrossover.__init__", false]], "__init__() (bentcigar method)": [[10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.__init__", false]], "__init__() (bitflipmutation method)": [[6, "pycellga.mutation.bit_flip_mutation.BitFlipMutation.__init__", false]], "__init__() (blxalphacrossover method)": [[14, "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover.__init__", false]], "__init__() (bohachevsky method)": [[10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.__init__", false]], "__init__() (bytemutation method)": [[6, "pycellga.mutation.byte_mutation.ByteMutation.__init__", false]], "__init__() (bytemutationrandom method)": [[6, "pycellga.mutation.byte_mutation_random.ByteMutationRandom.__init__", false]], "__init__() (byteonepointcrossover method)": [[14, "pycellga.recombination.byte_one_point_crossover.ByteOnePointCrossover.__init__", false]], "__init__() (byteuniformcrossover method)": [[14, "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover.__init__", false]], "__init__() (chichinadze method)": [[10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.__init__", false]], "__init__() (compact13 method)": [[7, "pycellga.neighborhoods.compact_13.Compact13.__init__", false]], "__init__() (compact21 method)": [[7, "pycellga.neighborhoods.compact_21.Compact21.__init__", false]], "__init__() (compact25 method)": [[7, "pycellga.neighborhoods.compact_25.Compact25.__init__", false]], "__init__() (compact9 method)": [[7, "pycellga.neighborhoods.compact_9.Compact9.__init__", false]], "__init__() (countsat method)": [[12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat.__init__", false]], "__init__() (dropwave method)": [[10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave.__init__", false]], "__init__() (ecc method)": [[12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc.__init__", false]], "__init__() (exampleproblem method)": [[5, "pycellga.example.example_alpha_cga.ExampleProblem.__init__", false], [5, "pycellga.example.example_ccga.ExampleProblem.__init__", false], [5, "pycellga.example.example_cga.ExampleProblem.__init__", false], [5, "pycellga.example.example_sync_cga.ExampleProblem.__init__", false]], "__init__() (flatcrossover method)": [[14, "pycellga.recombination.flat_crossover.FlatCrossover.__init__", false]], "__init__() (floatuniformmutation method)": [[6, "pycellga.mutation.float_uniform_mutation.FloatUniformMutation.__init__", false]], "__init__() (fms method)": [[10, "pycellga.problems.single_objective.continuous.fms.Fms.__init__", false], [12, "pycellga.problems.single_objective.discrete.binary.fms.Fms.__init__", false]], "__init__() (grid method)": [[4, "pycellga.grid.Grid.__init__", false]], "__init__() (griewank method)": [[10, "pycellga.problems.single_objective.continuous.griewank.Griewank.__init__", false]], "__init__() (holzman method)": [[10, "pycellga.problems.single_objective.continuous.holzman.Holzman.__init__", false]], "__init__() (individual method)": [[4, "pycellga.individual.Individual.__init__", false]], "__init__() (insertionmutation method)": [[6, "pycellga.mutation.insertion_mutation.InsertionMutation.__init__", false]], "__init__() (levy method)": [[10, "pycellga.problems.single_objective.continuous.levy.Levy.__init__", false]], "__init__() (linear5 method)": [[7, "pycellga.neighborhoods.linear_5.Linear5.__init__", false]], "__init__() (linear9 method)": [[7, "pycellga.neighborhoods.linear_9.Linear9.__init__", false]], "__init__() (linearcrossover method)": [[14, "pycellga.recombination.linear_crossover.LinearCrossover.__init__", false]], "__init__() (matyas method)": [[10, "pycellga.problems.single_objective.continuous.matyas.Matyas.__init__", false]], "__init__() (maxcut100 method)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100.__init__", false]], "__init__() (maxcut20_01 method)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01.__init__", false]], "__init__() (maxcut20_09 method)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09.__init__", false]], "__init__() (mmdp method)": [[12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp.__init__", false]], "__init__() (onemax method)": [[12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax.__init__", false]], "__init__() (onepointcrossover method)": [[14, "pycellga.recombination.one_point_crossover.OnePointCrossover.__init__", false]], "__init__() (peak method)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.__init__", false]], "__init__() (pmxcrossover method)": [[14, "pycellga.recombination.pmx_crossover.PMXCrossover.__init__", false]], "__init__() (population method)": [[4, "pycellga.population.Population.__init__", false]], "__init__() (pow method)": [[10, "pycellga.problems.single_objective.continuous.pow.Pow.__init__", false]], "__init__() (powell method)": [[10, "pycellga.problems.single_objective.continuous.powell.Powell.__init__", false]], "__init__() (rastrigin method)": [[10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin.__init__", false]], "__init__() (realproblem method)": [[5, "pycellga.example.example_mcccga.RealProblem.__init__", false]], "__init__() (rosenbrock method)": [[10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock.__init__", false]], "__init__() (rothellipsoid method)": [[10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid.__init__", false]], "__init__() (roulettewheelselection method)": [[15, "pycellga.selection.roulette_wheel_selection.RouletteWheelSelection.__init__", false]], "__init__() (schaffer method)": [[10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer.__init__", false]], "__init__() (schaffer2 method)": [[10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2.__init__", false]], "__init__() (schwefel method)": [[10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel.__init__", false]], "__init__() (shufflemutation method)": [[6, "pycellga.mutation.shuffle_mutation.ShuffleMutation.__init__", false]], "__init__() (sphere method)": [[10, "pycellga.problems.single_objective.continuous.sphere.Sphere.__init__", false]], "__init__() (styblinskitang method)": [[10, "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang.__init__", false]], "__init__() (sumofdifferentpowers method)": [[10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers.__init__", false]], "__init__() (swapmutation method)": [[6, "pycellga.mutation.swap_mutation.SwapMutation.__init__", false]], "__init__() (threehumps method)": [[10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps.__init__", false]], "__init__() (tournamentselection method)": [[15, "pycellga.selection.tournament_selection.TournamentSelection.__init__", false]], "__init__() (tsp method)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.__init__", false]], "__init__() (twooptmutation method)": [[6, "pycellga.mutation.two_opt_mutation.TwoOptMutation.__init__", false]], "__init__() (twopointcrossover method)": [[14, "pycellga.recombination.two_point_crossover.TwoPointCrossover.__init__", false]], "__init__() (unfairavaragecrossover method)": [[14, "pycellga.recombination.unfair_avarage_crossover.UnfairAvarageCrossover.__init__", false]], "__init__() (uniformcrossover method)": [[14, "pycellga.recombination.uniform_crossover.UniformCrossover.__init__", false]], "__init__() (zakharov method)": [[10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov.__init__", false]], "__init__() (zettle method)": [[10, "pycellga.problems.single_objective.continuous.zettle.Zettle.__init__", false]], "abstractproblem (class in pycellga.problems.abstract_problem)": [[8, "pycellga.problems.abstract_problem.AbstractProblem", false]], "ackley (class in pycellga.problems.single_objective.continuous.ackley)": [[10, "pycellga.problems.single_objective.continuous.ackley.Ackley", false]], "alpha_cga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.ALPHA_CGA", false]], "alpha_cga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.alpha_cga", false]], "arithmeticcrossover (class in pycellga.recombination.arithmetic_crossover)": [[14, "pycellga.recombination.arithmetic_crossover.ArithmeticCrossover", false]], "bentcigar (class in pycellga.problems.single_objective.continuous.bentcigar)": [[10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar", false]], "binary (genetype attribute)": [[4, "pycellga.individual.GeneType.BINARY", false]], "bitflipmutation (class in pycellga.mutation.bit_flip_mutation)": [[6, "pycellga.mutation.bit_flip_mutation.BitFlipMutation", false]], "bits_to_float() (in module pycellga.byte_operators)": [[4, "pycellga.byte_operators.bits_to_float", false]], "bits_to_floats() (in module pycellga.byte_operators)": [[4, "pycellga.byte_operators.bits_to_floats", false]], "blxalphacrossover (class in pycellga.recombination.blxalpha_crossover)": [[14, "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover", false]], "bohachevsky (class in pycellga.problems.single_objective.continuous.bohachevsky)": [[10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky", false]], "bounds (ackley attribute)": [[10, "pycellga.problems.single_objective.continuous.ackley.Ackley.bounds", false]], "bounds (bentcigar attribute)": [[10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.bounds", false]], "bounds (bohachevsky attribute)": [[10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.bounds", false]], "bounds (chichinadze attribute)": [[10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.bounds", false]], "bounds (countsat attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat.bounds", false]], "bounds (dropwave attribute)": [[10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave.bounds", false]], "bounds (ecc attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc.bounds", false]], "bounds (fms attribute)": [[10, "pycellga.problems.single_objective.continuous.fms.Fms.bounds", false], [12, "pycellga.problems.single_objective.discrete.binary.fms.Fms.bounds", false]], "bounds (griewank attribute)": [[10, "pycellga.problems.single_objective.continuous.griewank.Griewank.bounds", false]], "bounds (holzman attribute)": [[10, "pycellga.problems.single_objective.continuous.holzman.Holzman.bounds", false]], "bounds (levy attribute)": [[10, "pycellga.problems.single_objective.continuous.levy.Levy.bounds", false]], "bounds (matyas attribute)": [[10, "pycellga.problems.single_objective.continuous.matyas.Matyas.bounds", false]], "bounds (mmdp attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp.bounds", false]], "bounds (onemax attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax.bounds", false]], "bounds (peak attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.bounds", false]], "bounds (pow attribute)": [[10, "pycellga.problems.single_objective.continuous.pow.Pow.bounds", false]], "bounds (powell attribute)": [[10, "pycellga.problems.single_objective.continuous.powell.Powell.bounds", false]], "bounds (rastrigin attribute)": [[10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin.bounds", false]], "bounds (rosenbrock attribute)": [[10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock.bounds", false]], "bounds (rothellipsoid attribute)": [[10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid.bounds", false]], "bounds (schaffer attribute)": [[10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer.bounds", false]], "bounds (schaffer2 attribute)": [[10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2.bounds", false]], "bounds (schwefel attribute)": [[10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel.bounds", false]], "bounds (sumofdifferentpowers attribute)": [[10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers.bounds", false]], "bounds (threehumps attribute)": [[10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps.bounds", false]], "bounds (tsp attribute)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.bounds", false]], "bounds (zakharov attribute)": [[10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov.bounds", false]], "bounds (zettle attribute)": [[10, "pycellga.problems.single_objective.continuous.zettle.Zettle.bounds", false]], "bytemutation (class in pycellga.mutation.byte_mutation)": [[6, "pycellga.mutation.byte_mutation.ByteMutation", false]], "bytemutationrandom (class in pycellga.mutation.byte_mutation_random)": [[6, "pycellga.mutation.byte_mutation_random.ByteMutationRandom", false]], "byteonepointcrossover (class in pycellga.recombination.byte_one_point_crossover)": [[14, "pycellga.recombination.byte_one_point_crossover.ByteOnePointCrossover", false]], "byteuniformcrossover (class in pycellga.recombination.byte_uniform_crossover)": [[14, "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover", false]], "calculate_neighbors_positions() (compact13 method)": [[7, "pycellga.neighborhoods.compact_13.Compact13.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (compact21 method)": [[7, "pycellga.neighborhoods.compact_21.Compact21.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (compact25 method)": [[7, "pycellga.neighborhoods.compact_25.Compact25.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (compact9 method)": [[7, "pycellga.neighborhoods.compact_9.Compact9.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (linear5 method)": [[7, "pycellga.neighborhoods.linear_5.Linear5.calculate_neighbors_positions", false]], "calculate_neighbors_positions() (linear9 method)": [[7, "pycellga.neighborhoods.linear_9.Linear9.calculate_neighbors_positions", false]], "ccga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.CCGA", false]], "ccga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.ccga", false]], "cga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.CGA", false]], "cga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.cga", false]], "ch_size (individual attribute)": [[4, "pycellga.individual.Individual.ch_size", false]], "ch_size (population attribute)": [[4, "pycellga.population.Population.ch_size", false]], "chichinadze (class in pycellga.problems.single_objective.continuous.chichinadze)": [[10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze", false]], "chromosome (individual attribute)": [[4, "pycellga.individual.Individual.chromosome", false]], "combine() (blxalphacrossover method)": [[14, "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover.combine", false]], "combine() (byteuniformcrossover method)": [[14, "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover.combine", false]], "combine() (flatcrossover method)": [[14, "pycellga.recombination.flat_crossover.FlatCrossover.combine", false]], "combine() (linearcrossover method)": [[14, "pycellga.recombination.linear_crossover.LinearCrossover.combine", false]], "combine() (uniformcrossover method)": [[14, "pycellga.recombination.uniform_crossover.UniformCrossover.combine", false]], "compact13 (class in pycellga.neighborhoods.compact_13)": [[7, "pycellga.neighborhoods.compact_13.Compact13", false]], "compact21 (class in pycellga.neighborhoods.compact_21)": [[7, "pycellga.neighborhoods.compact_21.Compact21", false]], "compact25 (class in pycellga.neighborhoods.compact_25)": [[7, "pycellga.neighborhoods.compact_25.Compact25", false]], "compact9 (class in pycellga.neighborhoods.compact_9)": [[7, "pycellga.neighborhoods.compact_9.Compact9", false]], "compete() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.compete", false]], "constraints (ackley attribute)": [[10, "pycellga.problems.single_objective.continuous.ackley.Ackley.constraints", false]], "constraints (bentcigar attribute)": [[10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.constraints", false]], "constraints (bohachevsky attribute)": [[10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.constraints", false]], "constraints (chichinadze attribute)": [[10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.constraints", false]], "constraints (fms attribute)": [[10, "pycellga.problems.single_objective.continuous.fms.Fms.constraints", false]], "constraints (griewank attribute)": [[10, "pycellga.problems.single_objective.continuous.griewank.Griewank.constraints", false]], "constraints (holzman attribute)": [[10, "pycellga.problems.single_objective.continuous.holzman.Holzman.constraints", false]], "constraints (levy attribute)": [[10, "pycellga.problems.single_objective.continuous.levy.Levy.constraints", false]], "constraints (mmdp attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp.constraints", false]], "constraints (onemax attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax.constraints", false]], "constraints (peak attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.constraints", false]], "constraints (tsp attribute)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.constraints", false]], "countsat (class in pycellga.problems.single_objective.discrete.binary.count_sat)": [[12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat", false]], "design_variables (ackley attribute)": [[10, "pycellga.problems.single_objective.continuous.ackley.Ackley.design_variables", false]], "design_variables (bentcigar attribute)": [[10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.design_variables", false]], "design_variables (bohachevsky attribute)": [[10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.design_variables", false]], "design_variables (chichinadze attribute)": [[10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.design_variables", false]], "design_variables (countsat attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat.design_variables", false]], "design_variables (dropwave attribute)": [[10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave.design_variables", false]], "design_variables (ecc attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc.design_variables", false]], "design_variables (fms attribute)": [[10, "pycellga.problems.single_objective.continuous.fms.Fms.design_variables", false], [12, "pycellga.problems.single_objective.discrete.binary.fms.Fms.design_variables", false]], "design_variables (griewank attribute)": [[10, "pycellga.problems.single_objective.continuous.griewank.Griewank.design_variables", false]], "design_variables (holzman attribute)": [[10, "pycellga.problems.single_objective.continuous.holzman.Holzman.design_variables", false]], "design_variables (levy attribute)": [[10, "pycellga.problems.single_objective.continuous.levy.Levy.design_variables", false]], "design_variables (matyas attribute)": [[10, "pycellga.problems.single_objective.continuous.matyas.Matyas.design_variables", false]], "design_variables (mmdp attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp.design_variables", false]], "design_variables (onemax attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax.design_variables", false]], "design_variables (peak attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.design_variables", false]], "design_variables (pow attribute)": [[10, "pycellga.problems.single_objective.continuous.pow.Pow.design_variables", false]], "design_variables (powell attribute)": [[10, "pycellga.problems.single_objective.continuous.powell.Powell.design_variables", false]], "design_variables (rastrigin attribute)": [[10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin.design_variables", false]], "design_variables (rosenbrock attribute)": [[10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock.design_variables", false]], "design_variables (rothellipsoid attribute)": [[10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid.design_variables", false]], "design_variables (schaffer attribute)": [[10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer.design_variables", false]], "design_variables (schaffer2 attribute)": [[10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2.design_variables", false]], "design_variables (schwefel attribute)": [[10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel.design_variables", false]], "design_variables (threehumps attribute)": [[10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps.design_variables", false]], "design_variables (tsp attribute)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.design_variables", false]], "design_variables (zakharov attribute)": [[10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov.design_variables", false]], "design_variables (zettle attribute)": [[10, "pycellga.problems.single_objective.continuous.zettle.Zettle.design_variables", false]], "dropwave (class in pycellga.problems.single_objective.continuous.dropwave)": [[10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave", false]], "ecc (class in pycellga.problems.single_objective.discrete.binary.ecc)": [[12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc", false]], "euclidean_dist() (tsp method)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.euclidean_dist", false]], "evaluate() (abstractproblem method)": [[8, "pycellga.problems.abstract_problem.AbstractProblem.evaluate", false]], "evaluate() (ackley method)": [[10, "id0", false], [10, "pycellga.problems.single_objective.continuous.ackley.Ackley.evaluate", false]], "evaluate() (bentcigar method)": [[10, "id2", false], [10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.evaluate", false]], "evaluate() (bohachevsky method)": [[10, "id4", false], [10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.evaluate", false]], "evaluate() (chichinadze method)": [[10, "id6", false], [10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.evaluate", false]], "evaluate() (countsat method)": [[12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat.evaluate", false]], "evaluate() (dropwave method)": [[10, "id8", false], [10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave.evaluate", false]], "evaluate() (fms method)": [[10, "id10", false], [10, "pycellga.problems.single_objective.continuous.fms.Fms.evaluate", false], [12, "pycellga.problems.single_objective.discrete.binary.fms.Fms.evaluate", false]], "evaluate() (griewank method)": [[10, "id12", false], [10, "pycellga.problems.single_objective.continuous.griewank.Griewank.evaluate", false]], "evaluate() (holzman method)": [[10, "id14", false], [10, "pycellga.problems.single_objective.continuous.holzman.Holzman.evaluate", false]], "evaluate() (levy method)": [[10, "id16", false], [10, "pycellga.problems.single_objective.continuous.levy.Levy.evaluate", false]], "evaluate() (matyas method)": [[10, "id18", false], [10, "pycellga.problems.single_objective.continuous.matyas.Matyas.evaluate", false]], "evaluate() (maxcut20_01 method)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01.evaluate", false]], "evaluate() (maxcut20_09 method)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09.evaluate", false]], "evaluate() (peak method)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.evaluate", false]], "evaluate() (pow method)": [[10, "id20", false], [10, "pycellga.problems.single_objective.continuous.pow.Pow.evaluate", false]], "evaluate() (powell method)": [[10, "id22", false], [10, "pycellga.problems.single_objective.continuous.powell.Powell.evaluate", false]], "evaluate() (rosenbrock method)": [[10, "id25", false], [10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock.evaluate", false]], "evaluate() (rothellipsoid method)": [[10, "id27", false], [10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid.evaluate", false]], "evaluate() (schaffer method)": [[10, "id29", false], [10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer.evaluate", false]], "evaluate() (schaffer2 method)": [[10, "id31", false], [10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2.evaluate", false]], "evaluate() (schwefel method)": [[10, "id33", false], [10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel.evaluate", false]], "evaluate() (sphere method)": [[10, "pycellga.problems.single_objective.continuous.sphere.Sphere.evaluate", false]], "evaluate() (styblinskitang method)": [[10, "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang.evaluate", false]], "evaluate() (sumofdifferentpowers method)": [[10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers.evaluate", false]], "evaluate() (threehumps method)": [[10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps.evaluate", false]], "evaluate() (zakharov method)": [[10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov.evaluate", false]], "exampleproblem (class in pycellga.example.example_alpha_cga)": [[5, "pycellga.example.example_alpha_cga.ExampleProblem", false]], "exampleproblem (class in pycellga.example.example_ccga)": [[5, "pycellga.example.example_ccga.ExampleProblem", false]], "exampleproblem (class in pycellga.example.example_cga)": [[5, "pycellga.example.example_cga.ExampleProblem", false]], "exampleproblem (class in pycellga.example.example_sync_cga)": [[5, "pycellga.example.example_sync_cga.ExampleProblem", false]], "f() (abstractproblem method)": [[8, "pycellga.problems.abstract_problem.AbstractProblem.f", false]], "f() (ackley method)": [[10, "id1", false], [10, "pycellga.problems.single_objective.continuous.ackley.Ackley.f", false]], "f() (bentcigar method)": [[10, "id3", false], [10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.f", false]], "f() (bohachevsky method)": [[10, "id5", false], [10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.f", false]], "f() (chichinadze method)": [[10, "id7", false], [10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.f", false]], "f() (countsat method)": [[12, "id0", false], [12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat.f", false]], "f() (dropwave method)": [[10, "id9", false], [10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave.f", false]], "f() (ecc method)": [[12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc.f", false]], "f() (exampleproblem method)": [[5, "pycellga.example.example_alpha_cga.ExampleProblem.f", false], [5, "pycellga.example.example_ccga.ExampleProblem.f", false], [5, "pycellga.example.example_cga.ExampleProblem.f", false], [5, "pycellga.example.example_sync_cga.ExampleProblem.f", false]], "f() (fms method)": [[10, "id11", false], [10, "pycellga.problems.single_objective.continuous.fms.Fms.f", false], [12, "id1", false], [12, "pycellga.problems.single_objective.discrete.binary.fms.Fms.f", false]], "f() (griewank method)": [[10, "id13", false], [10, "pycellga.problems.single_objective.continuous.griewank.Griewank.f", false]], "f() (holzman method)": [[10, "id15", false], [10, "pycellga.problems.single_objective.continuous.holzman.Holzman.f", false]], "f() (levy method)": [[10, "id17", false], [10, "pycellga.problems.single_objective.continuous.levy.Levy.f", false]], "f() (matyas method)": [[10, "id19", false], [10, "pycellga.problems.single_objective.continuous.matyas.Matyas.f", false]], "f() (maxcut100 method)": [[12, "id2", false], [12, "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100.f", false]], "f() (maxcut20_01 method)": [[12, "id3", false], [12, "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01.f", false]], "f() (maxcut20_09 method)": [[12, "id4", false], [12, "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09.f", false]], "f() (mmdp method)": [[12, "id5", false], [12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp.f", false]], "f() (onemax method)": [[12, "id6", false], [12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax.f", false]], "f() (peak method)": [[12, "id7", false], [12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.f", false]], "f() (pow method)": [[10, "id21", false], [10, "pycellga.problems.single_objective.continuous.pow.Pow.f", false]], "f() (powell method)": [[10, "id23", false], [10, "pycellga.problems.single_objective.continuous.powell.Powell.f", false]], "f() (rastrigin method)": [[10, "id24", false], [10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin.f", false]], "f() (realproblem method)": [[5, "pycellga.example.example_mcccga.RealProblem.f", false]], "f() (rosenbrock method)": [[10, "id26", false], [10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock.f", false]], "f() (rothellipsoid method)": [[10, "id28", false], [10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid.f", false]], "f() (schaffer method)": [[10, "id30", false], [10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer.f", false]], "f() (schaffer2 method)": [[10, "id32", false], [10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2.f", false]], "f() (schwefel method)": [[10, "id34", false], [10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel.f", false]], "f() (sphere method)": [[10, "pycellga.problems.single_objective.continuous.sphere.Sphere.f", false]], "f() (styblinskitang method)": [[10, "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang.f", false]], "f() (sumofdifferentpowers method)": [[10, "id35", false], [10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers.f", false]], "f() (threehumps method)": [[10, "id36", false], [10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps.f", false]], "f() (tsp method)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.f", false]], "f() (zakharov method)": [[10, "id37", false], [10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov.f", false]], "f() (zettle method)": [[10, "id38", false], [10, "pycellga.problems.single_objective.continuous.zettle.Zettle.f", false]], "fitness_value (individual attribute)": [[4, "pycellga.individual.Individual.fitness_value", false]], "flatcrossover (class in pycellga.recombination.flat_crossover)": [[14, "pycellga.recombination.flat_crossover.FlatCrossover", false]], "float_to_bits() (in module pycellga.byte_operators)": [[4, "pycellga.byte_operators.float_to_bits", false]], "floats_to_bits() (in module pycellga.byte_operators)": [[4, "pycellga.byte_operators.floats_to_bits", false]], "floatuniformmutation (class in pycellga.mutation.float_uniform_mutation)": [[6, "pycellga.mutation.float_uniform_mutation.FloatUniformMutation", false]], "fms (class in pycellga.problems.single_objective.continuous.fms)": [[10, "pycellga.problems.single_objective.continuous.fms.Fms", false]], "fms (class in pycellga.problems.single_objective.discrete.binary.fms)": [[12, "pycellga.problems.single_objective.discrete.binary.fms.Fms", false]], "gen_type (individual attribute)": [[4, "pycellga.individual.Individual.gen_type", false]], "gen_type (population attribute)": [[4, "pycellga.population.Population.gen_type", false]], "generate_candidate() (individual method)": [[4, "pycellga.individual.Individual.generate_candidate", false]], "generate_probability_vector() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.generate_probability_vector", false]], "genetype (class in pycellga.individual)": [[4, "pycellga.individual.GeneType", false]], "get_parents() (roulettewheelselection method)": [[15, "pycellga.selection.roulette_wheel_selection.RouletteWheelSelection.get_parents", false]], "get_parents() (tournamentselection method)": [[15, "pycellga.selection.tournament_selection.TournamentSelection.get_parents", false]], "get_recombinations() (arithmeticcrossover method)": [[14, "pycellga.recombination.arithmetic_crossover.ArithmeticCrossover.get_recombinations", false]], "get_recombinations() (blxalphacrossover method)": [[14, "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover.get_recombinations", false]], "get_recombinations() (byteonepointcrossover method)": [[14, "pycellga.recombination.byte_one_point_crossover.ByteOnePointCrossover.get_recombinations", false]], "get_recombinations() (byteuniformcrossover method)": [[14, "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover.get_recombinations", false]], "get_recombinations() (flatcrossover method)": [[14, "pycellga.recombination.flat_crossover.FlatCrossover.get_recombinations", false]], "get_recombinations() (linearcrossover method)": [[14, "pycellga.recombination.linear_crossover.LinearCrossover.get_recombinations", false]], "get_recombinations() (onepointcrossover method)": [[14, "pycellga.recombination.one_point_crossover.OnePointCrossover.get_recombinations", false]], "get_recombinations() (pmxcrossover method)": [[14, "pycellga.recombination.pmx_crossover.PMXCrossover.get_recombinations", false]], "get_recombinations() (twopointcrossover method)": [[14, "pycellga.recombination.two_point_crossover.TwoPointCrossover.get_recombinations", false]], "get_recombinations() (unfairavaragecrossover method)": [[14, "pycellga.recombination.unfair_avarage_crossover.UnfairAvarageCrossover.get_recombinations", false]], "get_recombinations() (uniformcrossover method)": [[14, "pycellga.recombination.uniform_crossover.UniformCrossover.get_recombinations", false]], "getneighbors() (individual method)": [[4, "pycellga.individual.Individual.getneighbors", false]], "getneighbors_positions() (individual method)": [[4, "pycellga.individual.Individual.getneighbors_positions", false]], "gographical_dist() (tsp method)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.gographical_dist", false]], "grid (class in pycellga.grid)": [[4, "pycellga.grid.Grid", false]], "griewank (class in pycellga.problems.single_objective.continuous.griewank)": [[10, "pycellga.problems.single_objective.continuous.griewank.Griewank", false]], "holzman (class in pycellga.problems.single_objective.continuous.holzman)": [[10, "pycellga.problems.single_objective.continuous.holzman.Holzman", false]], "individual (class in pycellga.individual)": [[4, "pycellga.individual.Individual", false]], "initial_population() (population method)": [[4, "pycellga.population.Population.initial_population", false]], "insertionmutation (class in pycellga.mutation.insertion_mutation)": [[6, "pycellga.mutation.insertion_mutation.InsertionMutation", false]], "levy (class in pycellga.problems.single_objective.continuous.levy)": [[10, "pycellga.problems.single_objective.continuous.levy.Levy", false]], "linear5 (class in pycellga.neighborhoods.linear_5)": [[7, "pycellga.neighborhoods.linear_5.Linear5", false]], "linear9 (class in pycellga.neighborhoods.linear_9)": [[7, "pycellga.neighborhoods.linear_9.Linear9", false]], "linearcrossover (class in pycellga.recombination.linear_crossover)": [[14, "pycellga.recombination.linear_crossover.LinearCrossover", false]], "make_2d_grid() (grid method)": [[4, "pycellga.grid.Grid.make_2d_grid", false]], "matyas (class in pycellga.problems.single_objective.continuous.matyas)": [[10, "pycellga.problems.single_objective.continuous.matyas.Matyas", false]], "maxcut100 (class in pycellga.problems.single_objective.discrete.binary.maxcut100)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100", false]], "maxcut20_01 (class in pycellga.problems.single_objective.discrete.binary.maxcut20_01)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01", false]], "maxcut20_09 (class in pycellga.problems.single_objective.discrete.binary.maxcut20_09)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09", false]], "mcccga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.MCCCGA", false]], "mcccga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.mcccga", false]], "method_name (population attribute)": [[4, "pycellga.population.Population.method_name", false]], "mmdp (class in pycellga.problems.single_objective.discrete.binary.mmdp)": [[12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp", false]], "module": [[4, "module-pycellga.byte_operators", false], [4, "module-pycellga.grid", false], [4, "module-pycellga.individual", false], [4, "module-pycellga.optimizer", false], [4, "module-pycellga.population", false], [5, "module-pycellga.example", false], [5, "module-pycellga.example.example_alpha_cga", false], [5, "module-pycellga.example.example_ccga", false], [5, "module-pycellga.example.example_cga", false], [5, "module-pycellga.example.example_mcccga", false], [5, "module-pycellga.example.example_sync_cga", false], [6, "module-pycellga.mutation.bit_flip_mutation", false], [6, "module-pycellga.mutation.byte_mutation", false], [6, "module-pycellga.mutation.byte_mutation_random", false], [6, "module-pycellga.mutation.float_uniform_mutation", false], [6, "module-pycellga.mutation.insertion_mutation", false], [6, "module-pycellga.mutation.shuffle_mutation", false], [6, "module-pycellga.mutation.swap_mutation", false], [6, "module-pycellga.mutation.two_opt_mutation", false], [7, "module-pycellga.neighborhoods.compact_13", false], [7, "module-pycellga.neighborhoods.compact_21", false], [7, "module-pycellga.neighborhoods.compact_25", false], [7, "module-pycellga.neighborhoods.compact_9", false], [7, "module-pycellga.neighborhoods.linear_5", false], [7, "module-pycellga.neighborhoods.linear_9", false], [8, "module-pycellga.problems.abstract_problem", false], [10, "module-pycellga.problems.single_objective.continuous.ackley", false], [10, "module-pycellga.problems.single_objective.continuous.bentcigar", false], [10, "module-pycellga.problems.single_objective.continuous.bohachevsky", false], [10, "module-pycellga.problems.single_objective.continuous.chichinadze", false], [10, "module-pycellga.problems.single_objective.continuous.dropwave", false], [10, "module-pycellga.problems.single_objective.continuous.fms", false], [10, "module-pycellga.problems.single_objective.continuous.griewank", false], [10, "module-pycellga.problems.single_objective.continuous.holzman", false], [10, "module-pycellga.problems.single_objective.continuous.levy", false], [10, "module-pycellga.problems.single_objective.continuous.matyas", false], [10, "module-pycellga.problems.single_objective.continuous.pow", false], [10, "module-pycellga.problems.single_objective.continuous.powell", false], [10, "module-pycellga.problems.single_objective.continuous.rastrigin", false], [10, "module-pycellga.problems.single_objective.continuous.rosenbrock", false], [10, "module-pycellga.problems.single_objective.continuous.rothellipsoid", false], [10, "module-pycellga.problems.single_objective.continuous.schaffer", false], [10, "module-pycellga.problems.single_objective.continuous.schaffer2", false], [10, "module-pycellga.problems.single_objective.continuous.schwefel", false], [10, "module-pycellga.problems.single_objective.continuous.sphere", false], [10, "module-pycellga.problems.single_objective.continuous.styblinskitang", false], [10, "module-pycellga.problems.single_objective.continuous.sumofdifferentpowers", false], [10, "module-pycellga.problems.single_objective.continuous.threehumps", false], [10, "module-pycellga.problems.single_objective.continuous.zakharov", false], [10, "module-pycellga.problems.single_objective.continuous.zettle", false], [12, "module-pycellga.problems.single_objective.discrete.binary.count_sat", false], [12, "module-pycellga.problems.single_objective.discrete.binary.ecc", false], [12, "module-pycellga.problems.single_objective.discrete.binary.fms", false], [12, "module-pycellga.problems.single_objective.discrete.binary.maxcut100", false], [12, "module-pycellga.problems.single_objective.discrete.binary.maxcut20_01", false], [12, "module-pycellga.problems.single_objective.discrete.binary.maxcut20_09", false], [12, "module-pycellga.problems.single_objective.discrete.binary.mmdp", false], [12, "module-pycellga.problems.single_objective.discrete.binary.one_max", false], [12, "module-pycellga.problems.single_objective.discrete.binary.peak", false], [13, "module-pycellga.problems.single_objective.discrete.permutation.tsp", false], [14, "module-pycellga.recombination.arithmetic_crossover", false], [14, "module-pycellga.recombination.blxalpha_crossover", false], [14, "module-pycellga.recombination.byte_one_point_crossover", false], [14, "module-pycellga.recombination.byte_uniform_crossover", false], [14, "module-pycellga.recombination.flat_crossover", false], [14, "module-pycellga.recombination.linear_crossover", false], [14, "module-pycellga.recombination.one_point_crossover", false], [14, "module-pycellga.recombination.pmx_crossover", false], [14, "module-pycellga.recombination.two_point_crossover", false], [14, "module-pycellga.recombination.unfair_avarage_crossover", false], [14, "module-pycellga.recombination.uniform_crossover", false], [15, "module-pycellga.selection.roulette_wheel_selection", false], [15, "module-pycellga.selection.tournament_selection", false]], "mutate() (bitflipmutation method)": [[6, "pycellga.mutation.bit_flip_mutation.BitFlipMutation.mutate", false]], "mutate() (bytemutation method)": [[6, "pycellga.mutation.byte_mutation.ByteMutation.mutate", false]], "mutate() (bytemutationrandom method)": [[6, "pycellga.mutation.byte_mutation_random.ByteMutationRandom.mutate", false]], "mutate() (floatuniformmutation method)": [[6, "pycellga.mutation.float_uniform_mutation.FloatUniformMutation.mutate", false]], "mutate() (insertionmutation method)": [[6, "pycellga.mutation.insertion_mutation.InsertionMutation.mutate", false]], "mutate() (shufflemutation method)": [[6, "pycellga.mutation.shuffle_mutation.ShuffleMutation.mutate", false]], "mutate() (swapmutation method)": [[6, "pycellga.mutation.swap_mutation.SwapMutation.mutate", false]], "mutate() (twooptmutation method)": [[6, "pycellga.mutation.two_opt_mutation.TwoOptMutation.mutate", false]], "n_cols (grid attribute)": [[4, "pycellga.grid.Grid.n_cols", false]], "n_cols (population attribute)": [[4, "pycellga.population.Population.n_cols", false]], "n_rows (grid attribute)": [[4, "pycellga.grid.Grid.n_rows", false]], "n_rows (population attribute)": [[4, "pycellga.population.Population.n_rows", false]], "n_var (sumofdifferentpowers attribute)": [[10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers.n_var", false]], "neighbors (individual attribute)": [[4, "pycellga.individual.Individual.neighbors", false]], "neighbors_positions (individual attribute)": [[4, "pycellga.individual.Individual.neighbors_positions", false]], "num_variables (dropwave attribute)": [[10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave.num_variables", false]], "objectives (ackley attribute)": [[10, "pycellga.problems.single_objective.continuous.ackley.Ackley.objectives", false]], "objectives (bentcigar attribute)": [[10, "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar.objectives", false]], "objectives (bohachevsky attribute)": [[10, "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky.objectives", false]], "objectives (chichinadze attribute)": [[10, "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze.objectives", false]], "objectives (countsat attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat.objectives", false]], "objectives (dropwave attribute)": [[10, "pycellga.problems.single_objective.continuous.dropwave.Dropwave.objectives", false]], "objectives (ecc attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.ecc.Ecc.objectives", false]], "objectives (fms attribute)": [[10, "pycellga.problems.single_objective.continuous.fms.Fms.objectives", false], [12, "pycellga.problems.single_objective.discrete.binary.fms.Fms.objectives", false]], "objectives (griewank attribute)": [[10, "pycellga.problems.single_objective.continuous.griewank.Griewank.objectives", false]], "objectives (holzman attribute)": [[10, "pycellga.problems.single_objective.continuous.holzman.Holzman.objectives", false]], "objectives (levy attribute)": [[10, "pycellga.problems.single_objective.continuous.levy.Levy.objectives", false]], "objectives (matyas attribute)": [[10, "pycellga.problems.single_objective.continuous.matyas.Matyas.objectives", false]], "objectives (mmdp attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp.objectives", false]], "objectives (onemax attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax.objectives", false]], "objectives (peak attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak.objectives", false]], "objectives (pow attribute)": [[10, "pycellga.problems.single_objective.continuous.pow.Pow.objectives", false]], "objectives (powell attribute)": [[10, "pycellga.problems.single_objective.continuous.powell.Powell.objectives", false]], "objectives (rastrigin attribute)": [[10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin.objectives", false]], "objectives (rosenbrock attribute)": [[10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock.objectives", false]], "objectives (rothellipsoid attribute)": [[10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid.objectives", false]], "objectives (schaffer attribute)": [[10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer.objectives", false]], "objectives (schaffer2 attribute)": [[10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2.objectives", false]], "objectives (schwefel attribute)": [[10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel.objectives", false]], "objectives (sumofdifferentpowers attribute)": [[10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers.objectives", false]], "objectives (threehumps attribute)": [[10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps.objectives", false]], "objectives (tsp attribute)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp.objectives", false]], "objectives (zakharov attribute)": [[10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov.objectives", false]], "objectives (zettle attribute)": [[10, "pycellga.problems.single_objective.continuous.zettle.Zettle.objectives", false]], "onemax (class in pycellga.problems.single_objective.discrete.binary.one_max)": [[12, "pycellga.problems.single_objective.discrete.binary.one_max.OneMax", false]], "onepointcrossover (class in pycellga.recombination.one_point_crossover)": [[14, "pycellga.recombination.one_point_crossover.OnePointCrossover", false]], "optimizationmethod (class in pycellga.population)": [[4, "pycellga.population.OptimizationMethod", false]], "peak (class in pycellga.problems.single_objective.discrete.binary.peak)": [[12, "pycellga.problems.single_objective.discrete.binary.peak.Peak", false]], "permutation (genetype attribute)": [[4, "pycellga.individual.GeneType.PERMUTATION", false]], "pmxcrossover (class in pycellga.recombination.pmx_crossover)": [[14, "pycellga.recombination.pmx_crossover.PMXCrossover", false]], "population (class in pycellga.population)": [[4, "pycellga.population.Population", false]], "position (individual attribute)": [[4, "pycellga.individual.Individual.position", false]], "pow (class in pycellga.problems.single_objective.continuous.pow)": [[10, "pycellga.problems.single_objective.continuous.pow.Pow", false]], "powell (class in pycellga.problems.single_objective.continuous.powell)": [[10, "pycellga.problems.single_objective.continuous.powell.Powell", false]], "problem (population attribute)": [[4, "pycellga.population.Population.problem", false]], "problema (maxcut100 attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100.problema", false]], "problema (maxcut20_01 attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01.problema", false]], "problema (maxcut20_09 attribute)": [[12, "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09.problema", false]], "pycellga.byte_operators": [[4, "module-pycellga.byte_operators", false]], "pycellga.example": [[5, "module-pycellga.example", false]], "pycellga.example.example_alpha_cga": [[5, "module-pycellga.example.example_alpha_cga", false]], "pycellga.example.example_ccga": [[5, "module-pycellga.example.example_ccga", false]], "pycellga.example.example_cga": [[5, "module-pycellga.example.example_cga", false]], "pycellga.example.example_mcccga": [[5, "module-pycellga.example.example_mcccga", false]], "pycellga.example.example_sync_cga": [[5, "module-pycellga.example.example_sync_cga", false]], "pycellga.grid": [[4, "module-pycellga.grid", false]], "pycellga.individual": [[4, "module-pycellga.individual", false]], "pycellga.mutation.bit_flip_mutation": [[6, "module-pycellga.mutation.bit_flip_mutation", false]], "pycellga.mutation.byte_mutation": [[6, "module-pycellga.mutation.byte_mutation", false]], "pycellga.mutation.byte_mutation_random": [[6, "module-pycellga.mutation.byte_mutation_random", false]], "pycellga.mutation.float_uniform_mutation": [[6, "module-pycellga.mutation.float_uniform_mutation", false]], "pycellga.mutation.insertion_mutation": [[6, "module-pycellga.mutation.insertion_mutation", false]], "pycellga.mutation.shuffle_mutation": [[6, "module-pycellga.mutation.shuffle_mutation", false]], "pycellga.mutation.swap_mutation": [[6, "module-pycellga.mutation.swap_mutation", false]], "pycellga.mutation.two_opt_mutation": [[6, "module-pycellga.mutation.two_opt_mutation", false]], "pycellga.neighborhoods.compact_13": [[7, "module-pycellga.neighborhoods.compact_13", false]], "pycellga.neighborhoods.compact_21": [[7, "module-pycellga.neighborhoods.compact_21", false]], "pycellga.neighborhoods.compact_25": [[7, "module-pycellga.neighborhoods.compact_25", false]], "pycellga.neighborhoods.compact_9": [[7, "module-pycellga.neighborhoods.compact_9", false]], "pycellga.neighborhoods.linear_5": [[7, "module-pycellga.neighborhoods.linear_5", false]], "pycellga.neighborhoods.linear_9": [[7, "module-pycellga.neighborhoods.linear_9", false]], "pycellga.optimizer": [[4, "module-pycellga.optimizer", false]], "pycellga.population": [[4, "module-pycellga.population", false]], "pycellga.problems.abstract_problem": [[8, "module-pycellga.problems.abstract_problem", false]], "pycellga.problems.single_objective.continuous.ackley": [[10, "module-pycellga.problems.single_objective.continuous.ackley", false]], "pycellga.problems.single_objective.continuous.bentcigar": [[10, "module-pycellga.problems.single_objective.continuous.bentcigar", false]], "pycellga.problems.single_objective.continuous.bohachevsky": [[10, "module-pycellga.problems.single_objective.continuous.bohachevsky", false]], "pycellga.problems.single_objective.continuous.chichinadze": [[10, "module-pycellga.problems.single_objective.continuous.chichinadze", false]], "pycellga.problems.single_objective.continuous.dropwave": [[10, "module-pycellga.problems.single_objective.continuous.dropwave", false]], "pycellga.problems.single_objective.continuous.fms": [[10, "module-pycellga.problems.single_objective.continuous.fms", false]], "pycellga.problems.single_objective.continuous.griewank": [[10, "module-pycellga.problems.single_objective.continuous.griewank", false]], "pycellga.problems.single_objective.continuous.holzman": [[10, "module-pycellga.problems.single_objective.continuous.holzman", false]], "pycellga.problems.single_objective.continuous.levy": [[10, "module-pycellga.problems.single_objective.continuous.levy", false]], "pycellga.problems.single_objective.continuous.matyas": [[10, "module-pycellga.problems.single_objective.continuous.matyas", false]], "pycellga.problems.single_objective.continuous.pow": [[10, "module-pycellga.problems.single_objective.continuous.pow", false]], "pycellga.problems.single_objective.continuous.powell": [[10, "module-pycellga.problems.single_objective.continuous.powell", false]], "pycellga.problems.single_objective.continuous.rastrigin": [[10, "module-pycellga.problems.single_objective.continuous.rastrigin", false]], "pycellga.problems.single_objective.continuous.rosenbrock": [[10, "module-pycellga.problems.single_objective.continuous.rosenbrock", false]], "pycellga.problems.single_objective.continuous.rothellipsoid": [[10, "module-pycellga.problems.single_objective.continuous.rothellipsoid", false]], "pycellga.problems.single_objective.continuous.schaffer": [[10, "module-pycellga.problems.single_objective.continuous.schaffer", false]], "pycellga.problems.single_objective.continuous.schaffer2": [[10, "module-pycellga.problems.single_objective.continuous.schaffer2", false]], "pycellga.problems.single_objective.continuous.schwefel": [[10, "module-pycellga.problems.single_objective.continuous.schwefel", false]], "pycellga.problems.single_objective.continuous.sphere": [[10, "module-pycellga.problems.single_objective.continuous.sphere", false]], "pycellga.problems.single_objective.continuous.styblinskitang": [[10, "module-pycellga.problems.single_objective.continuous.styblinskitang", false]], "pycellga.problems.single_objective.continuous.sumofdifferentpowers": [[10, "module-pycellga.problems.single_objective.continuous.sumofdifferentpowers", false]], "pycellga.problems.single_objective.continuous.threehumps": [[10, "module-pycellga.problems.single_objective.continuous.threehumps", false]], "pycellga.problems.single_objective.continuous.zakharov": [[10, "module-pycellga.problems.single_objective.continuous.zakharov", false]], "pycellga.problems.single_objective.continuous.zettle": [[10, "module-pycellga.problems.single_objective.continuous.zettle", false]], "pycellga.problems.single_objective.discrete.binary.count_sat": [[12, "module-pycellga.problems.single_objective.discrete.binary.count_sat", false]], "pycellga.problems.single_objective.discrete.binary.ecc": [[12, "module-pycellga.problems.single_objective.discrete.binary.ecc", false]], "pycellga.problems.single_objective.discrete.binary.fms": [[12, "module-pycellga.problems.single_objective.discrete.binary.fms", false]], "pycellga.problems.single_objective.discrete.binary.maxcut100": [[12, "module-pycellga.problems.single_objective.discrete.binary.maxcut100", false]], "pycellga.problems.single_objective.discrete.binary.maxcut20_01": [[12, "module-pycellga.problems.single_objective.discrete.binary.maxcut20_01", false]], "pycellga.problems.single_objective.discrete.binary.maxcut20_09": [[12, "module-pycellga.problems.single_objective.discrete.binary.maxcut20_09", false]], "pycellga.problems.single_objective.discrete.binary.mmdp": [[12, "module-pycellga.problems.single_objective.discrete.binary.mmdp", false]], "pycellga.problems.single_objective.discrete.binary.one_max": [[12, "module-pycellga.problems.single_objective.discrete.binary.one_max", false]], "pycellga.problems.single_objective.discrete.binary.peak": [[12, "module-pycellga.problems.single_objective.discrete.binary.peak", false]], "pycellga.problems.single_objective.discrete.permutation.tsp": [[13, "module-pycellga.problems.single_objective.discrete.permutation.tsp", false]], "pycellga.recombination.arithmetic_crossover": [[14, "module-pycellga.recombination.arithmetic_crossover", false]], "pycellga.recombination.blxalpha_crossover": [[14, "module-pycellga.recombination.blxalpha_crossover", false]], "pycellga.recombination.byte_one_point_crossover": [[14, "module-pycellga.recombination.byte_one_point_crossover", false]], "pycellga.recombination.byte_uniform_crossover": [[14, "module-pycellga.recombination.byte_uniform_crossover", false]], "pycellga.recombination.flat_crossover": [[14, "module-pycellga.recombination.flat_crossover", false]], "pycellga.recombination.linear_crossover": [[14, "module-pycellga.recombination.linear_crossover", false]], "pycellga.recombination.one_point_crossover": [[14, "module-pycellga.recombination.one_point_crossover", false]], "pycellga.recombination.pmx_crossover": [[14, "module-pycellga.recombination.pmx_crossover", false]], "pycellga.recombination.two_point_crossover": [[14, "module-pycellga.recombination.two_point_crossover", false]], "pycellga.recombination.unfair_avarage_crossover": [[14, "module-pycellga.recombination.unfair_avarage_crossover", false]], "pycellga.recombination.uniform_crossover": [[14, "module-pycellga.recombination.uniform_crossover", false]], "pycellga.selection.roulette_wheel_selection": [[15, "module-pycellga.selection.roulette_wheel_selection", false]], "pycellga.selection.tournament_selection": [[15, "module-pycellga.selection.tournament_selection", false]], "random_vector_between() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.random_vector_between", false]], "randomize() (individual method)": [[4, "pycellga.individual.Individual.randomize", false]], "rastrigin (class in pycellga.problems.single_objective.continuous.rastrigin)": [[10, "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin", false]], "real (genetype attribute)": [[4, "pycellga.individual.GeneType.REAL", false]], "realproblem (class in pycellga.example.example_mcccga)": [[5, "pycellga.example.example_mcccga.RealProblem", false]], "rosenbrock (class in pycellga.problems.single_objective.continuous.rosenbrock)": [[10, "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock", false]], "rothellipsoid (class in pycellga.problems.single_objective.continuous.rothellipsoid)": [[10, "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid", false]], "roulettewheelselection (class in pycellga.selection.roulette_wheel_selection)": [[15, "pycellga.selection.roulette_wheel_selection.RouletteWheelSelection", false]], "run_alpha_cga_example() (in module pycellga.example.example_alpha_cga)": [[5, "pycellga.example.example_alpha_cga.run_alpha_cga_example", false]], "run_ccga_example() (in module pycellga.example.example_ccga)": [[5, "pycellga.example.example_ccga.run_ccga_example", false]], "run_cga_example() (in module pycellga.example.example_cga)": [[5, "pycellga.example.example_cga.run_cga_example", false]], "run_mcccga_example() (in module pycellga.example.example_mcccga)": [[5, "pycellga.example.example_mcccga.run_mcccga_example", false]], "run_sync_cga_example() (in module pycellga.example.example_sync_cga)": [[5, "pycellga.example.example_sync_cga.run_sync_cga_example", false]], "sample() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.sample", false]], "schaffer (class in pycellga.problems.single_objective.continuous.schaffer)": [[10, "pycellga.problems.single_objective.continuous.schaffer.Schaffer", false]], "schaffer2 (class in pycellga.problems.single_objective.continuous.schaffer2)": [[10, "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2", false]], "schwefel (class in pycellga.problems.single_objective.continuous.schwefel)": [[10, "pycellga.problems.single_objective.continuous.schwefel.Schwefel", false]], "setneighbors() (individual method)": [[4, "pycellga.individual.Individual.setneighbors", false]], "setneighbors_positions() (individual method)": [[4, "pycellga.individual.Individual.setneighbors_positions", false]], "shufflemutation (class in pycellga.mutation.shuffle_mutation)": [[6, "pycellga.mutation.shuffle_mutation.ShuffleMutation", false]], "sphere (class in pycellga.problems.single_objective.continuous.sphere)": [[10, "pycellga.problems.single_objective.continuous.sphere.Sphere", false]], "styblinskitang (class in pycellga.problems.single_objective.continuous.styblinskitang)": [[10, "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang", false]], "sumofdifferentpowers (class in pycellga.problems.single_objective.continuous.sumofdifferentpowers)": [[10, "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers", false]], "swapmutation (class in pycellga.mutation.swap_mutation)": [[6, "pycellga.mutation.swap_mutation.SwapMutation", false]], "sync_cga() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.sync_cga", false]], "syncga (optimizationmethod attribute)": [[4, "pycellga.population.OptimizationMethod.SYNCGA", false]], "threehumps (class in pycellga.problems.single_objective.continuous.threehumps)": [[10, "pycellga.problems.single_objective.continuous.threehumps.Threehumps", false]], "tournamentselection (class in pycellga.selection.tournament_selection)": [[15, "pycellga.selection.tournament_selection.TournamentSelection", false]], "tsp (class in pycellga.problems.single_objective.discrete.permutation.tsp)": [[13, "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp", false]], "twooptmutation (class in pycellga.mutation.two_opt_mutation)": [[6, "pycellga.mutation.two_opt_mutation.TwoOptMutation", false]], "twopointcrossover (class in pycellga.recombination.two_point_crossover)": [[14, "pycellga.recombination.two_point_crossover.TwoPointCrossover", false]], "unfairavaragecrossover (class in pycellga.recombination.unfair_avarage_crossover)": [[14, "pycellga.recombination.unfair_avarage_crossover.UnfairAvarageCrossover", false]], "uniformcrossover (class in pycellga.recombination.uniform_crossover)": [[14, "pycellga.recombination.uniform_crossover.UniformCrossover", false]], "update_vector() (in module pycellga.optimizer)": [[4, "pycellga.optimizer.update_vector", false]], "vector (population attribute)": [[4, "pycellga.population.Population.vector", false]], "zakharov (class in pycellga.problems.single_objective.continuous.zakharov)": [[10, "pycellga.problems.single_objective.continuous.zakharov.Zakharov", false]], "zettle (class in pycellga.problems.single_objective.continuous.zettle)": [[10, "pycellga.problems.single_objective.continuous.zettle.Zettle", false]]}, "objects": {"pycellga": [[4, 0, 0, "-", "byte_operators"], [5, 0, 0, "-", "example"], [4, 0, 0, "-", "grid"], [4, 0, 0, "-", "individual"], [4, 0, 0, "-", "optimizer"], [4, 0, 0, "-", "population"]], "pycellga.byte_operators": [[4, 1, 1, "", "bits_to_float"], [4, 1, 1, "", "bits_to_floats"], [4, 1, 1, "", "float_to_bits"], [4, 1, 1, "", "floats_to_bits"]], "pycellga.example": [[5, 0, 0, "-", "example_alpha_cga"], [5, 0, 0, "-", "example_ccga"], [5, 0, 0, "-", "example_cga"], [5, 0, 0, "-", "example_mcccga"], [5, 0, 0, "-", "example_sync_cga"]], "pycellga.example.example_alpha_cga": [[5, 2, 1, "", "ExampleProblem"], [5, 1, 1, "", "run_alpha_cga_example"]], "pycellga.example.example_alpha_cga.ExampleProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.example.example_ccga": [[5, 2, 1, "", "ExampleProblem"], [5, 1, 1, "", "run_ccga_example"]], "pycellga.example.example_ccga.ExampleProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.example.example_cga": [[5, 2, 1, "", "ExampleProblem"], [5, 1, 1, "", "run_cga_example"]], "pycellga.example.example_cga.ExampleProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.example.example_mcccga": [[5, 2, 1, "", "RealProblem"], [5, 1, 1, "", "run_mcccga_example"]], "pycellga.example.example_mcccga.RealProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.example.example_sync_cga": [[5, 2, 1, "", "ExampleProblem"], [5, 1, 1, "", "run_sync_cga_example"]], "pycellga.example.example_sync_cga.ExampleProblem": [[5, 3, 1, "", "__init__"], [5, 3, 1, "", "f"]], "pycellga.grid": [[4, 2, 1, "", "Grid"]], "pycellga.grid.Grid": [[4, 3, 1, "", "__init__"], [4, 3, 1, "", "make_2d_grid"], [4, 4, 1, "", "n_cols"], [4, 4, 1, "", "n_rows"]], "pycellga.individual": [[4, 2, 1, "", "GeneType"], [4, 2, 1, "", "Individual"]], "pycellga.individual.GeneType": [[4, 4, 1, "", "BINARY"], [4, 4, 1, "", "PERMUTATION"], [4, 4, 1, "", "REAL"]], "pycellga.individual.Individual": [[4, 3, 1, "", "__init__"], [4, 4, 1, "", "ch_size"], [4, 4, 1, "", "chromosome"], [4, 4, 1, "", "fitness_value"], [4, 4, 1, "", "gen_type"], [4, 3, 1, "", "generate_candidate"], [4, 3, 1, "", "getneighbors"], [4, 3, 1, "", "getneighbors_positions"], [4, 4, 1, "", "neighbors"], [4, 4, 1, "", "neighbors_positions"], [4, 4, 1, "", "position"], [4, 3, 1, "", "randomize"], [4, 3, 1, "", "setneighbors"], [4, 3, 1, "", "setneighbors_positions"]], "pycellga.mutation": [[6, 0, 0, "-", "bit_flip_mutation"], [6, 0, 0, "-", "byte_mutation"], [6, 0, 0, "-", "byte_mutation_random"], [6, 0, 0, "-", "float_uniform_mutation"], [6, 0, 0, "-", "insertion_mutation"], [6, 0, 0, "-", "shuffle_mutation"], [6, 0, 0, "-", "swap_mutation"], [6, 0, 0, "-", "two_opt_mutation"]], "pycellga.mutation.bit_flip_mutation": [[6, 2, 1, "", "BitFlipMutation"]], "pycellga.mutation.bit_flip_mutation.BitFlipMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.byte_mutation": [[6, 2, 1, "", "ByteMutation"]], "pycellga.mutation.byte_mutation.ByteMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.byte_mutation_random": [[6, 2, 1, "", "ByteMutationRandom"]], "pycellga.mutation.byte_mutation_random.ByteMutationRandom": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.float_uniform_mutation": [[6, 2, 1, "", "FloatUniformMutation"]], "pycellga.mutation.float_uniform_mutation.FloatUniformMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.insertion_mutation": [[6, 2, 1, "", "InsertionMutation"]], "pycellga.mutation.insertion_mutation.InsertionMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.shuffle_mutation": [[6, 2, 1, "", "ShuffleMutation"]], "pycellga.mutation.shuffle_mutation.ShuffleMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.swap_mutation": [[6, 2, 1, "", "SwapMutation"]], "pycellga.mutation.swap_mutation.SwapMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.mutation.two_opt_mutation": [[6, 2, 1, "", "TwoOptMutation"]], "pycellga.mutation.two_opt_mutation.TwoOptMutation": [[6, 3, 1, "", "__init__"], [6, 3, 1, "", "mutate"]], "pycellga.neighborhoods": [[7, 0, 0, "-", "compact_13"], [7, 0, 0, "-", "compact_21"], [7, 0, 0, "-", "compact_25"], [7, 0, 0, "-", "compact_9"], [7, 0, 0, "-", "linear_5"], [7, 0, 0, "-", "linear_9"]], "pycellga.neighborhoods.compact_13": [[7, 2, 1, "", "Compact13"]], "pycellga.neighborhoods.compact_13.Compact13": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.compact_21": [[7, 2, 1, "", "Compact21"]], "pycellga.neighborhoods.compact_21.Compact21": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.compact_25": [[7, 2, 1, "", "Compact25"]], "pycellga.neighborhoods.compact_25.Compact25": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.compact_9": [[7, 2, 1, "", "Compact9"]], "pycellga.neighborhoods.compact_9.Compact9": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.linear_5": [[7, 2, 1, "", "Linear5"]], "pycellga.neighborhoods.linear_5.Linear5": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.neighborhoods.linear_9": [[7, 2, 1, "", "Linear9"]], "pycellga.neighborhoods.linear_9.Linear9": [[7, 3, 1, "", "__init__"], [7, 3, 1, "", "calculate_neighbors_positions"]], "pycellga.optimizer": [[4, 1, 1, "", "alpha_cga"], [4, 1, 1, "", "ccga"], [4, 1, 1, "", "cga"], [4, 1, 1, "", "compete"], [4, 1, 1, "", "generate_probability_vector"], [4, 1, 1, "", "mcccga"], [4, 1, 1, "", "random_vector_between"], [4, 1, 1, "", "sample"], [4, 1, 1, "", "sync_cga"], [4, 1, 1, "", "update_vector"]], "pycellga.population": [[4, 2, 1, "", "OptimizationMethod"], [4, 2, 1, "", "Population"]], "pycellga.population.OptimizationMethod": [[4, 4, 1, "", "ALPHA_CGA"], [4, 4, 1, "", "CCGA"], [4, 4, 1, "", "CGA"], [4, 4, 1, "", "MCCCGA"], [4, 4, 1, "", "SYNCGA"]], "pycellga.population.Population": [[4, 3, 1, "", "__init__"], [4, 4, 1, "", "ch_size"], [4, 4, 1, "", "gen_type"], [4, 3, 1, "", "initial_population"], [4, 4, 1, "", "method_name"], [4, 4, 1, "", "n_cols"], [4, 4, 1, "", "n_rows"], [4, 4, 1, "", "problem"], [4, 4, 1, "", "vector"]], "pycellga.problems": [[8, 0, 0, "-", "abstract_problem"]], "pycellga.problems.abstract_problem": [[8, 2, 1, "", "AbstractProblem"]], "pycellga.problems.abstract_problem.AbstractProblem": [[8, 3, 1, "", "__init__"], [8, 3, 1, "", "evaluate"], [8, 3, 1, "", "f"]], "pycellga.problems.single_objective.continuous": [[10, 0, 0, "-", "ackley"], [10, 0, 0, "-", "bentcigar"], [10, 0, 0, "-", "bohachevsky"], [10, 0, 0, "-", "chichinadze"], [10, 0, 0, "-", "dropwave"], [10, 0, 0, "-", "fms"], [10, 0, 0, "-", "griewank"], [10, 0, 0, "-", "holzman"], [10, 0, 0, "-", "levy"], [10, 0, 0, "-", "matyas"], [10, 0, 0, "-", "pow"], [10, 0, 0, "-", "powell"], [10, 0, 0, "-", "rastrigin"], [10, 0, 0, "-", "rosenbrock"], [10, 0, 0, "-", "rothellipsoid"], [10, 0, 0, "-", "schaffer"], [10, 0, 0, "-", "schaffer2"], [10, 0, 0, "-", "schwefel"], [10, 0, 0, "-", "sphere"], [10, 0, 0, "-", "styblinskitang"], [10, 0, 0, "-", "sumofdifferentpowers"], [10, 0, 0, "-", "threehumps"], [10, 0, 0, "-", "zakharov"], [10, 0, 0, "-", "zettle"]], "pycellga.problems.single_objective.continuous.ackley": [[10, 2, 1, "", "Ackley"]], "pycellga.problems.single_objective.continuous.ackley.Ackley": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "constraints"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id0", "evaluate"], [10, 3, 1, "id1", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.bentcigar": [[10, 2, 1, "", "Bentcigar"]], "pycellga.problems.single_objective.continuous.bentcigar.Bentcigar": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "constraints"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id2", "evaluate"], [10, 3, 1, "id3", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.bohachevsky": [[10, 2, 1, "", "Bohachevsky"]], "pycellga.problems.single_objective.continuous.bohachevsky.Bohachevsky": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "constraints"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id4", "evaluate"], [10, 3, 1, "id5", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.chichinadze": [[10, 2, 1, "", "Chichinadze"]], "pycellga.problems.single_objective.continuous.chichinadze.Chichinadze": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "constraints"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id6", "evaluate"], [10, 3, 1, "id7", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.dropwave": [[10, 2, 1, "", "Dropwave"]], "pycellga.problems.single_objective.continuous.dropwave.Dropwave": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id8", "evaluate"], [10, 3, 1, "id9", "f"], [10, 4, 1, "", "num_variables"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.fms": [[10, 2, 1, "", "Fms"]], "pycellga.problems.single_objective.continuous.fms.Fms": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "constraints"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id10", "evaluate"], [10, 3, 1, "id11", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.griewank": [[10, 2, 1, "", "Griewank"]], "pycellga.problems.single_objective.continuous.griewank.Griewank": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "constraints"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id12", "evaluate"], [10, 3, 1, "id13", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.holzman": [[10, 2, 1, "", "Holzman"]], "pycellga.problems.single_objective.continuous.holzman.Holzman": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "constraints"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id14", "evaluate"], [10, 3, 1, "id15", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.levy": [[10, 2, 1, "", "Levy"]], "pycellga.problems.single_objective.continuous.levy.Levy": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "constraints"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id16", "evaluate"], [10, 3, 1, "id17", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.matyas": [[10, 2, 1, "", "Matyas"]], "pycellga.problems.single_objective.continuous.matyas.Matyas": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id18", "evaluate"], [10, 3, 1, "id19", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.pow": [[10, 2, 1, "", "Pow"]], "pycellga.problems.single_objective.continuous.pow.Pow": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id20", "evaluate"], [10, 3, 1, "id21", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.powell": [[10, 2, 1, "", "Powell"]], "pycellga.problems.single_objective.continuous.powell.Powell": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id22", "evaluate"], [10, 3, 1, "id23", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.rastrigin": [[10, 2, 1, "", "Rastrigin"]], "pycellga.problems.single_objective.continuous.rastrigin.Rastrigin": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id24", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.rosenbrock": [[10, 2, 1, "", "Rosenbrock"]], "pycellga.problems.single_objective.continuous.rosenbrock.Rosenbrock": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id25", "evaluate"], [10, 3, 1, "id26", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.rothellipsoid": [[10, 2, 1, "", "Rothellipsoid"]], "pycellga.problems.single_objective.continuous.rothellipsoid.Rothellipsoid": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id27", "evaluate"], [10, 3, 1, "id28", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.schaffer": [[10, 2, 1, "", "Schaffer"]], "pycellga.problems.single_objective.continuous.schaffer.Schaffer": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id29", "evaluate"], [10, 3, 1, "id30", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.schaffer2": [[10, 2, 1, "", "Schaffer2"]], "pycellga.problems.single_objective.continuous.schaffer2.Schaffer2": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id31", "evaluate"], [10, 3, 1, "id32", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.schwefel": [[10, 2, 1, "", "Schwefel"]], "pycellga.problems.single_objective.continuous.schwefel.Schwefel": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id33", "evaluate"], [10, 3, 1, "id34", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.sphere": [[10, 2, 1, "", "Sphere"]], "pycellga.problems.single_objective.continuous.sphere.Sphere": [[10, 3, 1, "", "__init__"], [10, 3, 1, "", "evaluate"], [10, 3, 1, "", "f"]], "pycellga.problems.single_objective.continuous.styblinskitang": [[10, 2, 1, "", "StyblinskiTang"]], "pycellga.problems.single_objective.continuous.styblinskitang.StyblinskiTang": [[10, 3, 1, "", "__init__"], [10, 3, 1, "", "evaluate"], [10, 3, 1, "", "f"]], "pycellga.problems.single_objective.continuous.sumofdifferentpowers": [[10, 2, 1, "", "Sumofdifferentpowers"]], "pycellga.problems.single_objective.continuous.sumofdifferentpowers.Sumofdifferentpowers": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 3, 1, "", "evaluate"], [10, 3, 1, "id35", "f"], [10, 4, 1, "", "n_var"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.threehumps": [[10, 2, 1, "", "Threehumps"]], "pycellga.problems.single_objective.continuous.threehumps.Threehumps": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "", "evaluate"], [10, 3, 1, "id36", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.zakharov": [[10, 2, 1, "", "Zakharov"]], "pycellga.problems.single_objective.continuous.zakharov.Zakharov": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "", "evaluate"], [10, 3, 1, "id37", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.continuous.zettle": [[10, 2, 1, "", "Zettle"]], "pycellga.problems.single_objective.continuous.zettle.Zettle": [[10, 3, 1, "", "__init__"], [10, 4, 1, "", "bounds"], [10, 4, 1, "", "design_variables"], [10, 3, 1, "id38", "f"], [10, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.discrete.binary": [[12, 0, 0, "-", "count_sat"], [12, 0, 0, "-", "ecc"], [12, 0, 0, "-", "fms"], [12, 0, 0, "-", "maxcut100"], [12, 0, 0, "-", "maxcut20_01"], [12, 0, 0, "-", "maxcut20_09"], [12, 0, 0, "-", "mmdp"], [12, 0, 0, "-", "one_max"], [12, 0, 0, "-", "peak"]], "pycellga.problems.single_objective.discrete.binary.count_sat": [[12, 2, 1, "", "CountSat"]], "pycellga.problems.single_objective.discrete.binary.count_sat.CountSat": [[12, 3, 1, "", "__init__"], [12, 4, 1, "", "bounds"], [12, 4, 1, "", "design_variables"], [12, 3, 1, "", "evaluate"], [12, 3, 1, "id0", "f"], [12, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.discrete.binary.ecc": [[12, 2, 1, "", "Ecc"]], "pycellga.problems.single_objective.discrete.binary.ecc.Ecc": [[12, 3, 1, "", "__init__"], [12, 4, 1, "", "bounds"], [12, 4, 1, "", "design_variables"], [12, 3, 1, "", "f"], [12, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.discrete.binary.fms": [[12, 2, 1, "", "Fms"]], "pycellga.problems.single_objective.discrete.binary.fms.Fms": [[12, 3, 1, "", "__init__"], [12, 4, 1, "", "bounds"], [12, 4, 1, "", "design_variables"], [12, 3, 1, "", "evaluate"], [12, 3, 1, "id1", "f"], [12, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.discrete.binary.maxcut100": [[12, 2, 1, "", "Maxcut100"]], "pycellga.problems.single_objective.discrete.binary.maxcut100.Maxcut100": [[12, 3, 1, "", "__init__"], [12, 3, 1, "id2", "f"], [12, 4, 1, "", "problema"]], "pycellga.problems.single_objective.discrete.binary.maxcut20_01": [[12, 2, 1, "", "Maxcut20_01"]], "pycellga.problems.single_objective.discrete.binary.maxcut20_01.Maxcut20_01": [[12, 3, 1, "", "__init__"], [12, 3, 1, "", "evaluate"], [12, 3, 1, "id3", "f"], [12, 4, 1, "", "problema"]], "pycellga.problems.single_objective.discrete.binary.maxcut20_09": [[12, 2, 1, "", "Maxcut20_09"]], "pycellga.problems.single_objective.discrete.binary.maxcut20_09.Maxcut20_09": [[12, 3, 1, "", "__init__"], [12, 3, 1, "", "evaluate"], [12, 3, 1, "id4", "f"], [12, 4, 1, "", "problema"]], "pycellga.problems.single_objective.discrete.binary.mmdp": [[12, 2, 1, "", "Mmdp"]], "pycellga.problems.single_objective.discrete.binary.mmdp.Mmdp": [[12, 3, 1, "", "__init__"], [12, 4, 1, "", "bounds"], [12, 4, 1, "", "constraints"], [12, 4, 1, "", "design_variables"], [12, 3, 1, "id5", "f"], [12, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.discrete.binary.one_max": [[12, 2, 1, "", "OneMax"]], "pycellga.problems.single_objective.discrete.binary.one_max.OneMax": [[12, 3, 1, "", "__init__"], [12, 4, 1, "", "bounds"], [12, 4, 1, "", "constraints"], [12, 4, 1, "", "design_variables"], [12, 3, 1, "id6", "f"], [12, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.discrete.binary.peak": [[12, 2, 1, "", "Peak"]], "pycellga.problems.single_objective.discrete.binary.peak.Peak": [[12, 3, 1, "", "__init__"], [12, 4, 1, "", "bounds"], [12, 4, 1, "", "constraints"], [12, 4, 1, "", "design_variables"], [12, 3, 1, "", "evaluate"], [12, 3, 1, "id7", "f"], [12, 4, 1, "", "objectives"]], "pycellga.problems.single_objective.discrete.permutation": [[13, 0, 0, "-", "tsp"]], "pycellga.problems.single_objective.discrete.permutation.tsp": [[13, 2, 1, "", "Tsp"]], "pycellga.problems.single_objective.discrete.permutation.tsp.Tsp": [[13, 3, 1, "", "__init__"], [13, 4, 1, "", "bounds"], [13, 4, 1, "", "constraints"], [13, 4, 1, "", "design_variables"], [13, 3, 1, "", "euclidean_dist"], [13, 3, 1, "", "f"], [13, 3, 1, "", "gographical_dist"], [13, 4, 1, "", "objectives"]], "pycellga.recombination": [[14, 0, 0, "-", "arithmetic_crossover"], [14, 0, 0, "-", "blxalpha_crossover"], [14, 0, 0, "-", "byte_one_point_crossover"], [14, 0, 0, "-", "byte_uniform_crossover"], [14, 0, 0, "-", "flat_crossover"], [14, 0, 0, "-", "linear_crossover"], [14, 0, 0, "-", "one_point_crossover"], [14, 0, 0, "-", "pmx_crossover"], [14, 0, 0, "-", "two_point_crossover"], [14, 0, 0, "-", "unfair_avarage_crossover"], [14, 0, 0, "-", "uniform_crossover"]], "pycellga.recombination.arithmetic_crossover": [[14, 2, 1, "", "ArithmeticCrossover"]], "pycellga.recombination.arithmetic_crossover.ArithmeticCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.blxalpha_crossover": [[14, 2, 1, "", "BlxalphaCrossover"]], "pycellga.recombination.blxalpha_crossover.BlxalphaCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.byte_one_point_crossover": [[14, 2, 1, "", "ByteOnePointCrossover"]], "pycellga.recombination.byte_one_point_crossover.ByteOnePointCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.byte_uniform_crossover": [[14, 2, 1, "", "ByteUniformCrossover"]], "pycellga.recombination.byte_uniform_crossover.ByteUniformCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.flat_crossover": [[14, 2, 1, "", "FlatCrossover"]], "pycellga.recombination.flat_crossover.FlatCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.linear_crossover": [[14, 2, 1, "", "LinearCrossover"]], "pycellga.recombination.linear_crossover.LinearCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.one_point_crossover": [[14, 2, 1, "", "OnePointCrossover"]], "pycellga.recombination.one_point_crossover.OnePointCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.pmx_crossover": [[14, 2, 1, "", "PMXCrossover"]], "pycellga.recombination.pmx_crossover.PMXCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.two_point_crossover": [[14, 2, 1, "", "TwoPointCrossover"]], "pycellga.recombination.two_point_crossover.TwoPointCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.unfair_avarage_crossover": [[14, 2, 1, "", "UnfairAvarageCrossover"]], "pycellga.recombination.unfair_avarage_crossover.UnfairAvarageCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "get_recombinations"]], "pycellga.recombination.uniform_crossover": [[14, 2, 1, "", "UniformCrossover"]], "pycellga.recombination.uniform_crossover.UniformCrossover": [[14, 3, 1, "", "__init__"], [14, 3, 1, "", "combine"], [14, 3, 1, "", "get_recombinations"]], "pycellga.selection": [[15, 0, 0, "-", "roulette_wheel_selection"], [15, 0, 0, "-", "tournament_selection"]], "pycellga.selection.roulette_wheel_selection": [[15, 2, 1, "", "RouletteWheelSelection"]], "pycellga.selection.roulette_wheel_selection.RouletteWheelSelection": [[15, 3, 1, "", "__init__"], [15, 3, 1, "", "get_parents"]], "pycellga.selection.tournament_selection": [[15, 2, 1, "", "TournamentSelection"]], "pycellga.selection.tournament_selection.TournamentSelection": [[15, 3, 1, "", "__init__"], [15, 3, 1, "", "get_parents"]]}, "objnames": {"0": ["py", "module", "Python module"], "1": ["py", "function", "Python function"], "2": ["py", "class", "Python class"], "3": ["py", "method", "Python method"], "4": ["py", "attribute", "Python attribute"]}, "objtypes": {"0": "py:module", "1": "py:function", "2": "py:class", "3": "py:method", "4": "py:attribute"}, "terms": {"": [0, 1, 4, 6, 8, 9, 10, 12, 15, 17], "0": [4, 5, 6, 10, 11, 15, 17], "003791": 10, "01": 12, "0299": 10, "1": [0, 1, 4, 5, 6, 10, 11, 17], "10": [5, 10, 12], "100": [5, 10, 11, 17], "12": [7, 10], "13": 0, "14": 13, "144": 12, "15": 10, "192": 12, "2": [1, 4, 6, 10, 12, 15, 17], "20": [7, 11], "2013": [6, 14], "2024": 0, "24": 7, "240": 12, "2500": 0, "2514": 0, "2d": [4, 7], "3": [1, 3, 4, 10], "30": 10, "3159": 10, "32": [4, 10, 17], "4": [1, 4, 7, 10], "40": 12, "43": 10, "5": [4, 5, 6, 10, 17], "500": 10, "5x5": 5, "6": 12, "600": 10, "7": [3, 10], "754": 17, "768": [10, 17], "8": [1, 7], "9": [10, 11, 17], "90133": 10, "A": [0, 2, 5, 6, 7, 10, 12, 13, 14, 15], "Be": 1, "By": 8, "For": [0, 1, 3, 5], "If": [0, 1, 3, 4, 8, 10, 12, 17], "In": [4, 17], "It": [4, 6, 10, 12], "One": 11, "The": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "These": [4, 5, 7, 8, 9, 10, 11, 12, 13], "To": [1, 3, 17], "__init__": [4, 5, 6, 7, 8, 10, 12, 13, 14, 15, 17], "__version__": 3, "abc": 8, "abil": [10, 12], "abov": 17, "abstractproblem": [4, 6, 8, 10, 12, 13, 14], "account": 1, "accuraci": [8, 9, 10], "achiev": 5, "acklei": 9, "acknowledg": 0, "across": [6, 7, 8], "act": 15, "ad": [1, 6], "add": 1, "addit": 3, "address": [9, 10], "adher": 1, "adjac": 12, "adjust": 6, "akten": 0, "algorithm": [0, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], "alia": 10, "all": [1, 5, 10, 12, 17], "allow": [2, 4, 6, 7, 14], "along": [7, 17], "alpha": [2, 4, 5], "alpha_cga": [4, 5], "also": 0, "alter": 6, "altern": 5, "among": 7, "an": [0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 17], "ani": [1, 3, 8, 10, 12], "annot": 1, "apa": 0, "appli": [0, 6, 8, 14, 17], "applic": [5, 7], "approach": [6, 10], "ar": [1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 17], "arg": [8, 10, 12], "argument": 1, "arithmet": 17, "arithmeticcrossov": 14, "around": [6, 14], "arrai": [5, 8, 10, 12], "arrang": 7, "articl": 0, "aspect": 10, "assess": [9, 12], "attribut": [4, 13], "author": 0, "automata": 2, "avail": [10, 17], "b": [1, 13], "back": 4, "balanc": [2, 10, 15], "base": [4, 5, 7, 9, 10, 12, 14, 15], "basic": [5, 17], "befor": [1, 3], "begin": 1, "being": [5, 15], "below": [5, 10, 17], "benchmark": [8, 9, 10, 11, 12, 13], "benefici": [7, 15], "bent": 9, "bentcigar": 10, "besid": 2, "best": [4, 5, 15, 17], "better": [1, 4, 17], "between": [2, 4, 10, 12, 13, 14], "bia": 14, "bibtex": 0, "binari": [4, 5, 6, 9, 14, 17], "bit": [4, 12], "bit_list": 4, "bitflipmut": 6, "bits_to_float": 4, "bitwis": 6, "block": 4, "blxalphacrossov": 14, "bohachevski": 9, "both": [4, 8, 10, 11, 14], "bound": [8, 10, 12, 13], "boundari": 4, "branch": 1, "bring": 1, "broader": [6, 7], "brows": 1, "bug": 1, "bugfix": 1, "build": 4, "burma14": 13, "button": 1, "byte": [2, 5, 17], "bytemut": 6, "bytemutationrandom": [6, 17], "byteonepointcrossov": [14, 17], "byteuniformcrossov": 14, "c": 15, "calcul": [4, 7, 10, 12, 14], "calculate_neighbors_posit": 7, "callabl": 4, "camel": 10, "can": [1, 3, 7, 8, 17], "candid": [4, 6], "capabl": 10, "case": [4, 10, 12, 13], "ccga": [4, 5], "cd": [1, 3], "cell": [4, 7], "cellular": [0, 2, 4, 5, 7], "center": 10, "certain": 3, "cga": [2, 4, 5, 7], "ch_size": [4, 17], "challeng": [9, 10, 12], "chanc": 15, "chang": [1, 6], "character": [10, 12], "checkout": 1, "chicago": 0, "chichinadz": 9, "choic": 6, "chosen": [14, 15], "chromosom": [4, 5, 6, 12, 13, 14, 17], "cigar": 9, "citat": 0, "cite": 2, "citi": 13, "clarifi": 1, "class": [1, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15], "classic": [6, 12, 13, 14], "clear": 1, "click": [1, 17], "clone": [1, 3], "cluster": 7, "co": 10, "code": [0, 2, 4, 5, 12, 14, 17], "codebas": [1, 10], "collect": [8, 9], "column": [4, 7], "com": [1, 3], "combin": [2, 4, 14], "combinatori": [6, 9, 11, 13], "command": 3, "commit": 1, "common": [8, 10], "commonli": [6, 8, 9, 10, 12, 14], "commun": [0, 1, 12], "compact": [2, 4, 5], "compact13": 7, "compact21": 7, "compact25": 7, "compact9": 7, "compat": [8, 10, 12], "compet": [4, 15], "complex": [2, 10], "compon": 8, "comprehens": [2, 5, 6], "comput": [5, 10, 13, 17], "configur": [5, 6], "connect": 12, "consid": [1, 7], "consist": [1, 8], "constrain": 5, "constraint": [8, 10, 12, 13], "contain": [4, 5, 11, 14, 15], "continu": [0, 6, 8, 17], "contribut": [0, 2], "control": [4, 14], "converg": [5, 7, 8, 9, 10, 15, 17], "convert": 4, "convex": 10, "coordin": [10, 13], "copi": [1, 14], "core": 5, "corner": 1, "correct": 12, "correctli": 3, "correspond": [5, 17], "count": 11, "countsat": 12, "cover": 1, "creat": [0, 1, 4, 6, 8, 14], "crossov": [4, 15, 17], "custom": 8, "cut": 11, "d": 10, "data": 4, "dataset": 13, "date": 3, "deal": 10, "deceiv": 12, "decept": 11, "decim": [6, 10, 12, 13], "decod": [4, 17], "decrement": 6, "def": 17, "default": [4, 6, 8, 10, 12, 13], "defin": [4, 6, 7, 8, 10, 12, 14, 17], "definit": 4, "degre": 6, "demonstr": 5, "dens": 7, "denser": 12, "densiti": 11, "depend": [1, 7], "depth": 4, "descript": [1, 4], "design": [6, 8, 9, 10, 11, 12, 13, 14], "design_vari": [8, 10, 12, 13], "desir": [6, 7], "detail": [1, 3], "determin": [4, 7, 15], "develop": 0, "dict": [8, 10, 12], "dictionari": [8, 10, 12], "differ": [4, 5, 7, 9, 10, 11, 12, 14], "differenti": [9, 10], "difficulti": 10, "dimens": 10, "directli": [3, 15, 17], "directori": [1, 3], "discret": [8, 12, 13], "distanc": [12, 13], "divers": [2, 4, 6, 7, 9, 14, 15, 17], "docstr": 1, "document": [1, 5], "drive": [1, 12], "drop": 9, "dropwav": 10, "dure": [1, 2, 3, 4, 6, 15], "e": [4, 6, 8, 10, 12, 13], "each": [1, 2, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "easiest": 3, "ecc": 11, "edg": [7, 12], "effect": [4, 6, 14, 15], "effici": [4, 5, 10, 12, 13], "either": 6, "element": [4, 5, 6, 11, 12, 13, 17], "ellipsoid": 10, "empti": [4, 8, 10, 12], "enabl": 6, "encapsul": 4, "encod": [4, 5, 6, 11, 12, 14, 17], "encount": [1, 3, 12], "encourag": 7, "engin": 0, "enhanc": [1, 4, 5, 6, 7], "ensur": [1, 3, 4, 8, 17], "entri": 0, "enum": 4, "enumer": 4, "environ": 1, "equal": [5, 17], "error": [3, 12], "escap": [10, 12], "essenti": 7, "euclidean": 13, "euclidean_dist": 13, "evalu": [4, 8, 9, 10, 11, 12, 13], "even": 1, "evolutionari": 4, "evolv": 4, "exactli": 13, "exampl": [0, 1, 2, 3, 4, 8, 13], "example_alpha_cga": 5, "example_ccga": 5, "example_cga": 5, "example_mcccga": 5, "example_sync_cga": 5, "exampleproblem": 5, "exchang": [4, 14], "excit": 1, "execut": 4, "experiment": 10, "explain": 17, "exploit": [2, 10, 15], "explor": [2, 4, 5, 6, 7, 10, 14, 15, 17], "extend": 7, "f": [5, 8, 10, 12, 13, 17], "facilit": 7, "factor": 12, "featur": [1, 3, 12], "feedback": 1, "find": [12, 13, 17], "fine": [10, 14], "first": [4, 13, 14], "fit": [4, 6, 8, 10, 12, 13, 14, 15], "fitness_valu": 4, "five": 4, "fix": 1, "flat": 10, "flatcrossov": 14, "fletcher": 11, "flexibl": 8, "float": [4, 5, 8, 10, 12, 13, 17], "float_list": 4, "float_numb": 4, "float_to_bit": 4, "floats_to_bit": 4, "floatuniformmut": 6, "flow": 7, "fm": [9, 11], "focus": 11, "folder": [1, 17], "follow": [0, 1, 3, 6, 17], "fork": 1, "form": [4, 11], "format": [0, 12], "found": 4, "four": 12, "framework": [4, 5, 8, 10], "frequenc": [9, 12], "frequent": 6, "from": [1, 4, 6, 8, 14, 15, 17], "full": 5, "function": [1, 4, 5, 6, 8, 9, 12, 13, 14, 17], "fundament": 4, "g": [4, 8, 10, 12, 13], "gap": 4, "gen_typ": [4, 17], "gene": [4, 5, 6, 12, 14, 17], "gener": [4, 5, 12, 14, 17], "generate_candid": 4, "generate_probability_vector": 4, "genet": [0, 2, 4, 5, 6, 7, 8, 12, 14, 15], "genetyp": [4, 17], "genom": 4, "geo": 13, "geodes": 13, "geograph": 13, "get": [4, 15], "get_par": 15, "get_recombin": 14, "getneighbor": 4, "getneighbors_posit": 4, "git": [1, 3], "github": [1, 3], "given": [4, 5, 7, 10, 12, 13], "global": [5, 10, 17], "goal": [5, 10, 13, 17], "gographical_dist": 13, "googl": 1, "graph": 12, "grid": [2, 5, 7, 17], "griewank": 9, "guid": [1, 2], "h": 0, "ha": [2, 3, 10], "hakan": 0, "handl": [4, 9, 13], "harvard": 0, "have": [1, 3, 7, 12, 17], "help": [0, 1, 4, 17], "here": [1, 17], "high": 6, "higher": [3, 7, 14], "highlight": 5, "hint": 1, "hole": 10, "holzman": 9, "how": [5, 7, 15, 17], "http": [1, 3], "hump": 10, "hyper": 10, "hypercub": 10, "i": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "icga": 17, "idea": 1, "ideal": [6, 7, 9, 10], "identifi": 0, "ieee": 17, "illustr": 5, "immedi": 7, "impact": [0, 15], "implement": [1, 2, 4, 10, 12, 13, 15], "import": [3, 17], "improv": [0, 1, 2, 5, 17], "includ": [1, 4, 5, 6, 7, 8, 9, 11, 14, 17], "incorpor": 5, "increment": 6, "index": [3, 13, 15], "individu": [2, 5, 6, 7, 14, 15, 17], "inform": [7, 14], "inherit": 8, "initi": [4, 6, 7, 8, 10, 12, 13, 14, 15], "initial_popul": 4, "innov": 1, "input": [5, 8, 10, 12], "insertionmut": 6, "insight": 5, "instal": [1, 2], "instanc": [4, 5, 6, 14, 17], "instruct": 3, "int": [4, 5, 7, 8, 10, 12, 13, 15], "integ": [4, 8, 10, 12], "interact": [2, 4, 7, 17], "interest": 17, "interfac": [4, 8], "intermedi": 14, "introduc": 6, "invalu": 1, "invari": 10, "involv": [12, 13], "issu": [1, 3], "its": [2, 3, 4, 5, 7, 10, 12, 15, 17], "journal": 0, "jupyt": 3, "k": 15, "k_tournament": 4, "karakaya": 0, "karakaya2024improv": 0, "kei": [1, 8, 10, 15], "known": [4, 10, 13], "known_best": 4, "kwarg": [8, 10, 12], "landscap": [9, 10, 12, 15], "larg": 10, "larger": 7, "latex": 0, "layout": [4, 7], "lead": 14, "length": 12, "level": [4, 5, 7, 10, 14], "leverag": 6, "levi": 9, "li": 10, "librari": 4, "like": [2, 4], "limit": [7, 12], "line": 7, "linear5": 7, "linear9": 7, "linearcrossov": 14, "linearli": 14, "list": [4, 5, 7, 8, 10, 12, 13, 14, 15], "ll": [1, 17], "local": [1, 7, 10, 12], "locationsourc": 14, "look": 4, "lose": 4, "loser": 4, "low": 4, "lower": 10, "m": 0, "machin": [0, 1, 2, 4, 5, 14, 17], "mai": 3, "main": [1, 4, 9], "maintain": [1, 2, 4, 7, 10, 14, 15, 17], "make": [1, 3, 10], "make_2d_grid": 4, "male": [2, 4, 5], "manag": [3, 7, 8, 12], "manipul": 6, "map": 14, "massiv": 12, "matplotlib": 3, "matrix": 12, "matya": 9, "max": [4, 5, 8, 10, 11, 13, 17], "maxcut": 12, "maxcut100": 12, "maxcut20_01": 12, "maxcut20_09": 12, "maxim": [5, 8, 10, 12, 13], "maximum": [4, 12, 17], "mcc": 5, "mcccga": [4, 5], "mccga": 4, "meaning": 1, "mechan": [4, 5, 15], "mehmet": 0, "memori": [4, 5], "merg": 1, "messag": 1, "method": [4, 5, 8, 10, 14, 15, 17], "method_nam": 4, "min": [4, 5, 8, 10, 12, 13, 17], "minim": [5, 8, 10, 12, 13, 17], "minima": 10, "minimum": [4, 5, 10, 13, 17], "mix": 14, "mla": 0, "mmdp": 11, "modal": 11, "moder": 7, "modifi": 10, "modul": [6, 7, 8, 9, 12, 13], "more": [4, 7, 14, 17], "move": 6, "mpmath": 17, "multi": [4, 8, 11], "multidimension": 10, "multimod": [10, 12, 15], "multipl": 12, "must": 4, "mutat": [4, 17], "mutation_cand": 6, "mutationoper": [4, 6], "n": 10, "n_col": [4, 7, 17], "n_gen": [4, 17], "n_row": [4, 7, 17], "n_var": 10, "name": [1, 4, 8, 10, 12, 13], "navig": [1, 3], "nbest": 17, "ndarrai": [5, 8, 10, 12], "nearli": 10, "necessari": 6, "need": [3, 8, 17], "neighbor": [2, 4, 7, 15, 17], "neighborhood": 4, "neighbors_posit": 4, "new": [1, 6], "node": [11, 13], "none": [4, 6, 10, 12], "nonlinear": 10, "normal": 12, "note": [10, 12, 13], "notebook": 3, "notimplementederror": 4, "ntri": 4, "num_vari": 10, "number": [0, 4, 5, 6, 7, 8, 10, 12, 15, 17], "numer": [10, 12], "numpi": [5, 8, 10, 12], "object": [4, 5, 6, 7, 10, 11, 12, 13, 14, 15], "occur": 3, "offer": [4, 6, 7, 10], "offspr": [4, 14], "often": [10, 12, 14], "onc": 13, "one": [1, 4, 6, 8, 13, 14], "onemax": 12, "onepointcrossov": 14, "ones": 12, "onli": [2, 8, 17], "open": 1, "oper": [0, 2, 17], "optim": [2, 3, 5, 6, 8, 14, 15, 17], "optima": [10, 12], "optimis": 0, "optimizationmethod": 4, "optimum": 12, "option": [4, 6, 8, 10, 12], "order": [6, 11, 13, 14], "organ": [2, 9], "origin": [10, 13], "other": [0, 17], "our": 1, "out": [8, 10, 12], "outer": 10, "output": [8, 10, 12], "over": [10, 14], "overview": 5, "own": 1, "p1": [4, 14], "p2": [4, 14], "p_crossov": [4, 17], "p_mutat": [4, 17], "packag": [0, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 17], "page": [0, 1], "pair": 14, "paramet": [4, 5, 6, 7, 8, 10, 12, 13, 14, 15], "parent": [4, 14, 15], "particularli": [6, 9, 11, 12, 13], "partit": 12, "pass": [1, 17], "path": 6, "pattern": 4, "peak": 11, "pep": 1, "perform": [4, 6, 9, 10, 11, 12, 14, 15], "permut": [4, 6, 9, 14, 17], "persist": 3, "pick": 1, "pip": [1, 3], "place": [6, 10, 12, 13], "plai": 15, "plan": 3, "pleas": [0, 1], "pmxcrossov": 14, "point": [6, 7, 10, 17], "pop_list": 15, "pop_siz": 4, "popul": [2, 5, 6, 7, 15, 17], "posit": [4, 6, 7, 14], "possibl": 13, "pow": 9, "powel": [9, 11], "power": [10, 17], "pp": 0, "practic": 5, "precis": 6, "predefin": 12, "prematur": 17, "present": 12, "preserv": 6, "prevent": 17, "principl": [2, 5], "print": [3, 17], "probabl": 4, "problem": [0, 2, 4, 5, 6, 7, 14, 15], "problema": 12, "probvector": 4, "process": [1, 2, 4, 6, 15], "produc": 14, "project": [0, 1], "promot": [2, 6, 7], "proport": 15, "proportion": 15, "provid": [1, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 17], "purpos": [6, 13, 14], "push": 1, "pw": 17, "pycellga": [0, 1, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "pymoo": [8, 10, 12], "pytest": 1, "python": [1, 2, 3, 4, 17], "qualnam": 4, "r": 1, "rais": 4, "random": [4, 14, 15, 17], "random_vector_between": 4, "randomli": [4, 6, 12, 14], "rang": [4, 6, 10, 12, 14], "rapid": 7, "rastrigin": 9, "re": [1, 17], "reach": [10, 17], "readabl": 1, "readi": [1, 17], "real": [0, 2, 4, 5, 6, 14, 17], "realproblem": 5, "rearrang": 6, "recombin": [4, 17], "recombinationoper": [4, 14], "recommend": 1, "refer": [0, 3, 5], "region": 10, "relat": 12, "relev": 4, "repeat": [4, 17], "replac": [4, 17], "repo": 1, "report": 1, "reposit": 6, "repositori": [1, 3, 17], "repres": [4, 5, 7, 9, 10, 11, 12, 13], "represent": [6, 14, 17], "requir": [1, 6, 7, 12], "research": 0, "respect": 4, "respond": 1, "respons": 1, "rest": [8, 10], "restrict": 4, "result": [3, 14, 17], "retain": 14, "return": [1, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15, 17], "revers": 6, "review": 1, "right": 1, "roadmap": 1, "robust": [8, 9, 10, 12], "role": 15, "rosenbrock": 9, "rotat": 10, "rotation": 10, "rothellipsoid": 9, "roulettewheelselect": 15, "round": [6, 10, 12, 13], "rout": 13, "row": [4, 7], "rug": 12, "run": [3, 4, 5, 17], "run_alpha_cga_exampl": 5, "run_ccga_exampl": 5, "run_cga_exampl": 5, "run_mcccga_exampl": 5, "run_sync_cga_exampl": 5, "salesman": [6, 11], "sampl": [4, 6], "sat": 11, "satisfact": 12, "satisfi": 12, "satman": [0, 6, 14], "scenario": 8, "schaffer": 9, "schaffer2": 9, "schedul": 6, "schwefel": 9, "scienc": 0, "scientif": 0, "search": [9, 10, 11, 12], "second": [4, 13, 14], "section": [3, 17], "see": [1, 17], "seed_par": [4, 17], "segment": [6, 14], "select": [1, 4, 6, 7, 17], "selectionoper": [4, 15], "self": 17, "sequenc": [6, 11, 13, 14], "sequenti": 7, "serv": [4, 6, 8, 14], "set": [1, 4, 5, 6, 8, 9, 10, 11, 12, 13], "setneighbor": 4, "setneighbors_posit": 4, "sevgi": 0, "sevgiakten": 3, "share": 7, "shortest": 13, "should": [1, 4], "shufflemut": 6, "signific": 6, "simpl": [5, 6, 10, 12, 17], "simplic": 15, "simultan": 5, "singl": [6, 10, 11, 12, 14], "single_object": [8, 9, 10, 11, 12, 13], "six": 10, "size": [4, 5, 7], "slight": 14, "small": 6, "smooth": [1, 9, 10], "smoothli": 1, "softwar": [0, 1], "solut": [1, 4, 5, 6, 8, 9, 10, 11, 12, 13, 17], "solv": [5, 12, 13], "some": [1, 10], "sound": [9, 12], "sourc": [4, 5, 6, 7, 8, 10, 12, 13, 14, 15], "space": [6, 9, 10, 11, 12], "spars": 12, "sparsiti": 12, "spatial": [2, 7], "special": 17, "specif": [4, 6, 7, 10, 11, 14], "specifi": [4, 5, 8, 10, 12, 14], "speed": [4, 8, 9, 10], "sphere": 9, "sqrt": 10, "squar": [5, 17], "standard": [5, 8, 13, 17], "start": [4, 15], "steep": 10, "step": [1, 3], "store": [8, 10, 12], "str": [4, 8, 10, 12], "strategi": 6, "string": [4, 8, 10, 11, 12], "structur": [2, 5, 7, 8, 9, 10, 17], "styblinski": 10, "styblinskitang": 9, "style": [0, 1], "submit": [1, 3], "subpackag": [8, 9, 11], "subproblem": 12, "subsequ": 6, "subset": [6, 15], "subtl": 6, "subtract": 6, "success": 3, "suggest": 1, "suitabl": [6, 7, 10, 12, 14], "sum": [5, 10, 12, 17], "sumofdifferentpow": 9, "support": [0, 1, 4], "suppos": 17, "sure": 3, "swap": 14, "swapmut": 6, "sync": [4, 5], "sync_cga": [4, 5], "syncga": 4, "synchron": [4, 5], "system": 12, "tailor": [6, 11], "take": 4, "tang": 10, "target": 12, "task": [6, 8, 11, 13], "techniqu": 14, "term": [8, 9, 10], "test": [4, 8, 9, 10, 11, 12, 13], "thank": 1, "them": 10, "thi": [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "third": 4, "those": [10, 12], "three": [4, 10, 12], "threehump": 9, "thrill": 1, "tightli": 7, "tip": 3, "titl": 0, "topologi": [2, 17], "total": [12, 13], "tournament": 4, "tournamentselect": [15, 17], "toward": 12, "tracker": 1, "tradit": 2, "trait": 14, "trap": 12, "travel": [6, 11], "trial": 4, "try": 3, "tsp": 11, "tune": 10, "tupl": [4, 5, 7, 8, 10, 12, 13], "tutori": 3, "two": [4, 9, 10, 13], "twooptmut": 6, "twopointcrossov": 14, "txt": 1, "type": [1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "typic": [10, 11, 12], "typo": 1, "u": 1, "understand": [1, 4], "unfairavaragecrossov": 14, "uniformcrossov": 14, "uniformli": 6, "unimod": 10, "uniqu": [6, 10, 12, 14], "up": [1, 3, 5], "updat": [4, 5], "update_vector": 4, "upgrad": 3, "upper": [1, 10], "us": [0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "usag": [2, 4, 5], "user": [0, 1, 4, 5, 7, 8], "usernam": 1, "usual": 10, "util": [2, 4, 5], "v": 1, "valu": [0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 14, 17], "variabl": [8, 10, 12, 13], "variant": [4, 5], "variat": 6, "variou": [0, 5, 7, 8, 10, 14, 15, 17], "vector": [4, 17], "verifi": 1, "version": [3, 5, 12], "via": 3, "visibl": 0, "visit": [1, 13], "visual": 3, "volum": 0, "wa": 4, "wai": 3, "want": 17, "wave": 9, "we": [1, 17], "weight": 12, "went": 0, "what": 1, "when": [1, 5, 6, 17], "where": [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17], "whether": 1, "which": [4, 5, 8, 10, 12, 14], "while": [6, 7, 17], "whose": 7, "why": 0, "wide": [10, 11, 13, 14, 15], "win": 4, "winner": 4, "wise": 6, "within": [4, 6, 7, 10, 12, 14], "without": 6, "work": [0, 11], "wrap": [6, 7], "wrapper": 10, "write": 1, "x": [4, 5, 7, 8, 10, 12, 13, 17], "x1": 10, "x2": 10, "x_i": 10, "xi": [10, 17], "y": [4, 7, 10], "year": 0, "yet": 6, "yield": 17, "you": [0, 1, 3, 17], "your": [0, 1], "zakharov": 9, "zettl": 9}, "titles": ["Citing", "Contributing", "PYCELLGA Documentation", "Installation", "pycellga: A Comprehensive Guide", "Example Implementations in pycellga", "Mutation Operators", "Neighborhood Operators", "Problem Definitions", "Single-Objective Optimization Problems", "Continuous Optimization Problems", "Discrete Optimization Problems", "Binary Optimization Problems", "Permutation-Based Optimization Problems", "Recombination Operators", "Selection Operators", "setup module", "Usage Examples"], "titleterms": {"0": 12, "1": 12, "100": 12, "13": 7, "20": 12, "21": 7, "25": 7, "5": 7, "9": [7, 12], "A": 4, "One": [12, 14], "abstract": 8, "acklei": 10, "algorithm": 17, "alpha": 14, "arithmet": 14, "avail": 5, "averag": 14, "base": [6, 8, 11, 13], "bent": 10, "binari": [11, 12], "bit": 6, "blx": 14, "bohachevski": 10, "byte": [4, 6, 14], "cellular": 17, "cga": 17, "chichinadz": 10, "cigar": 10, "cite": 0, "class": 17, "code": 1, "compact": 7, "comprehens": 4, "content": 2, "continu": [9, 10], "contribut": 1, "core": 4, "count": 12, "crossov": 14, "cut": 12, "decept": 12, "definit": 8, "densiti": 12, "depend": 3, "develop": 1, "discret": [9, 11], "document": 2, "drop": 10, "ecc": 12, "exampl": [5, 17], "exampleproblem": 17, "flat": 14, "fletcher": 12, "flip": 6, "float": 6, "fm": [10, 12], "frequenc": 10, "from": 3, "function": 10, "genet": 17, "grid": 4, "griewank": 10, "guid": 4, "guidelin": 1, "holzman": 10, "implement": 5, "individu": 4, "insert": 6, "instal": 3, "level": 6, "levi": 10, "linear": [7, 14], "manag": 4, "match": 14, "matya": 10, "max": 12, "mmdp": 12, "modal": 12, "modul": [4, 5, 10, 16], "multi": 12, "mutat": 6, "neighborhood": 7, "node": 12, "object": [8, 9], "oper": [4, 6, 7, 14, 15], "opt": 6, "optim": [4, 9, 10, 11, 12, 13], "option": 3, "partial": 14, "peak": 12, "permut": [11, 13], "pmx": 14, "point": 14, "popul": 4, "pow": 10, "powel": [10, 12], "problem": [8, 9, 10, 11, 12, 13, 17], "pull": 1, "pycellga": [2, 4, 5], "pypi": 3, "random": 6, "rastrigin": 10, "recombin": 14, "represent": 4, "request": 1, "requir": 3, "rosenbrock": 10, "rothellipsoid": 10, "roulett": 15, "run": 1, "salesman": 13, "sat": 12, "schaffer": 10, "schaffer2": 10, "schwefel": 10, "select": 15, "setup": [1, 16], "shuffl": 6, "singl": [8, 9], "sound": 10, "sourc": 3, "sphere": 10, "standard": 1, "structur": 4, "styblinskitang": 10, "sumofdifferentpow": 10, "swap": 6, "tabl": 2, "test": 1, "threehump": 10, "tournament": 15, "travel": 13, "troubleshoot": 3, "tsp": 13, "two": [6, 14], "unfair": 14, "uniform": [6, 14], "uninstal": 3, "usag": 17, "verifi": 3, "wai": 1, "wave": 10, "wheel": 15, "zakharov": 10, "zettl": 10}}) \ No newline at end of file