pyVolutionary 1.0.1__py3-none-any.whl

pyvolutionary/krill_herd/models.py

@@ -0,0 +1,62 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Krill(Agent):
+    induced_speed: list[float]
+    foraging_speed: list[float]
+
+
+class KrillHerdOptimizationConfig(BaseOptimizationConfig):
+    """
+    Krill Herd Optimization Configuration
+        n_max (float): maximum induced speed.\n
+        foraging_speed (float): Foraging speed.\n
+        diffusion_speed (float): maximum diffusion speed.\n
+        c_t (float): [0, 2] constant.\n
+        w_neighbour (float): [0, 1] inertia weights of the motion induced from neighbors.\n
+        w_foraging (float): [0, 1] inertia weights of the motion induced from foraging.\n
+        max_neighbours (int): maximum neighbors for neighbors effect.\n
+        crossover_rate (float): (0, 1) crossover probability.\n
+        mutation_rate (float): (0, 1) mutation probability.\n
+    """
+    n_max: float
+    foraging_speed: float
+    diffusion_speed: float
+    c_t: float
+    w_neighbour: float
+    w_foraging: float
+    max_neighbours: int
+    crossover_rate: float
+    mutation_rate: float
+
+    @field_validator("c_t")
+    def correct_c_t(cls, v):
+        if not 0 <= v <= 2:
+            raise ValueError(f"\"c_t\" must be a float in [0, 2]. Got {v}")
+        return v
+
+    @field_validator("w_neighbour")
+    def correct_w_neighbour(cls, v):
+        if not 0 <= v <= 1:
+            raise ValueError(f"\"w_neighbour\" must be a float in [0, 1]. Got {v}")
+        return v
+
+    @field_validator("w_foraging")
+    def correct_w_foraging(cls, v):
+        if not 0 <= v <= 1:
+            raise ValueError(f"\"w_foraging\" must be a float in [0, 1]. Got {v}")
+        return v
+
+    @field_validator("crossover_rate")
+    def correct_crossover_rate(cls, v):
+        if not 0 < v < 1:
+            raise ValueError(f"\"crossover_rate\" must be a float in (0, 1). Got {v}")
+        return v
+
+    @field_validator("mutation_rate")
+    def correct_mutation_rate(cls, v):
+        if not 0 < v < 1:
+            raise ValueError(f"\"mutation_rate\" must be a float in (0, 1). Got {v}")
+        return v

pyvolutionary/levi_jaya_swarm/__init__.py

@@ -0,0 +1,2 @@
+from .models import Jaya, LeviFlightJayaSwarmOptimizationConfig
+from .levy_flight_jaya_swarm_optimization import LeviFlightJayaSwarmOptimization

pyvolutionary/levi_jaya_swarm/levy_flight_jaya_swarm_optimization.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+from ..helpers import (
+    get_levy_flight_step,
+    parse_obj_doc  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import LeviFlightJayaSwarmOptimizationConfig
+
+
+class LeviFlightJayaSwarmOptimization(OptimizationAbstract):
+    """
+    Implementation of the Levy-Flight Jaya Swarm Optimization algorithm.
+
+    Args:
+        config (LeviFlightJayaSwarmOptimizationConfig): an instance of LeviFlightJayaSwarmOptimizationConfig class.
+            {parse_obj_doc(LeviFlightJayaSwarmOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Iacca, G., dos Santos Junior, V.C. and de Melo, V.V., 2021. An improved Jaya optimization
+        algorithm with Lévy flight. Expert Systems with Applications, 165, p.113902.
+    """
+    def __init__(self, config: LeviFlightJayaSwarmOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def optimization_step(self):
+        g_worst_pos = np.array(self._worst_agent.position)
+        for idx in range(0, self._config.population_size):
+            position = self._population[idx].position
+
+            L1 = get_levy_flight_step(multiplier=1.0, beta=1.8, case=-1)
+            L2 = get_levy_flight_step(multiplier=1.0, beta=1.8, case=-1)
+            pos_new = self._correct_position(
+                position + np.abs(L1) * (self._best_agent.position - np.abs(position)) - np.abs(L2) * (
+                    g_worst_pos - np.abs(position)
+                )
+            )
+            agent = self._init_agent(pos_new)
+            self._population[idx] = self._greedy_select_agent(self._population[idx], agent)

pyvolutionary/levi_jaya_swarm/models.py

@@ -0,0 +1,9 @@
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Jaya(Agent):
+    pass
+
+
+class LeviFlightJayaSwarmOptimizationConfig(BaseOptimizationConfig):
+    pass

pyvolutionary/models.py

@@ -0,0 +1,130 @@
+from abc import ABC, abstractmethod
+from dataclasses import field
+from typing import TypeVar, Any
+import numpy as np
+from pydantic import BaseModel, model_validator
+
+from .enums import TaskType
+
+
+class BaseOptimizationConfig(BaseModel):
+    population_size: int
+    fitness_error: float | None = None
+    max_cycles: int
+
+
+class Agent(BaseModel):
+    position: list[float]
+    cost: float
+    fitness: float
+
+
+class Population(BaseModel):
+    agents: list[Agent] = field(default_factory=list)
+
+    # initialize the agents by considering the task type: if it is a minimization task, each agent is accepted as is;
+    # otherwise, the position of each agent is multiplied by -1
+    def __init__(self, **data: Any):
+        def refine_agent(a: Agent, tt: TaskType) -> Agent:
+            if tt == TaskType.MIN:
+                return a
+            # return the agent with the position multiplied by -1
+            return a.model_copy(update={"cost": -a.cost})
+
+        task_type = data.get("task_type", TaskType.MIN)
+        agents = [refine_agent(a, task_type) for a in data.get("agents", [])]
+        data["agents"] = agents
+        super().__init__(**data)
+
+    def __iter__(self):
+        return iter(self.agents)
+
+    def __getitem__(self, item):
+        return self.agents[item]
+
+    def __setitem__(self, key, value):
+        self.agents[key] = value
+
+    def __len__(self):
+        return len(self.agents)
+
+    def __str__(self):
+        return str(self.agents)
+
+
+class OptimizationResult(BaseModel):
+    evolution: list[Population] = field(default_factory=list)
+    rates: list[float] = field(default_factory=list)
+    best_solution: Agent | None = None
+
+    # initialize the best_solution by considering the task type: if it is a minimization task, it is accepted as is;
+    # otherwise, the position is multiplied by -1
+    def __init__(self, **data: Any):
+        def refine_best_solution(a: Agent, tt: TaskType) -> Agent:
+            if tt == TaskType.MIN:
+                return a
+            # return the agent with the position multiplied by -1
+            return a.model_copy(update={"cost": -a.cost})
+
+        task_type = data.get("task_type", TaskType.MIN)
+        best_solution = data.get("best_solution")
+        if best_solution is not None:
+            data["best_solution"] = refine_best_solution(best_solution, task_type)
+        super().__init__(**data)
+
+
+class Variable(BaseModel, ABC):
+    name: str
+    value: Any | None = None
+
+    @abstractmethod
+    def randomize(self) -> None:
+        pass
+
+
+class ContinuousVariable(Variable):
+    lower_bound: float
+    upper_bound: float
+
+    @model_validator(mode="after")
+    def validate_bounds(self) -> "ContinuousVariable":
+        if self.upper_bound <= self.lower_bound:
+            raise ValueError("Upper bound must be greater than lower bound")
+        return self
+
+    def randomize(self) -> float:
+        self.value = np.random.uniform(self.lower_bound, self.upper_bound)
+        return self.value
+
+
+class DiscreteVariable(Variable):
+    choices: list[Any]
+
+    def randomize(self) -> int:
+        self.value = np.random.choice(range(0, len(self.choices)))
+        return self.value
+
+
+class Task(BaseModel, ABC):
+    seed: float | None = None
+    variables: list[Variable] = field(default_factory=list)
+    space_dimension: int
+    minmax: TaskType = TaskType.MIN
+
+    def __init__(self, **data: Any):
+        variables = data.get("variables", [])
+        data["space_dimension"] = len(variables)
+        super().__init__(**data)
+
+    @abstractmethod
+    def objective_function(self, x: list[float | int]) -> float:
+        pass
+
+    def transform_position(self, x: list[float | int]) -> dict[str, Any]:
+        return {
+            v.name: x[i] if isinstance(v, ContinuousVariable) else v.choices[int(x[i])]
+            for i, v in enumerate(self.variables)
+        }
+
+
+T = TypeVar("T", Agent, Agent)

pyvolutionary/monarch_butterfly/__init__.py

@@ -0,0 +1,2 @@
+from .models import MonarchButterfly, MonarchButterflyOptimizationConfig
+from .monarch_butterfly_optimization import MonarchButterflyOptimization

pyvolutionary/monarch_butterfly/models.py

@@ -0,0 +1,25 @@
+from pydantic import model_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class MonarchButterfly(Agent):
+    pass
+
+
+class MonarchButterflyOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Monarch Butterfly Optimization algorithm.
+        partition (float): the value of the partition.\n
+        period (float): the period as per the description in the original paper.\n
+        keep (int): elitism parameter: how many of the best habitats to keep from one generation to the next
+    """
+    partition: float
+    period: float
+    keep: int = 2
+
+    @model_validator(mode="after")
+    def validate_keep(self) -> "MonarchButterflyOptimizationConfig":
+        if not 2 <= self.keep < self.population_size / 2:
+            raise ValueError(f"keep must be between 2 and population_size / 2, got {self.keep}")
+        return self

pyvolutionary/monarch_butterfly/monarch_butterfly_optimization.py

@@ -0,0 +1,104 @@
+import numpy as np
+
+from ..helpers import (
+    get_levy_flight_step,
+    sort_and_trim,
+    sort_by_cost,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import MonarchButterfly, MonarchButterflyOptimizationConfig
+
+
+class MonarchButterflyOptimization(OptimizationAbstract):
+    """
+    Implementation of the Monarch Butterfly Optimization algorithm.
+
+    Args:
+        config (MonarchButterflyOptimizationConfig): an instance of MonarchButterflyOptimizationConfig class.
+            {parse_obj_doc(MonarchButterflyOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Wang, G. G., Deb, S., & Cui, Z. (2019). Monarch butterfly optimization. Neural computing and applications,
+        31(7), 1995-2014.
+    """
+    def __init__(self, config: MonarchButterflyOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__bar = self._config.partition
+        self.__np1 = int(np.ceil(self._config.partition * self._config.population_size))
+        self.__np2 = self._config.population_size - self.__np1
+
+    def __get_elite__(self) -> list[MonarchButterfly]:
+        """
+        Get the elite agents of the current generation. The elite agents are the best habitats of the current generation.
+        The best habitats are selected according to the cost value of the agents. The number of elite agents is defined
+        by the keep parameter. The keep parameter is defined in the configuration class. The keep parameter must be
+        between 2 and population_size / 2. If the keep parameter is not defined, the default value is 2.
+        :return: a list of elite agents.
+        :rtype: list[MonarchButterfly]
+        """
+        sort_by_cost(self._population)
+        return self._population[:self._config.keep].copy()
+
+    def __migration_operator__(self) -> list[MonarchButterfly]:
+        """
+        Apply the migration operator. This operator is applied to the best habitats of the current generation. The best
+        habitats are selected according to the cost value of the agents. The result of this operator is a new population
+        of agents.
+        :return: a new population of agents.
+        :rtype: list[MonarchButterfly]
+        """
+        r1 = np.random.random(size=self.__np1) * self._config.period
+        partition_condition = r1 <= self._config.partition
+        n_values = np.where(partition_condition, self.__np1, self.__np2)
+
+        pop_indices = np.round(n_values * np.random.random(size=self.__np1) + 0.5).astype(int).tolist()
+
+        return [
+            MonarchButterfly(**self._init_agent(self._population[idx].position).model_dump()) for idx in pop_indices
+        ]
+
+    def __adjusting_operator__(self) -> list[MonarchButterfly]:
+        """
+        Apply the adjusting operator. This operator is applied to the worst habitats of the current generation. The
+        worst habitats are selected according to the cost value of the agents. The result of this operator is a new
+        population of agents.
+        :return: a new population of agents.
+        :rtype: list[MonarchButterfly]
+        """
+        scale = 1.0 / ((self._cycles + 1) ** 2)
+        step_size = np.ceil(np.random.exponential(2 * self._config.max_cycles))
+        delta_x = get_levy_flight_step(beta=1., multiplier=step_size, size=self._task.space_dimension, case=1)
+
+        mask = np.random.uniform(0.0, 1.0, size=self.__np2) <= self._config.partition
+        indices = np.where(
+            mask, -1, np.round(self.__np2 * np.random.random(size=self.__np2) + 0.5).astype(int).tolist()
+        )
+
+        positions = [
+            self._best_agent.position
+            if idx == -1
+            else self._population[idx].position + scale * (delta_x - 0.5) * int(
+                np.random.uniform(0.0, 1.0) > self.__bar
+            )
+            for idx in indices]
+        return [MonarchButterfly(**self._init_agent(position).model_dump()) for position in positions]
+
+    def __elitism__(self, elite: list[MonarchButterfly], pop1: list[MonarchButterfly], pop2: list[MonarchButterfly]):
+        """
+        Apply the elitism operator. This operator is applied to the best habitats of the current generation. The best
+        habitats are selected according to the cost value of the agents. The number of elite agents is defined by the
+        keep parameter. The keep parameter is defined in the configuration class. The keep parameter must be between 2
+        and population_size / 2. If the keep parameter is not defined, the default value is 2. The elite agents are
+        added to the next generation. The rest of the agents are discarded.
+        """
+        self._population = sort_and_trim(pop1 + pop2, self._config.population_size - self._config.keep)
+        self._population.extend(elite)
+
+    def optimization_step(self):
+        elite = self.__get_elite__()
+        pop1 = self.__migration_operator__()
+        pop2 = self.__adjusting_operator__()
+
+        self.__elitism__(elite, pop1, pop2)

pyvolutionary/mountain_gazelle/__init__.py

@@ -0,0 +1,2 @@
+from .models import MountainGazelle, MountainGazelleOptimizationConfig
+from .mountain_gazelle_optimization import MountainGazelleOptimization

pyvolutionary/mountain_gazelle/models.py

@@ -0,0 +1,9 @@
+from ..models import Agent, BaseOptimizationConfig
+
+
+class MountainGazelle(Agent):
+    pass
+
+
+class MountainGazelleOptimizationConfig(BaseOptimizationConfig):
+    pass

pyvolutionary/mountain_gazelle/mountain_gazelle_optimization.py

@@ -0,0 +1,118 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import MountainGazelleOptimizationConfig
+
+
+class MountainGazelleOptimization(OptimizationAbstract):
+    """
+    Implementation of the Mountain Gazelle Optimization algorithm.
+
+    Args:
+        config (MountainGazelleOptimizationConfig): an instance of MountainGazelleSwarmOptimizationConfig class.
+            {parse_obj_doc(MountainGazelleOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Abdollahzadeh, B., Gharehchopogh, F. S., Khodadadi, N., & Mirjalili, S. (2022). Mountain gazelle optimizer: a
+        new nature-inspired metaheuristic algorithm for global optimization problems. Advances in Engineering Software,
+        174, 103282.
+    """
+    def __init__(self, config: MountainGazelleOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+
+    def __random_solution__(self) -> np.ndarray:
+        """
+        Random solution. It is used to generate a new solution. It is a random combination of the best solution and the
+        mean of the positions of the best solutions.
+        :return: random solution.
+        :rtype: np.ndarray
+        """
+        pop_size = self._config.population_size
+        mean_positions = np.average(
+            np.array([
+                self._population[mm].position for mm in np.random.permutation(pop_size)[:int(np.ceil(pop_size / 3))]
+            ]),
+            axis=0,
+        )
+
+        index = np.random.randint(int(np.ceil(pop_size / 3)), pop_size)
+        return (
+            np.array(self._population[index].position) * np.floor(np.random.normal()) +
+            mean_positions * np.ceil(np.random.normal())
+        )
+
+    def __coefficient_vectors__(self, epoch: int, position: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Calculate the coefficient vectors. They are calculated according to [1].
+        :param epoch: the current epoch.
+        :param position: the position of the current agent.
+        :return: the coefficient vectors.
+        :rtype: tuple[np.ndarray, np.ndarray, np.ndarray]
+        """
+        n_dims = self._task.space_dimension
+        a2 = -1. + epoch * (-1. / self._config.max_cycles)
+        u = np.random.standard_normal(n_dims)
+        # Coefficient vector for the update of the position of the agents
+        cofi = np.zeros((4, n_dims))
+        cofi[0, :] = np.random.random(n_dims)
+        cofi[1, :] = (a2 + 1) + np.random.random()
+        cofi[2, :] = a2 * np.random.standard_normal(n_dims)
+        cofi[3, :] = u * np.random.standard_normal(n_dims) ** 2 * np.cos((np.random.random() * 2) * u)
+
+        A = np.random.standard_normal(n_dims) * np.exp(2 - (epoch + 1) * (2. / self._config.max_cycles))
+        D = (np.abs(position) + np.abs(self._best_agent.position)) * (2 * np.random.random() - 1)
+
+        return cofi, A, D
+
+    def __implement_candidate_positions__(
+        self, cofi: np.ndarray, A: np.ndarray, D: np.ndarray, M: np.ndarray, position: np.ndarray
+    ) -> list[np.ndarray]:
+        """
+        Implement the candidate positions. It is used to generate a new solution. It is a random combination of the
+        best solution and the mean of the positions of the best solutions.
+        :param cofi: the coefficient vector.
+        :param A: the coefficient vector.
+        :param D: the coefficient vector.
+        :param M: the random solution.
+        :param position: the position of the current agent.
+        :return: the candidate positions.
+        :rtype: list[np.ndarray]
+        """
+        best_position = np.array(self._best_agent.position)
+        random_position = np.array(self._population[np.random.randint(0, self._config.population_size)].position)
+
+        x1 = self._uniform_position()
+
+        x2 = best_position - np.abs(
+            (np.random.randint(1, 3) * M - np.random.randint(1, 3) * position) * A
+        ) * cofi[np.random.randint(0, 4)]
+
+        x3 = M + cofi[np.random.randint(0, 4)] + (
+            np.random.randint(1, 3) * best_position - np.random.randint(1, 3) * random_position
+        ) * cofi[np.random.randint(0, 4)]
+
+        x4 = position - D + (
+            np.random.randint(1, 3) * best_position - np.random.randint(1, 3) * M
+        ) * cofi[np.random.randint(0, 4)]
+
+        return [x1, x2, x3, x4]
+
+    def optimization_step(self):
+        pop_new = []
+        for index in range(0, self._config.population_size):
+            current_position = np.array(self._population[index].position)
+
+            # get a new random solution
+            M = self.__random_solution__()
+
+            # calculate the vector of coefficients
+            cofi, A, D = self.__coefficient_vectors__(self._cycles, current_position)
+
+            # update the new population for the next generation with the calculated candidate positions
+            pop_new += [
+                self._init_agent(x) for x in self.__implement_candidate_positions__(cofi, A, D, M, current_position)
+            ]
+
+        self._extend_and_trim_population(pop_new)

pyvolutionary/osprey/__init__.py

@@ -0,0 +1,2 @@
+from .models import Osprey, OspreyOptimizationConfig
+from .osprey_optimization import OspreyOptimization

pyvolutionary/osprey/models.py

@@ -0,0 +1,9 @@
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Osprey(Agent):
+    pass
+
+
+class OspreyOptimizationConfig(BaseOptimizationConfig):
+    pass

pyvolutionary/osprey/osprey_optimization.py

@@ -0,0 +1,54 @@
+import numpy as np
+
+from ..helpers import parse_obj_doc  # type: ignore
+from ..abstract import OptimizationAbstract
+from .models import Osprey, OspreyOptimizationConfig
+
+
+class OspreyOptimization(OptimizationAbstract):
+    """
+    Implementation of the Osprey Optimization algorithm.
+
+    Args:
+        config (OspreyOptimizationConfig): an instance of OspreyOptimizationConfig class.
+            {parse_obj_doc(OspreyOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Trojovský, P., & Dehghani, M. Osprey Optimization Algorithm: A new bio-inspired metaheuristic algorithm
+        for solving engineering optimization problems. Frontiers in Mechanical Engineering, 8, 136.
+    """
+    def __init__(self, config: OspreyOptimizationConfig, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__phi = (1 + np.sqrt(5)) / 2  # golden ratio
+
+    def __get_indexes_better__(self, osprey: Osprey) -> np.ndarray:
+        costs = np.array([agent.cost for agent in self._population])
+        idxs = np.where(costs < osprey.cost)
+        return idxs[0]
+
+    def __sf__(self, osprey: Osprey) -> np.ndarray:
+        idxs = self.__get_indexes_better__(osprey)
+        if len(idxs) == 0 or np.random.random() < 0.5:
+            return np.array(self._best_agent.position)
+
+        kk = np.random.permutation(idxs)[0]
+        return np.array(self._population[kk].position)
+
+    def optimization_step(self):
+        for idx, osprey in enumerate(self._population):
+            pos = np.array(osprey.position)
+
+            # phase 1: position identification and fish hunting (exploration)
+            sf = self.__sf__(osprey)
+            r1 = np.random.randint(1, 3)
+            pos_new = pos + np.random.normal(0, 1) * (sf - r1 * pos)  # Eq. 5
+            agent = self._init_agent(self._correct_position(pos_new))
+
+            osprey = self._greedy_select_agent(osprey, agent)
+
+            # phase 2: carrying the fish to a suitable position (exploitation)
+            pos_new = self._increase_position(osprey.position)  # Eq. 7
+            agent = self._init_agent(self._correct_position(pos_new))
+
+            self._population[idx] = self._greedy_select_agent(osprey, agent)

pyvolutionary/particle_swarm/__init__.py

@@ -0,0 +1,2 @@
+from .models import Particle, ParticleSwarmOptimizationConfig
+from .particle_swarm_optimization import ParticleSwarmOptimization

pyvolutionary/particle_swarm/models.py

@@ -0,0 +1,40 @@
+from pydantic import model_validator, conlist, field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Particle(Agent):
+    velocity: list[float]
+
+
+class ParticleSwarmOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Particle Swarm Optimization algorithm.
+        c1 (float): (0, 5), cognitive parameter.\n
+        c2 (float): (0, 5), social parameter.\n
+        w (list[float]): (0, 0.5), [0.5, 2.0], weights.
+    """
+    c1: float
+    c2: float
+    w: conlist(float, min_length=2, max_length=2)
+
+    @field_validator("c1")
+    def correct_c1(cls, v):
+        if not 0 < v < 5:
+            raise ValueError(f"\"c1\" must be a float in (0, 5.0). Got {v}")
+        return v
+
+    @field_validator("c2")
+    def correct_c2(cls, v):
+        if not 0 < v < 5:
+            raise ValueError(f"\"c2\" must be a float in (0, 5.0). Got {v}")
+        return v
+
+    @field_validator("w")
+    def correct_weights(cls, v):
+        w_min, w_max = v
+        if not 0 < w_min < 0.5:
+            raise ValueError(f"\"w[0]\" must be a float in (0, 0.5). Got {w_min}")
+        if not 0.5 < w_max < 2:
+            raise ValueError(f"\"w[1]\" must be a float in [0.5, 2.0]. Got {w_max}")
+        return v