NiaPy.algorithms

Module with implementations of basic and hybrid algorithms.

class NiaPy.algorithms.Algorithm(**kwargs)

Bases: object

Class for implementing algorithms.

Date:

2018

Author

Klemen Berkovič

License:

MIT

Variables:

• Name (List[str]) – List of names for algorithm.
• Rand (mtrand.RandomState) – Random generator.
• NP (int) – Number of inidividuals in populatin.
• InitPopFunc (Callable[[int, Task, mtrand.RandomState, Dict[str, Any]], Tuple[numpy.ndarray, numpy.ndarray[float]]]) – Idividual initialization function.
• itype (Individual) – Type of individuals used in population, default value is None for Numpy arrays.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

InitPopFunc(NP, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **kwargs)

Initialize starting population that is represented with numpy.ndarray with shape {NP, task.D}.

Parameters:

• task (Task) – Optimization task.
• NP (int) – Number of individuals in population.
• rnd (Optional[mtrand.RandomState]) – Random number generator.
• kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New population with shape {NP, task.D}.
2. New population function/fitness values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float]]

NP = 50

Name = ['Algorithm', 'AAA']

Rand = RandomState(MT19937) at 0x7FE4C2080A98

__init__(**kwargs)

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

static algorithmInfo()

Get algorithm information.

Returns:Bit item. Return type:str

bad_run()

Check if some exeptions where thrown when the algorithm was running.

Returns:True if some error where detected at runtime of the algorithm, otherwise False Return type:bool

getBest(X, X_f, xb=None, xb_f=inf)

Get the best individual for population.

Parameters:

• X (numpy.ndarray) – Current population.
• X_f (numpy.ndarray) – Current populations fitness/function values of aligned individuals.
• xb (numpy.ndarray) – Best individual.
• xb_f (float) – Fitness value of best individual.

Returns:

1. Coordinates of best solution.
2. beset fitness/function value.

Return type:

Tuple[numpy.ndarray, float]

getParameters()

Get parameters of the algorithm.

Returns:

• Parameter name (str): Represents a parameter name
• Value of parameter (Any): Represents the value of the parameter

Return type:Dict[str, Any]

initPopulation(task)

Initialize starting population of optimization algorithm.

Parameters:task (Task) – Optimization task. Returns:

1. New population.
2. New population fitness values.
3. Additional arguments.

Return type:Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.setParameters()

itype = None

normal(loc, scale, D=None)

Get normal random distribution of shape D with mean “loc” and standard deviation “scale”.

Parameters:

• loc (float) – Mean of the normal random distribution.
• scale (float) – Standard deviation of the normal random distribution.
• D (Union[int, Iterable[int]]) – Shape of returned normal random distribution.

Returns:

Array of numbers.

Return type:

Union[numpy.ndarray[float], float]

rand(D=1)

Get random distribution of shape D in range from 0 to 1.

Parameters:D (numpy.ndarray[int]) – Shape of returned random distribution. Returns:Random number or numbers \(\in [0, 1]\). Return type:Union[numpy.ndarray[float], float]

randint(Nmax, D=1, Nmin=0, skip=None)

Get discrete uniform (integer) random distribution of D shape in range from “Nmin” to “Nmax”.

Parameters:

• Nmin (int) – Lower integer bound.
• Nmax (int) – One above upper integer bound.
• D (Union[int, Iterable[int]]) – shape of returned discrete uniform random distribution.
• skip (Union[int, Iterable[int], numpy.ndarray[int]]) – numbers to skip.

Returns:

Random generated integer number.

Return type:

Union[int, numpy.ndarrayj[int]]

randn(D=None)

Get standard normal distribution of shape D.

Parameters:D (Union[int, Iterable[int]]) – Shape of returned standard normal distribution. Returns:Random generated numbers or one random generated number \(\in [0, 1]\). Return type:Union[numpy.ndarray[float], float]

run(task)

Start the optimization.

Parameters:task (Task) – Optimization task. Returns:

1. Best individuals components found in optimization process.
2. Best fitness value found in optimization process.

Return type:Tuple[numpy.ndarray, float]

See also

• NiaPy.algorithms.Algorithm.runTask()

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core functionality of algorithm.

This function is called on every algorithm iteration.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population coordinates.
• fpop (numpy.ndarray) – Current population fitness value.
• xb (numpy.ndarray) – Current generation best individuals coordinates.
• xb_f (float) – current generation best individuals fitness value.
• **dparams (Dict[str, Any]) – Additional arguments for algorithms.

Returns:

1. New populations coordinates.
2. New populations fitness values.
3. New global best position/solution
4. New global best fitness/objective value
5. Additional arguments of the algorithm.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.runYield()

runTask(task)

Start the optimization.

Parameters:task (Task) – Task with bounds and objective function for optimization. Returns:

1. Best individuals components found in optimization process.
2. Best fitness value found in optimization process.

Return type:Tuple[numpy.ndarray, float]

See also

• NiaPy.algorithms.Algorithm.runYield()

runYield(task)

Run the algorithm for a single iteration and return the best solution.

Parameters:task (Task) – Task with bounds and objective function for optimization. Returns:Generator getting new/old optimal global values. Return type:Generator[Tuple[numpy.ndarray, float], None, None] Yields:Tuple[numpy.ndarray, float] – 1. New population best individuals coordinates. 2. Fitness value of the best solution.

See also

• NiaPy.algorithms.Algorithm.initPopulation()
• NiaPy.algorithms.Algorithm.runIteration()

setParameters(NP=50, InitPopFunc=<function defaultNumPyInit>, itype=None, **kwargs)

Set the parameters/arguments of the algorithm.

Parameters:

• NP (Optional[int]) – Number of individuals in population \(\in [1, \infty]\).
• InitPopFunc (Optional[Callable[[int, Task, mtrand.RandomState, Dict[str, Any]], Tuple[numpy.ndarray, numpy.ndarray[float]]]]) – Type of individuals used by algorithm.
• itype (Optional[Any]) – Individual type used in population, default is Numpy array.
• **kwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.defaultNumPyInit()
• NiaPy.algorithms.defaultIndividualInit()

static typeParameters()

Return functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Check if number of individuals is \(\in [0, \infty]\).

Return type:Dict[str, Callable]

uniform(Lower, Upper, D=None)

Get uniform random distribution of shape D in range from “Lower” to “Upper”.

Parameters:

• Lower (Iterable[float]) – Lower bound.
• Upper (Iterable[float]) – Upper bound.
• D (Union[int, Iterable[int]]) – Shape of returned uniform random distribution.

Returns:

Array of numbers \(\in [\mathit{Lower}, \mathit{Upper}]\).

Return type:

Union[numpy.ndarray[float], float]

NiaPy.algorithms.defaultNumPyInit(task, NP, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **kwargs)

Initialize starting population that is represented with numpy.ndarray with shape {NP, task.D}.

Parameters:

• task (Task) – Optimization task.
• NP (int) – Number of individuals in population.
• rnd (Optional[mtrand.RandomState]) – Random number generator.
• kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New population with shape {NP, task.D}.
2. New population function/fitness values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float]]

NiaPy.algorithms.defaultIndividualInit(task, NP, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, itype=None, **kwargs)

Initialize NP individuals of type itype.

Parameters:

• task (Task) – Optimization task.
• NP (int) – Number of individuals in population.
• rnd (Optional[mtrand.RandomState]) – Random number generator.
• itype (Optional[Individual]) – Class of individual in population.
• kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. Initialized individuals.
2. Initialized individuals function/fitness values.

Return type:

Tuple[numpy.ndarray[Individual], numpy.ndarray[float]

class NiaPy.algorithms.Individual(x=None, task=None, e=True, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **kwargs)

Bases: object

Class that represents one solution in population of solutions.

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:

• x (numpy.ndarray) – Coordinates of individual.
• f (float) – Function/fitness value of individual.

Initialize new individual.

Parameters:

• task (Optional[Task]) – Optimization task.
• rand (Optional[mtrand.RandomState]) – Random generator.
• x (Optional[numpy.ndarray]) – Individuals components.
• e (Optional[bool]) – True to evaluate the individual on initialization. Default value is True.
• **kwargs (Dict[str, Any]) – Additional arguments.

__eq__(other)

Compare the individuals for equalities.

Parameters:other (Union[Any, numpy.ndarray]) – Object that we want to compare this object to. Returns:True if equal or False if no equal. Return type:bool

__getitem__(i)

Get the value of i-th component of the solution.

Parameters:i (int) – Position of the solution component. Returns:Value of ith component. Return type:Any

__init__(x=None, task=None, e=True, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **kwargs)

Initialize new individual.

Parameters:

• task (Optional[Task]) – Optimization task.
• rand (Optional[mtrand.RandomState]) – Random generator.
• x (Optional[numpy.ndarray]) – Individuals components.
• e (Optional[bool]) – True to evaluate the individual on initialization. Default value is True.
• **kwargs (Dict[str, Any]) – Additional arguments.

__len__()

Get the length of the solution or the number of components.

Returns:Number of components. Return type:int

__setitem__(i, v)

Set the value of i-th component of the solution to v value.

Parameters:

• i (int) – Position of the solution component.
• v (Any) – Value to set to i-th component.

__str__()

Print the individual with the solution and objective value.

Returns:String representation of self. Return type:str

copy()

Return a copy of self.

Method returns copy of this object so it is safe for editing.

Returns:Copy of self. Return type:Individual

evaluate(task, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>)

Evaluate the solution.

Evaluate solution this.x with the help of task. Task is used for reparing the solution and then evaluating it.

Parameters:

• task (Task) – Objective function object.
• rnd (Optional[mtrand.RandomState]) – Random generator.

See also

• NiaPy.util.Task.repair()

f = inf

generateSolution(task, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>)

Generate new solution.

Generate new solution for this individual and set it to self.x. This method uses rnd for getting random numbers. For generating random components rnd and task is used.

Parameters:

• task (Task) – Optimization task.
• rnd (Optional[mtrand.RandomState]) – Random numbers generator object.

x = None

class NiaPy.algorithms.BasicStatistics(array)

Bases: object

Name = ['BasicStatistics']

generate_standard_report()

max_value()

mean()

median()

min_value()

standard_deviation()

class NiaPy.algorithms.AlgorithmUtility

Bases: object

Base class with string mappings to algorithms.

Variables:classes (Dict[str, Algorithm]) – Mapping from stings to algorithms.

Initialize the algorithms.

__init__()

Initialize the algorithms.

get_algorithm(algorithm)

Get the algorithm.

Parameters:algorithm (Union[str, Algorithm]) – String or class that represents the algorithm. Returns:Instance of an Algorithm. Return type:Algorithm

NiaPy.algorithms.basic

Implementation of basic nature-inspired algorithms.

class NiaPy.algorithms.basic.BatAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Bat algorithm.

Algorithm:

Bat algorithm

Date:

2015

Authors:

Iztok Fister Jr., Marko Burjek and Klemen Berkovič

License:

MIT

Reference paper:

Yang, Xin-She. “A new metaheuristic bat-inspired algorithm.” Nature inspired cooperative strategies for optimization (NICSO 2010). Springer, Berlin, Heidelberg, 2010. 65-74.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• A (float) – Loudness.
• r (float) – Pulse rate.
• Qmin (float) – Minimum frequency.
• Qmax (float) – Maximum frequency.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['BatAlgorithm', 'BA']

static algorithmInfo()

Get algorithms information.

Returns:Algorithm information. Return type:str

getParameters()

Get parameters of the algorithm.

Returns:Dict[str, Any]

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task Returns:

1. New population.
2. New population fitness/function values.

3. Additional arguments:

   • S (numpy.ndarray): TODO
   • Q (numpy.ndarray[float]): TODO
   • v (numpy.ndarray[float]): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

localSearch(best, task, **kwargs)

Improve the best solution according to the Yang (2010).

Parameters:

• best (numpy.ndarray) – Global best individual.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

New solution based on global best individual.

Return type:

numpy.ndarray

runIteration(task, Sol, Fitness, xb, fxb, S, Q, v, **dparams)

Core function of Bat Algorithm.

Parameters:

• task (Task) – Optimization task.
• Sol (numpy.ndarray) – Current population
• Fitness (numpy.ndarray[float]) – Current population fitness/funciton values
• best (numpy.ndarray) – Current best individual
• f_min (float) – Current best individual function/fitness value
• S (numpy.ndarray) – TODO
• Q (numpy.ndarray) – TODO
• v (numpy.ndarray) – TODO
• best – Global best used by the algorithm
• f_min – Global best fitness value used by the algorithm
• dparams (Dict[str, Any]) – Additional algorithm arguments

Returns:

1. New population
2. New population fitness/function vlues
3. New global best solution
4. New global best fitness/objective value

5. Additional arguments:

   • S (numpy.ndarray): TODO
   • Q (numpy.ndarray): TODO
   • v (numpy.ndarray): TODO
   • best (numpy.ndarray): TODO
   • f_min (float): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=40, A=0.5, r=0.5, Qmin=0.0, Qmax=2.0, **ukwargs)

Set the parameters of the algorithm.

Parameters:

• A (Optional[float]) – Loudness.
• r (Optional[float]) – Pulse rate.
• Qmin (Optional[float]) – Minimum frequency.
• Qmax (Optional[float]) – Maximum frequency.

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Return dict with where key of dict represents parameter name and values represent checking functions for selected parameter.

Returns:

• A (Callable[[Union[float, int]], bool]): Loudness.
• r (Callable[[Union[float, int]], bool]): Pulse rate.
• Qmin (Callable[[Union[float, int]], bool]): Minimum frequency.
• Qmax (Callable[[Union[float, int]], bool]): Maximum frequency.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

class NiaPy.algorithms.basic.FireflyAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Firefly algorithm.

Algorithm:

Firefly algorithm

Date:

2016

Authors:

Iztok Fister Jr, Iztok Fister and Klemen Berkovič

License:

MIT

Reference paper:

Fister, I., Fister Jr, I., Yang, X. S., & Brest, J. (2013). A comprehensive review of firefly algorithms. Swarm and Evolutionary Computation, 13, 34-46.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• alpha (float) – Alpha parameter.
• betamin (float) – Betamin parameter.
• gamma (flaot) – Gamma parameter.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['FireflyAlgorithm', 'FA']

static algorithmInfo()

Get algorithm information.

Returns:Bit item. Return type:str

alpha_new(a, alpha)

Optionally recalculate the new alpha value.

Parameters:

• a (float) –
• alpha (float) –

Returns:

New value of parameter alpha

Return type:

float

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task Returns:

1. New population.
2. New population fitness/function values.

3. Additional arguments:

   • alpha (float): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

move_ffa(i, Fireflies, Intensity, oFireflies, alpha, task)

Move fireflies.

Parameters:

• i (int) – Index of current individual.
• Fireflies (numpy.ndarray) –
• Intensity (numpy.ndarray) –
• oFireflies (numpy.ndarray) –
• alpha (float) –
• task (Task) – Optimization task.

Returns:

1. New individual
2. True if individual was moved, False if individual was not moved

Return type:

Tuple[numpy.ndarray, bool]

runIteration(task, Fireflies, Intensity, xb, fxb, alpha, **dparams)

Core function of Firefly Algorithm.

Parameters:

• task (Task) – Optimization task.
• Fireflies (numpy.ndarray) – Current population.
• Intensity (numpy.ndarray) – Current population function/fitness values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individual fitness/function value.
• alpha (float) – TODO.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution
4. New global best solutions fitness/objective value

5. Additional arguments:

   • alpha (float): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

See also

• NiaPy.algorithms.basic.FireflyAlgorithm.move_ffa()

setParameters(NP=20, alpha=1, betamin=1, gamma=2, **ukwargs)

Set the parameters of the algorithm.

Parameters:

• NP (Optional[int]) – Population size.
• alpha (Optional[float]) – Alpha parameter.
• betamin (Optional[float]) – Betamin parameter.
• gamma (Optional[flaot]) – Gamma parameter.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

TODO.

Returns:

• alpha (Callable[[Union[float, int]], bool]): TODO.
• betamin (Callable[[Union[float, int]], bool]): TODO.
• gamma (Callable[[Union[float, int]], bool]): TODO.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

class NiaPy.algorithms.basic.DifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Differential evolution algorithm.

Algorithm:

Differential evolution algorithm

Date:

2018

Author:

Uros Mlakar and Klemen Berkovič

License:

MIT

Reference paper:

Storn, Rainer, and Kenneth Price. “Differential evolution - a simple and efficient heuristic for global optimization over continuous spaces.” Journal of global optimization 11.4 (1997): 341-359.

Variables:

• Name (List[str]) – List of string of names for algorithm.
• F (float) – Scale factor.
• CR (float) – Crossover probability.
• CrossMutt (Callable[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, Dict[str, Any]]) – crossover and mutation strategy.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DifferentialEvolution', 'DE']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

evolve(pop, xb, task, **kwargs)

Evolve population.

Parameters:

• pop (numpy.ndarray) – Current population.
• xb (Individual) – Current best individual.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

New evolved populations.

Return type:

numpy.ndarray

getParameters()

Get parameters values of the algorithm.

Returns:TODO Return type:Dict[str, Any]

See also

• NiaPy.algorithms.Algorithm.getParameters()

postSelection(pop, task, xb, fxb, **kwargs)

Apply additional operation after selection.

Parameters:

• pop (numpy.ndarray) – Current population.
• task (Task) – Optimization task.
• xb (numpy.ndarray) – Global best solution.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New global best solution.
3. New global best solutions fitness/objective value.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of Differential Evolution algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Current best individual.
• fxb (float) – Current best individual function/fitness value.
• **dparams (dict) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.evolve()
• NiaPy.algorithms.basic.DifferentialEvolution.selection()
• NiaPy.algorithms.basic.DifferentialEvolution.postSelection()

selection(pop, npop, xb, fxb, task, **kwargs)

Operator for selection.

Parameters:

• pop (numpy.ndarray) – Current population.
• npop (numpy.ndarray) – New Population.
• xb (numpy.ndarray) – Current global best solution.
• fxb (float) – Current global best solutions fitness/objective value.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New selected individuals.
2. New global best solution.
3. New global best solutions fitness/objective value.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

setParameters(NP=50, F=1, CR=0.8, CrossMutt=<function CrossRand1>, **ukwargs)

Set the algorithm parameters.

Parameters:

• NP (Optional[int]) – Population size.
• F (Optional[float]) – Scaling factor.
• CR (Optional[float]) – Crossover rate.
• CrossMutt (Optional[Callable[[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, list], numpy.ndarray]]) – Crossover and mutation strategy.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• F (Callable[[Union[float, int]], bool]): Check for correct value of parameter.
• CR (Callable[[float], bool]): Check for correct value of parameter.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

class NiaPy.algorithms.basic.CrowdingDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution

Implementation of Differential evolution algorithm with multiple mutation strateys.

Algorithm:

Implementation of Differential evolution algorithm with multiple mutation strateys

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• CrowPop (float) – Proportion of range for cowding.

See also

• NiaPy.algorithms.basic.DifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['CrowdingDifferentialEvolution', 'CDE']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

selection(pop, npop, xb, fxb, task, **kwargs)

Operator for selection of individuals.

Parameters:

• pop (numpy.ndarray) – Current population.
• npop (numpy.ndarray) – New population.
• xb (numpy.ndarray) – Current global best solution.
• fxb (float) – Current global best solutions fitness/objective value.
• task (Task) – Optimization task.
• kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New global best solution.
3. New global best solutions fitness/objective value.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

setParameters(CrowPop=0.1, **ukwargs)

Set core parameters of algorithm.

Parameters:

• CrowPop (Optional[float]) – Crowding distance.
• **ukwargs – Additional arguments.

See also

• NiaPy.algorithms.basic.DifferentialEvolution.setParameters()

class NiaPy.algorithms.basic.AgingNpDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution

Implementation of Differential evolution algorithm with aging individuals.

Algorithm:

Differential evolution algorithm with dynamic population size that is defined by the quality of population

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:

• Name (List[str]) – list of strings representing algorithm names.
• Lt_min (int) – Minimal age of individual.
• Lt_max (int) – Maximal age of individual.
• delta_np (float) – Proportion of how many individuals shall die.
• omega (float) – Acceptance rate for individuals to die.
• mu (int) – Mean of individual max and min age.
• age (Callable[[int, int, float, float, float, float, float], int]) – Function for calculation of age for individual.

See also

• NiaPy.algorithms.basic.DifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['AgingNpDifferentialEvolution', 'ANpDE']

aging(task, pop)

Apply aging to individuals.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray[Individual]) – Current population.

Returns:

New population.

Return type:

numpy.ndarray[Individual]

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

deltaPopC(t)

Calculate how many individuals are going to be created.

Parameters:t (int) – Number of generations made by the algorithm. Returns:Number of individuals to be born. Return type:int

deltaPopE(t)

Calculate how many individuals are going to dye.

Parameters:t (int) – Number of generations made by the algorithm. Returns:Number of individuals to dye. Return type:int

popDecrement(pop, task)

Decrement population.

Parameters:

• pop (numpy.ndarray) – Current population.
• task (Task) – Optimization task.

Returns:

Decreased population.

Return type:

numpy.ndarray[Individual]

popIncrement(pop, task)

Increment population.

Parameters:

• pop (numpy.ndarray[Individual]) – Current population.
• task (Task) – Optimization task.

Returns:

Increased population.

Return type:

numpy.ndarray[Individual]

postSelection(pop, task, xb, fxb, **kwargs)

Post selection operator.

Parameters:

• pop (numpy.ndarray) – Current population.
• task (Task) – Optimization task.
• xb (Individual) – Global best individual.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New global best solution
3. New global best solutions fitness/objective value

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

selection(pop, npop, xb, fxb, task, **kwargs)

Select operator for individuals with aging.

Parameters:

• pop (numpy.ndarray) – Current population.
• npop (numpy.ndarray) – New population.
• xb (numpy.ndarray) – Current global best solution.
• fxb (float) – Current global best solutions fitness/objective value.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New population of individuals.
2. New global best solution.
3. New global best solutions fitness/objective value.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

setParameters(Lt_min=0, Lt_max=12, delta_np=0.3, omega=0.3, age=<function proportional>, CrossMutt=<function CrossBest1>, **ukwargs)

Set the algorithm parameters.

Parameters:

• Lt_min (Optional[int]) – Minimum life time.
• Lt_max (Optional[int]) – Maximum life time.
• age (Optional[Callable[[int, int, float, float, float, float, float], int]]) – Function for calculation of age for individual.

See also

• NiaPy.algorithms.basic.DifferentialEvolution.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• Lt_min (Callable[[int], bool])
• Lt_max (Callable[[int], bool])
• delta_np (Callable[[float], bool])
• omega (Callable[[float], bool])

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.typeParameters()

class NiaPy.algorithms.basic.DynNpDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution

Implementation of Dynamic poulation size Differential evolution algorithm.

Algorithm:

Dynamic poulation size Differential evolution algorithm

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• pmax (int) – Number of population reductions.
• rp (int) – Small non-negative number which is added to value of generations.

See also

• NiaPy.algorithms.basic.DifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynNpDifferentialEvolution', 'dynNpDE']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

postSelection(pop, task, xb, fxb, **kwargs)

Post selection operator.

In this algorithm the post selection operator decrements the population at specific iterations/generations.

Parameters:

• pop (numpy.ndarray) – Current population.
• task (Task) – Optimization task.
• kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. Changed current population.
2. New global best solution.
3. New global best solutions fitness/objective value.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

setParameters(pmax=50, rp=3, **ukwargs)

Set the algorithm parameters.

Parameters:

• pmax (Optional[int]) – umber of population reductions.
• rp (Optional[int]) – Small non-negative number which is added to value of generations.

See also

• NiaPy.algorithms.basic.DifferentialEvolution.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• rp (Callable[[Union[float, int]], bool])
• pmax (Callable[[int], bool])

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.typeParameters()

class NiaPy.algorithms.basic.MultiStrategyDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution

Implementation of Differential evolution algorithm with multiple mutation strateys.

Algorithm:

Implementation of Differential evolution algorithm with multiple mutation strateys

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• strategies (Iterable[Callable[[numpy.ndarray[Individual], int, Individual, float, float, mtrand.RandomState], numpy.ndarray[Individual]]]) – List of mutation strategies.
• CrossMutt (Callable[[numpy.ndarray[Individual], int, Individual, float, float, Task, Individual, Iterable[Callable[[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, Dict[str, Any]], Individual]]], Individual]) – Multi crossover and mutation combiner function.

See also

• NiaPy.algorithms.basic.DifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MultiStrategyDifferentialEvolution', 'MsDE']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

evolve(pop, xb, task, **kwargs)

Evolve population with the help multiple mutation strategies.

Parameters:

• pop (numpy.ndarray) – Current population.
• xb (numpy.ndarray) – Current best individual.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

New population of individuals.

Return type:

numpy.ndarray

getParameters()

Get parameters values of the algorithm.

Returns:TODO. Return type:Dict[str, Any]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.getParameters()

setParameters(strategies=(<function CrossRand1>, <function CrossBest1>, <function CrossCurr2Best1>, <function CrossRand2>), **ukwargs)

Set the arguments of the algorithm.

Parameters:

• strategies (Optional[Iterable[Callable[[numpy.ndarray[Individual], int, Individual, float, float, mtrand.RandomState], numpy.ndarray[Individual]]]]) – List of mutation strategyis.
• CrossMutt (Optional[Callable[[numpy.ndarray[Individual], int, Individual, float, float, Task, Individual, Iterable[Callable[[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, Dict[str, Any]], Individual]]], Individual]]) – Multi crossover and mutation combiner function.

See also

• NiaPy.algorithms.basic.DifferentialEvolution.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:Testing functions for parameters. Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.typeParameters()

class NiaPy.algorithms.basic.DynNpMultiStrategyDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.MultiStrategyDifferentialEvolution, NiaPy.algorithms.basic.de.DynNpDifferentialEvolution

Implementation of Dynamic population size Differential evolution algorithm with dynamic population size that is defined by the quality of population.

Algorithm:

Dynamic population size Differential evolution algorithm with dynamic population size that is defined by the quality of population

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• NiaPy.algorithms.basic.MultiStrategyDifferentialEvolution
• NiaPy.algorithms.basic.DynNpDifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynNpMultiStrategyDifferentialEvolution', 'dynNpMsDE']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

evolve(pop, xb, task, **kwargs)

Evolve the current population.

Parameters:

• pop (numpy.ndarray) – Current population.
• xb (numpy.ndarray) – Global best solution.
• task (Task) – Optimization task.
• **kwargs (dict) – Additional arguments.

Returns:

Evolved new population.

Return type:

numpy.ndarray

postSelection(pop, task, xb, fxb, **kwargs)

Post selection operator.

Parameters:

• pop (numpy.ndarray) – Current population.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New global best solution.
3. New global best solutions fitness/objective value.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

See also

• NiaPy.algorithms.basic.DynNpDifferentialEvolution.postSelection()

setParameters(**ukwargs)

Set the arguments of the algorithm.

Parameters:ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.basic.MultiStrategyDifferentialEvolution.setParameters()
• NiaPy.algorithms.basic.DynNpDifferentialEvolution.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• rp (Callable[[Union[float, int]], bool]): TODO
• pmax (Callable[[int], bool]): TODO

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.MultiStrategyDifferentialEvolution.typeParameters()

NiaPy.algorithms.basic.multiMutations(pop, i, xb, F, CR, rnd, task, itype, strategies, **kwargs)

Mutation strategy that takes more than one strategy and applys them to individual.

Parameters:

• pop (numpy.ndarray[Individual]) – Current population.
• i (int) – Index of current individual.
• xb (Individual) – Current best individual.
• F (float) – Scale factor.
• CR (float) – Crossover probability.
• rnd (mtrand.RandomState) – Random generator.
• task (Task) – Optimization task.
• IndividualType (Individual) – Individual type used in algorithm.
• strategies (Iterable[Callable[[numpy.ndarray[Individual], int, Individual, float, float, mtrand.RandomState], numpy.ndarray[Individual]]]) – List of mutation strategies.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

Best individual from applyed mutations strategies.

Return type:

Individual

class NiaPy.algorithms.basic.AgingNpMultiMutationDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.AgingNpDifferentialEvolution, NiaPy.algorithms.basic.de.MultiStrategyDifferentialEvolution

Implementation of Differential evolution algorithm with aging individuals.

Algorithm:

Differential evolution algorithm with dynamic population size that is defined by the quality of population

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm names

See also

• NiaPy.algorithms.basic.AgingNpDifferentialEvolution
• NiaPy.algorithms.basic.MultiStrategyDifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['AgingNpMultiMutationDifferentialEvolution', 'ANpMSDE']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

evolve(pop, xb, task, **kwargs)

Evolve current population.

Parameters:

• pop (numpy.ndarray) – Current population.
• xb (numpy.ndarray) – Global best individual.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

New population of individuals.

Return type:

numpy.ndarray

setParameters(**ukwargs)

Set core parameter arguments.

Parameters:**ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.basic.AgingNpDifferentialEvolution.setParameters()
• NiaPy.algorithms.basic.MultiStrategyDifferentialEvolution.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:Mappings form parameter names to test functions. Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.MultiStrategyDifferentialEvolution.typeParameters()
• NiaPy.algorithms.basic.AgingNpDifferentialEvolution.typeParameters()

class NiaPy.algorithms.basic.FlowerPollinationAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Flower Pollination algorithm.

Algorithm:

Flower Pollination algorithm

Date:

2018

Authors:

Dusan Fister, Iztok Fister Jr. and Klemen Berkovič

License:

MIT

Reference paper:

Yang, Xin-She. “Flower pollination algorithm for global optimization. International conference on unconventional computing and natural computation. Springer, Berlin, Heidelberg, 2012.

References URL:

Implementation is based on the following MATLAB code: https://www.mathworks.com/matlabcentral/fileexchange/45112-flower-pollination-algorithm?requestedDomain=true

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• p (float) – probability switch.
• beta (float) – Shape of the gamma distribution (should be greater than zero).

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['FlowerPollinationAlgorithm', 'FPA']

initPopulation(task)

Initialize starting population of optimization algorithm.

Parameters:task (Task) – Optimization task. Returns:

1. New population.
2. New population fitness values.
3. Additional arguments.

Return type:Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.setParameters()

levy(D)

Levy function.

Returns:Next Levy number. Return type:float

repair(x, task)

Repair solution to search space.

Parameters:

• x (numpy.ndarray) – Solution to fix.
• task (Task) – Optimization task.

Returns:

fixed solution.

Return type:

numpy.ndarray

runIteration(task, Sol, Sol_f, xb, fxb, S, **dparams)

Core function of FlowerPollinationAlgorithm algorithm.

Parameters:

• task (Task) – Optimization task.
• Sol (numpy.ndarray) – Current population.
• Sol_f (numpy.ndarray) – Current population fitness/function values.
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solution function/fitness value.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New populations fitness/function values.
3. New global best solution
4. New global best solution fitness/objective value
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=25, p=0.35, beta=1.5, **ukwargs)

Set core parameters of FlowerPollinationAlgorithm algorithm.

Parameters:

• NP (int) – Population size.
• p (float) – Probability switch.
• beta (float) – Shape of the gamma distribution (should be greater than zero).

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

TODO.

Returns:

• p (function): TODO
• beta (function): TODO

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

class NiaPy.algorithms.basic.GreyWolfOptimizer(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Grey wolf optimizer.

Algorithm:

Grey wolf optimizer

Date:

2018

Author:

Iztok Fister Jr. and Klemen Berkovič

License:

MIT

Reference paper:

• Mirjalili, Seyedali, Seyed Mohammad Mirjalili, and Andrew Lewis. “Grey wolf optimizer.” Advances in engineering software 69 (2014): 46-61.
• Grey Wold Optimizer (GWO) source code version 1.0 (MATLAB) from MathWorks

Variables:Name (List[str]) – List of strings representing algorithm names.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['GreyWolfOptimizer', 'GWO']

initPopulation(task)

Initialize population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized populations fitness/function values.

3. Additional arguments:

   • A (): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

runIteration(task, pop, fpop, xb, fxb, A, A_f, B, B_f, D, D_f, **dparams)

Core funciton of GreyWolfOptimizer algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations function/fitness values.
• xb (numpy.ndarray) –
• fxb (float) –
• A (numpy.ndarray) –
• A_f (float) –
• B (numpy.ndarray) –
• B_f (float) –
• D (numpy.ndarray) –
• D_f (float) –
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population
2. New population fitness/function values

3. Additional arguments:

   • A (): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=25, **ukwargs)

Set the algorithm parameters.

Parameters:NP (int) – Number of individuals in population

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Return functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Check if number of individuals is \(\in [0, \infty]\).

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.CatSwarmOptimization(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Cat swarm optimiization algorithm.

Algorithm: Cat swarm optimization

Date: 2019

Author: Mihael Baketarić

License: MIT

Reference paper: Chu, Shu-Chuan & Tsai, Pei-Wei & Pan, Jeng-Shyang. (2006). Cat Swarm Optimization. 854-858. 10.1007/11801603_94.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['CatSwarmOptimization', 'CSO']

initPopulation(task)

Initialize population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized populations fitness/function values.

3. Additional arguments:

   • Dictionary of modes (seek or trace) and velocities for each cat

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

randomSeekTrace()

Set cats into seeking/tracing mode.

Returns:One or zero. One means tracing mode. Zero means seeking mode. Length of list is equal to NP. Return type:numpy.ndarray

repair(x, l, u)

Repair array to range.

Parameters:

• x (numpy.ndarray) – Array to repair.
• l (numpy.ndarray) – Lower limit of allowed range.
• u (numpy.ndarray) – Upper limit of allowed range.

Returns:

Repaired array.

Return type:

numpy.ndarray

runIteration(task, pop, fpop, xb, fxb, velocities, modes, **dparams)

Core function of Cat Swarm Optimization algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current population fitness/function values.
• xb (numpy.ndarray) – Current best individual.
• fxb (float) – Current best cat fitness/function value.
• velocities (numpy.ndarray) – Velocities of individuals.
• modes (numpy.ndarray) – Flag of each individual.
• **dparams (Dict[str, Any]) – Additional function arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.

5. Additional arguments:

   • Dictionary of modes (seek or trace) and velocities for each cat.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

seekingMode(task, cat, fcat, pop, fpop, fxb)

Seeking mode.

Parameters:

• task (Task) – Optimization task.
• cat (numpy.ndarray) – Individual from population.
• fcat (float) – Current individual’s fitness/function value.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current population fitness/function values.
• fxb (float) – Current best cat fitness/function value.

Returns:

1. Updated individual’s position
2. Updated individual’s fitness/function value
3. Updated global best position
4. Updated global best fitness/function value

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float]

setParameters(NP=30, MR=0.1, C1=2.05, SMP=3, SPC=True, CDC=0.85, SRD=0.2, vMax=1.9, **ukwargs)

Set the algorithm parameters.

Parameters:

• NP (int) – Number of individuals in population
• MR (float) – Mixture ratio
• C1 (float) – Constant in tracing mode
• SMP (int) – Seeking memory pool
• SPC (bool) – Self-position considering
• CDC (float) – Decides how many dimensions will be varied
• SRD (float) – Seeking range of the selected dimension
• vMax (float) – Maximal velocity
• Also (See) –
  • NiaPy.algorithms.Algorithm.setParameters()

tracingMode(task, cat, velocity, xb)

Tracing mode.

Parameters:

• task (Task) – Optimization task.
• cat (numpy.ndarray) – Individual from population.
• velocity (numpy.ndarray) – Velocity of individual.
• xb (numpy.ndarray) – Current best individual.

Returns:

1. Updated individual’s position
2. Updated individual’s fitness/function value
3. Updated individual’s velocity vector

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray]

static typeParameters()

Return functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Check if number of individuals is \(\in [0, \infty]\).

Return type:Dict[str, Callable]

weightedSelection(weights)

Random selection considering the weights.

Parameters:weights (numpy.ndarray) – weight for each potential position. Returns:index of selected next position. Return type:int

class NiaPy.algorithms.basic.GeneticAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Genetic algorithm.

Algorithm:

Genetic algorithm

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• Ts (int) – Tournament size.
• Mr (float) – Mutation rate.
• Cr (float) – Crossover rate.
• Selection (Callable[[numpy.ndarray[Individual], int, int, Individual, mtrand.RandomState], Individual]) – Selection operator.
• Crossover (Callable[[numpy.ndarray[Individual], int, float, mtrand.RandomState], Individual]) – Crossover operator.
• Mutation (Callable[[numpy.ndarray[Individual], int, float, Task, mtrand.RandomState], Individual]) – Mutation operator.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['GeneticAlgorithm', 'GA']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of GeneticAlgorithm algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individuals function/fitness value.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New populations function/fitness values.
3. New global best solution
4. New global best solutions fitness/objective value
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=25, Ts=5, Mr=0.25, Cr=0.25, Selection=<function TournamentSelection>, Crossover=<function UniformCrossover>, Mutation=<function UniformMutation>, **ukwargs)

Set the parameters of the algorithm.

Parameters:

• NP (Optional[int]) – Population size.
• Ts (Optional[int]) – Tournament selection.
• Mr (Optional[int]) – Mutation rate.
• Cr (Optional[float]) – Crossover rate.
• Selection (Optional[Callable[[numpy.ndarray[Individual], int, int, Individual, mtrand.RandomState], Individual]]) – Selection operator.
• Crossover (Optional[Callable[[numpy.ndarray[Individual], int, float, mtrand.RandomState], Individual]]) – Crossover operator.
• Mutation (Optional[Callable[[numpy.ndarray[Individual], int, float, Task, mtrand.RandomState], Individual]]) – Mutation operator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

• Selection:

  • NiaPy.algorithms.basic.TournamentSelection()
  • NiaPy.algorithms.basic.RouletteSelection()

• Crossover:

  • NiaPy.algorithms.basic.UniformCrossover()
  • NiaPy.algorithms.basic.TwoPointCrossover()
  • NiaPy.algorithms.basic.MultiPointCrossover()
  • NiaPy.algorithms.basic.CrossoverUros()

• Mutations:

  • NiaPy.algorithms.basic.UniformMutation()
  • NiaPy.algorithms.basic.CreepMutation()
  • NiaPy.algorithms.basic.MutationUros()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• Ts (Callable[[int], bool]): Tournament size.
• Mr (Callable[[float], bool]): Probability of mutation.
• Cr (Callable[[float], bool]): Probability of crossover.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

class NiaPy.algorithms.basic.ArtificialBeeColonyAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Artificial Bee Colony algorithm.

Algorithm:

Artificial Bee Colony algorithm

Date:

2018

Author:

Uros Mlakar and Klemen Berkovič

License:

MIT

Reference paper:

Karaboga, D., and Bahriye B. “A powerful and efficient algorithm for numerical function optimization: artificial bee colony (ABC) algorithm.” Journal of global optimization 39.3 (2007): 459-471.

Arguments

Name (List[str]): List containing strings that represent algorithm names Limit (Union[float, numpy.ndarray[float]]): Limt

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

CalculateProbs(Foods, Probs)

Calculate the probes.

Parameters:

• Foods (numpy.ndarray) – TODO
• Probs (numpy.ndarray) – TODO

Returns:

TODO

Return type:

numpy.ndarray

Name = ['ArtificialBeeColonyAlgorithm', 'ABC']

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task Returns:

1. New population
2. New population fitness/function values

3. Additional arguments:

   • Probes (numpy.ndarray): TODO
   • Trial (numpy.ndarray): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

runIteration(task, Foods, fpop, xb, fxb, Probs, Trial, **dparams)

Core funciton of the algorithm.

Parameters:

• task (Task) – Optimization task
• Foods (numpy.ndarray) – Current population
• fpop (numpy.ndarray[float]) – Function/fitness values of current population
• xb (numpy.ndarray) – Current best individual
• fxb (float) – Current best individual fitness/function value
• Probs (numpy.ndarray) – TODO
• Trial (numpy.ndarray) – TODO
• dparams (Dict[str, Any]) – Additional parameters

Returns:

1. New population
2. New population fitness/function values
3. New global best solution
4. New global best fitness/objecive value

5. Additional arguments:

   • Probes (numpy.ndarray): TODO
   • Trial (numpy.ndarray): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=10, Limit=100, **ukwargs)

Set the parameters of Artificial Bee Colony Algorithm.

Parameters:

• Limit (Optional[Union[float, numpy.ndarray[float]]]) – Limt
• **ukwargs (Dict[str, Any]) – Additional arguments

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Return functions for checking values of parameters.

Returns:

• Limit (Callable[Union[float, numpy.ndarray[float]]]): TODO

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

class NiaPy.algorithms.basic.ParticleSwarmAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Particle Swarm Optimization algorithm.

Algorithm:

Particle Swarm Optimization algorithm

Date:

2018

Authors:

Lucija Brezočnik, Grega Vrbančič, Iztok Fister Jr. and Klemen Berkovič

License:

MIT

Reference paper:

TODO: Find the right paper

Variables:

• Name (List[str]) – List of strings representing algorithm names
• C1 (float) – Cognitive component.
• C2 (float) – Social component.
• w (Union[float, numpy.ndarray[float]]) – Inertial weight.
• vMin (Union[float, numpy.ndarray[float]]) – Minimal velocity.
• vMax (Union[float, numpy.ndarray[float]]) – Maximal velocity.
• Repair (Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray, mtrnd.RandomState], numpy.ndarray]) – Repair method for velocity.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['WeightedVelocityClampingParticleSwarmAlgorithm', 'WVCPSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get value of parametrs for this instance of algorithm.

Returns:Dictionari which has parameters maped to values. Return type:Dict[str, Union[int, float, np.ndarray]]

See also

• NiaPy.algorithms.Algorithm.getParameters()

init(task)

Initialize dynamic arguments of Particle Swarm Optimization algorithm.

Parameters:task (Task) – Optimization task. Returns:

• w (numpy.ndarray): Inertial weight.
• vMin (numpy.ndarray): Mininal velocity.
• vMax (numpy.ndarray): Maximal velocity.
• V (numpy.ndarray): Initial velocity of particle.

Return type:Dict[str, Union[float, np.ndarray]]

initPopulation(task)

Initialize population and dynamic arguments of the Particle Swarm Optimization algorithm.

Parameters:task – Optimization task. Returns:

1. Initial population.
2. Initial population fitness/function values.

3. Additional arguments:

   • popb (numpy.ndarray): particles best population.
   • fpopb (numpy.ndarray[float]): particles best positions function/fitness value.
   • w (numpy.ndarray): Inertial weight.
   • vMin (numpy.ndarray): Minimal velocity.
   • vMax (numpy.ndarray): Maximal velocity.
   • V (numpy.ndarray): Initial velocity of particle.

Return type:Tuple[np.ndarray, np.ndarray, dict]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

runIteration(task, pop, fpop, xb, fxb, popb, fpopb, w, vMin, vMax, V, **dparams)

Core function of Particle Swarm Optimization algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current populations.
• fpop (numpy.ndarray) – Current population fitness/function values.
• xb (numpy.ndarray) – Current best particle.
• fxb (float) – Current best particle fitness/function value.
• popb (numpy.ndarray) – Particles best position.
• fpopb (numpy.ndarray) – Particles best positions fitness/function values.
• w (numpy.ndarray) – Inertial weights.
• vMin (numpy.ndarray) – Minimal velocity.
• vMax (numpy.ndarray) – Maximal velocity.
• V (numpy.ndarray) – Velocity of particles.
• **dparams – Additional function arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best position.
4. New global best positions function/fitness value.

5. Additional arguments:

   • popb (numpy.ndarray): Particles best population.
   • fpopb (numpy.ndarray[float]): Particles best positions function/fitness value.
   • w (numpy.ndarray): Inertial weight.
   • vMin (numpy.ndarray): Minimal velocity.
   • vMax (numpy.ndarray): Maximal velocity.
   • V (numpy.ndarray): Initial velocity of particle.

Return type:

Tuple[np.ndarray, np.ndarray, np.ndarray, float, dict]

See also

• NiaPy.algorithms.algorithm.runIteration

setParameters(NP=25, C1=2.0, C2=2.0, w=0.7, vMin=-1.5, vMax=1.5, Repair=<function reflectRepair>, **ukwargs)

Set Particle Swarm Algorithm main parameters.

Parameters:

• NP (int) – Population size
• C1 (float) – Cognitive component.
• C2 (float) – Social component.
• w (Union[float, numpy.ndarray]) – Inertial weight.
• vMin (Union[float, numpy.ndarray]) – Minimal velocity.
• vMax (Union[float, numpy.ndarray]) – Maximal velocity.
• Repair (Callable[[np.ndarray, np.ndarray, np.ndarray, dict], np.ndarray]) – Repair method for velocity.
• **ukwargs – Additional arguments

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool])
• C1 (Callable[[Union[int, float]], bool])
• C2 (Callable[[Union[int, float]], bool])
• w (Callable[[float], bool])
• vMin (Callable[[Union[int, float]], bool])
• vMax (Callable[[Union[int, float], bool])

Return type:Dict[str, Callable[[Union[int, float]], bool]]

updateVelocity(V, p, pb, gb, w, vMin, vMax, task, **kwargs)

Update particle velocity.

Parameters:

• V (numpy.ndarray) – Current velocity of particle.
• p (numpy.ndarray) – Current position of particle.
• pb (numpy.ndarray) – Personal best position of particle.
• gb (numpy.ndarray) – Global best position of particle.
• w (numpy.ndarray) – Weights for velocity adjustment.
• vMin (numpy.ndarray) – Minimal velocity allowed.
• vMax (numpy.ndarray) – Maximal velocity allowed.
• task (Task) – Optimization task.
• kwargs – Additional arguments.

Returns:

Updated velocity of particle.

Return type:

numpy.ndarray

class NiaPy.algorithms.basic.BareBonesFireworksAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of bare bone fireworks algorithm.

Algorithm:

Bare Bones Fireworks Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.sciencedirect.com/science/article/pii/S1568494617306609

Reference paper:

Junzhi Li, Ying Tan, The bare bones fireworks algorithm: A minimalist global optimizer, Applied Soft Computing, Volume 62, 2018, Pages 454-462, ISSN 1568-4946, https://doi.org/10.1016/j.asoc.2017.10.046.

Variables:

• Name (lsit of str) – List of strings representing algorithm names
• n (int) – Number of spraks
• C_a (float) – amplification coefficient
• C_r (float) – reduction coefficient

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['BareBonesFireworksAlgorithm', 'BBFWA']

static algorithmInfo()

Get default information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

initPopulation(task)

Initialize starting population.

Parameters:task (Task) – Optimization task. Returns:

1. Initial solution.
2. Initial solution function/fitness value.

3. Additional arguments:

   • A (numpy.ndarray): Starting aplitude or search range.

Return type:Tuple[numpy.ndarray, float, Dict[str, Any]]

runIteration(task, x, x_fit, xb, fxb, A, **dparams)

Core function of Bare Bones Fireworks Algorithm.

Parameters:

• task (Task) – Optimization task.
• x (numpy.ndarray) – Current solution.
• x_fit (float) – Current solution fitness/function value.
• xb (numpy.ndarray) – Current best solution.
• fxb (float) – Current best solution fitness/function value.
• A (numpy.ndarray) – Serach range.
• dparams (Dict[str, Any]) – Additional parameters.

Returns:

1. New solution.
2. New solution fitness/function value.
3. New global best solution.
4. New global best solutions fitness/objective value.

5. Additional arguments:

   • A (numpy.ndarray): Serach range.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, Dict[str, Any]]

setParameters(n=10, C_a=1.5, C_r=0.5, **ukwargs)

Set the arguments of an algorithm.

Parameters:

• n (int) – Number of sparks \(\in [1, \infty)\).
• C_a (float) – Amplification coefficient \(\in [1, \infty)\).
• C_r (float) – Reduction coefficient \(\in (0, 1)\).

static typeParameters()

Return functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Check if number of individuals is \(\in [0, \infty]\).

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.CamelAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Camel traveling behavior.

Algorithm:

Camel algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.iasj.net/iasj?func=fulltext&aId=118375

Reference paper:

Ali, Ramzy. (2016). Novel Optimization Algorithm Inspired by Camel Traveling Behavior. Iraq J. Electrical and Electronic Engineering. 12. 167-177.

Variables:

• Name (List[str]) – List of strings representing name of the algorithm.
• T_min (float) – Minimal temperature of environment.
• T_max (float) – Maximal temperature of environment.
• E_init (float) – Starting value of energy.
• S_init (float) – Starting value of supplys.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['CamelAlgorithm', 'CA']

static algorithmInfo()

Get information about algorithm.

Returns:Algorithm information Return type:str

getParameters()

Get parameters of the algorithm.

Returns: Return type:Dict[str, Any]

initPop(task, NP, rnd, itype, **kwargs)

Initialize starting population.

Parameters:

• task (Task) – Optimization task.
• NP (int) – Number of camels in population.
• rnd (mtrand.RandomState) – Random number generator.
• itype (Individual) – Individual type.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. Initialize population of camels.
2. Initialized populations function/fitness values.

Return type:

Tuple[numpy.ndarray[Camel], numpy.ndarray[float]]

initPopulation(task)

Initialize population.

Parameters:task (Task) – Optimization taks. Returns:

1. New population of Camels.
2. New population fitness/function values.
3. Additional arguments.

Return type:Tuple[numpy.ndarray[Camel], numpy.ndarray[float], dict]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

lifeCycle(c, mu, task)

Apply life cycle to Camel.

Parameters:

• c (Camel) – Camel to apply life cycle.
• mu (float) – Vision range of camel.
• task (Task) – Optimization task.

Returns:

Camel with life cycle applyed to it.

Return type:

Camel

oasis(c, rn, alpha)

Apply oasis function to camel.

Parameters:

• c (Camel) – Camel to apply oasis on.
• rn (float) – Random number.
• alpha (float) – View range of Camel.

Returns:

Camel with appliyed oasis on.

Return type:

Camel

runIteration(task, caravan, fcaravan, cb, fcb, **dparams)

Core function of Camel Algorithm.

Parameters:

• task (Task) – Optimization task.
• caravan (numpy.ndarray[Camel]) – Current population of Camels.
• fcaravan (numpy.ndarray[float]) – Current population fitness/function values.
• cb (Camel) – Current best Camel.
• fcb (float) – Current best Camel fitness/function value.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population
2. New population function/fitness value
3. New global best solution
4. New global best fitness/objective value
5. Additional arguments

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, folat, dict]

setParameters(NP=50, omega=0.25, mu=0.5, alpha=0.5, S_init=10, E_init=10, T_min=-10, T_max=10, **ukwargs)

Set the arguments of an algorithm.

Parameters:

• NP (Optional[int]) – Population size \(\in [1, \infty)\).
• T_min (Optional[float]) – Minimum temperature, must be true \($T_{min} < T_{max}\).
• T_max (Optional[float]) – Maximum temperature, must be true \(T_{min} < T_{max}\).
• omega (Optional[float]) – Burden factor \(\in [0, 1]\).
• mu (Optional[float]) – Dying rate \(\in [0, 1]\).
• S_init (Optional[float]) – Initial supply \(\in (0, \infty)\).
• E_init (Optional[float]) – Initial endurance \(\in (0, \infty)\).

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• omega (Callable[[Union[int, float]], bool])
• mu (Callable[[float], bool])
• alpha (Callable[[float], bool])
• S_init (Callable[[Union[float, int]], bool])
• E_init (Callable[[Union[float, int]], bool])
• T_min (Callable[[Union[float, int], bool])
• T_max (Callable[[Union[float, int], bool])

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

walk(c, cb, task)

Move the camel in search space.

Parameters:

• c (Camel) – Camel that we want to move.
• cb (Camel) – Best know camel.
• task (Task) – Optimization task.

Returns:

Camel that moved in the search space.

Return type:

Camel

class NiaPy.algorithms.basic.MonkeyKingEvolutionV1(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of monkey king evolution algorithm version 1.

Algorithm:

Monkey King Evolution version 1

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.sciencedirect.com/science/article/pii/S0950705116000198

Reference paper:

Zhenyu Meng, Jeng-Shyang Pan, Monkey King Evolution: A new memetic evolutionary algorithm and its application in vehicle fuel consumption optimization, Knowledge-Based Systems, Volume 97, 2016, Pages 144-157, ISSN 0950-7051, https://doi.org/10.1016/j.knosys.2016.01.009.

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• F (float) – Scale factor for normal particles.
• R (float) – TODO.
• C (int) – Number of new particles generated by Monkey King particle.
• FC (float) – Scale factor for Monkey King particles.

See also

• NiaPy.algorithms.algorithm.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MonkeyKingEvolutionV1', 'MKEv1']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get algorithms parametes values.

Returns:Dict[str, Any]

See also

• :func:`NiaPy.algorithms.Algorithm.getParameters

initPopulation(task)

Init population.

Parameters:task (Task) – Optimization task Returns:

1. Initialized solutions
2. Fitness/function values of solution
3. Additional arguments

Return type:Tuple(numpy.ndarray[MkeSolution], numpy.ndarray[float], Dict[str, Any]]

moveMK(x, task)

Move Mokey King paticle.

For moving Monkey King particles algorithm uses next formula: \(\mathbf{x} + \mathit{FC} \odot \mathbf{R} \odot \mathbf{x}\) where \(\mathbf{R}\) is two dimensional array with shape {C * D, D}. Componentes of this array are in range [0, 1]

Parameters:

• x (numpy.ndarray) – Monkey King patricle position.
• task (Task) – Optimization task.

Returns:

New particles generated by Monkey King particle.

Return type:

numpy.ndarray

moveMokeyKingPartice(p, task)

Move Monky King Particles.

Parameters:

• p (MkeSolution) – Monkey King particle to apply this function on.
• task (Task) – Optimization task

moveP(x, x_pb, x_b, task)

Move normal particle in search space.

For moving particles algorithm uses next formula: \(\mathbf{x_{pb} - \mathit{F} \odot \mathbf{r} \odot (\mathbf{x_b} - \mathbf{x})\) where \(\mathbf{r}\) is one dimension array with D components. Components in this vector are in range [0, 1].

Parameters:

• x (numpy.ndarray) – Paticle position.
• x_pb (numpy.ndarray) – Particle best position.
• x_b (numpy.ndarray) – Best particle position.
• task (Task) – Optimization task.

Returns:

Particle new position.

Return type:

numpy.ndarray

movePartice(p, p_b, task)

Move patricles.

Parameters:

• p (MkeSolution) – Monke particle.
• p_b (MkeSolution) – Population best particle.
• task (Task) – Optimization task.

movePopulation(pop, xb, task)

Move population.

Parameters:

• pop (numpy.ndarray[MkeSolution]) – Current population.
• xb (MkeSolution) – Current best solution.
• task (Task) – Optimization task.

Returns:

New particles.

Return type:

numpy.ndarray[MkeSolution]

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of Monkey King Evolution v1 algorithm.

Parameters:

• task (Task) – Optimization task
• pop (numpy.ndarray[MkeSolution]) – Current population
• fpop (numpy.ndarray[float]) – Current population fitness/function values
• xb (MkeSolution) – Current best solution.
• fxb (float) – Current best solutions function/fitness value.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. Initialized solutions.
2. Fitness/function values of solution.
3. Additional arguments.

Return type:

Tuple(numpy.ndarray[MkeSolution], numpy.ndarray[float], Dict[str, Any]]

setParameters(NP=40, F=0.7, R=0.3, C=3, FC=0.5, **ukwargs)

Set Monkey King Evolution v1 algorithms static parameters.

Parameters:

• NP (int) – Population size.
• F (float) – Scale factor for normal particle.
• R (float) – Procentual value of now many new particle Monkey King particle creates. Value in rage [0, 1].
• C (int) – Number of new particles generated by Monkey King particle.
• FC (float) – Scale factor for Monkey King particles.
• **ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.algorithm.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• F (Callable[[int], bool])
• R (Callable[[Union[int, float]], bool])
• C (Callable[[Union[int, float]], bool])
• FC (Callable[[Union[int, float]], bool])

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.MonkeyKingEvolutionV2(**kwargs)

Bases: NiaPy.algorithms.basic.mke.MonkeyKingEvolutionV1

Implementation of monkey king evolution algorithm version 2.

Algorithm:

Monkey King Evolution version 2

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.sciencedirect.com/science/article/pii/S0950705116000198

Reference paper:

Zhenyu Meng, Jeng-Shyang Pan, Monkey King Evolution: A new memetic evolutionary algorithm and its application in vehicle fuel consumption optimization, Knowledge-Based Systems, Volume 97, 2016, Pages 144-157, ISSN 0950-7051, https://doi.org/10.1016/j.knosys.2016.01.009.

Variables:Name (List[str]) – List of strings representing algorithm names.

See also

• NiaPy.algorithms.basic.mke.MonkeyKingEvolutionV1

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MonkeyKingEvolutionV2', 'MKEv2']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

moveMK(x, dx, task)

Move Monkey King particle.

For movment of particles algorithm uses next formula: \(\mathbf{x} - \mathit{FC} \odot \mathbf{dx}\)

Parameters:

• x (numpy.ndarray) – Particle to apply movment on.
• dx (numpy.ndarray) – Difference between to random paricles in population.
• task (Task) – Optimization task.

Returns:

Moved particles.

Return type:

numpy.ndarray

moveMokeyKingPartice(p, pop, task)

Move Monkey King particles.

Parameters:

• p (MkeSolution) – Monkey King particle to move.
• pop (numpy.ndarray[MkeSolution]) – Current population.
• task (Task) – Optimization task.

movePopulation(pop, xb, task)

Move population.

Parameters:

• pop (numpy.ndarray[MkeSolution]) – Current population.
• xb (MkeSolution) – Current best solution.
• task (Task) – Optimization task.

Returns:

Moved population.

Return type:

numpy.ndarray[MkeSolution]

class NiaPy.algorithms.basic.MonkeyKingEvolutionV3(**kwargs)

Bases: NiaPy.algorithms.basic.mke.MonkeyKingEvolutionV1

Implementation of monkey king evolution algorithm version 3.

Algorithm:

Monkey King Evolution version 3

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.sciencedirect.com/science/article/pii/S0950705116000198

Reference paper:

Zhenyu Meng, Jeng-Shyang Pan, Monkey King Evolution: A new memetic evolutionary algorithm and its application in vehicle fuel consumption optimization, Knowledge-Based Systems, Volume 97, 2016, Pages 144-157, ISSN 0950-7051, https://doi.org/10.1016/j.knosys.2016.01.009.

Variables:Name (List[str]) – List of strings that represent algorithm names.

See also

• NiaPy.algorithms.basic.mke.MonkeyKingEvolutionV1

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MonkeyKingEvolutionV3', 'MKEv3']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

initPopulation(task)

Initialize the population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized population function/fitness values.

3. Additional arguments:

   • k (int): TODO.
   • c (int): TODO.

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.algorithm.Algorithm.initPopulation()

neg(x)

Transform function.

Parameters:x (Union[int, float]) – Sould be 0 or 1. Returns:If 0 thet 1 else 1 then 0. Return type:float

runIteration(task, X, X_f, xb, fxb, k, c, **dparams)

Core funciton of Monkey King Evolution v3 algorithm.

Parameters:

• task (Task) – Optimization task
• X (numpy.ndarray) – Current population
• X_f (numpy.ndarray[float]) – Current population fitness/function values
• xb (numpy.ndarray) – Current best individual
• fxb (float) – Current best individual function/fitness value
• k (int) – TODO
• (int (c) – TODO
• **dparams – Additional arguments

Returns:

1. Initialized population.
2. Initialized population function/fitness values.

3. Additional arguments:

   • k (int): TODO.
   • c (int): TODO.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

setParameters(**ukwargs)

Set core parameters of MonkeyKingEvolutionV3 algorithm.

Parameters:**ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.basic.MonkeyKingEvolutionV1.setParameters()

class NiaPy.algorithms.basic.EvolutionStrategy1p1(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of (1 + 1) evolution strategy algorithm. Uses just one individual.

Algorithm:

(1 + 1) Evolution Strategy Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

Reference paper:

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• mu (int) – Number of parents.
• k (int) – Number of iterations before checking and fixing rho.
• c_a (float) – Search range amplification factor.
• c_r (float) – Search range reduction factor.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['EvolutionStrategy1p1', 'EvolutionStrategy(1+1)', 'ES(1+1)']

initPopulation(task)

Initialize starting individual.

Parameters:task (Task) – Optimization task. Returns:1, Initialized individual. 2, Initialized individual fitness/function value. 3. Additional arguments:

• ki (int): Number of successful rho update.

Return type:Tuple[Individual, float, Dict[str, Any]]

mutate(x, rho)

Mutate individual.

Parameters:

• x (Individual) – Current individual.
• rho (float) – Current standard deviation.

Returns:

Mutated individual.

Return type:

Individual

runIteration(task, c, fpop, xb, fxb, ki, **dparams)

Core function of EvolutionStrategy(1+1) algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (Individual) – Current position.
• fpop (float) – Current position function/fitness value.
• xb (Individual) – Global best position.
• fxb (float) – Global best function/fitness value.
• ki (int) – Number of successful updates before rho update.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1, Initialized individual. 2, Initialized individual fitness/function value. 3. New global best solution. 4. New global best soluitons fitness/objective value. 5. Additional arguments:

• ki (int): Number of successful rho update.

Return type:

Tuple[Individual, float, Individual, float, Dict[str, Any]]

setParameters(mu=1, k=10, c_a=1.1, c_r=0.5, epsilon=1e-20, **ukwargs)

Set the arguments of an algorithm.

Parameters:

• mu (Optional[int]) – Number of parents
• k (Optional[int]) – Number of iterations before checking and fixing rho
• c_a (Optional[float]) – Search range amplification factor
• c_r (Optional[float]) – Search range reduction factor

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• mu (Callable[[int], bool])
• k (Callable[[int], bool])
• c_a (Callable[[Union[float, int]], bool])
• c_r (Callable[[Union[float, int]], bool])
• epsilon (Callable[[float], bool])

Return type:Dict[str, Callable]

updateRho(rho, k)

Update standard deviation.

Parameters:

• rho (float) – Current standard deviation.
• k (int) – Number of succesfull mutations.

Returns:

New standard deviation.

Return type:

float

class NiaPy.algorithms.basic.EvolutionStrategyMp1(**kwargs)

Bases: NiaPy.algorithms.basic.es.EvolutionStrategy1p1

Implementation of (mu + 1) evolution strategy algorithm. Algorithm creates mu mutants but into new generation goes only one individual.

Algorithm:

(\(\mu + 1\)) Evolution Strategy Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

Reference paper:

Variables:Name (List[str]) – List of strings representing algorithm names.

See also

• NiaPy.algorithms.basic.EvolutionStrategy1p1

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['EvolutionStrategyMp1', 'EvolutionStrategy(mu+1)', 'ES(m+1)']

setParameters(**kwargs)

Set core parameters of EvolutionStrategy(mu+1) algorithm.

Parameters:**kwargs (Dict[str, Any]) –

See also

• NiaPy.algorithms.basic.EvolutionStrategy1p1.setParameters()

class NiaPy.algorithms.basic.EvolutionStrategyMpL(**kwargs)

Bases: NiaPy.algorithms.basic.es.EvolutionStrategy1p1

Implementation of (mu + lambda) evolution strategy algorithm. Mulation creates lambda individual. Lambda individual compete with mu individuals for survival, so only mu individual go to new generation.

Algorithm:

(\(\mu + \lambda\)) Evolution Strategy Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

Reference paper:

Variables:

• Name (List[str]) – List of strings representing algorithm names
• lam (int) – TODO

See also

• NiaPy.algorithms.basic.EvolutionStrategy1p1

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['EvolutionStrategyMpL', 'EvolutionStrategy(mu+lambda)', 'ES(m+l)']

changeCount(c, cn)

Update number of successful mutations for population.

Parameters:

• c (numpy.ndarray[Individual]) – Current population.
• cn (numpy.ndarray[Individual]) – New population.

Returns:

Number of successful mutations.

Return type:

int

initPopulation(task)

Initialize starting population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized populaiton.
2. Initialized populations function/fitness values.

3. Additional arguments:

   • ki (int): Number of successful mutations.

Return type:Tuple[numpy.ndarray[Individual], numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.algorithm.Algorithm.initPopulation()

mutateRand(pop, task)

Mutate random individual form population.

Parameters:

• pop (numpy.ndarray[Individual]) – Current population.
• task (Task) – Optimization task.

Returns:

Random individual from population that was mutated.

Return type:

numpy.ndarray

runIteration(task, c, fpop, xb, fxb, ki, **dparams)

Core function of EvolutionStrategyMpL algorithm.

Parameters:

• task (Task) – Optimization task.
• c (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individuals fitness/function value.
• ki (int) – Number of successful mutations.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New populations function/fitness values.
3. New global best solution.
4. New global best solutions fitness/objective value.

5. Additional arguments:

   • ki (int): Number of successful mutations.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(lam=45, **ukwargs)

Set the arguments of an algorithm.

Parameters:lam (int) – Number of new individual generated by mutation.

See also

• NiaPy.algorithms.basic.es.EvolutionStrategy1p1.setParameters()

static typeParameters()

TODO.

Returns:

• lam (Callable[[int], bool]): TODO.

Return type:Dict[str, Any]

See also

• NiaPy.algorithms.basic.EvolutionStrategy1p1()

updateRho(pop, k)

Update standard deviation for population.

Parameters:

• pop (numpy.ndarray[Individual]) – Current population.
• k (int) – Number of successful mutations.

class NiaPy.algorithms.basic.EvolutionStrategyML(**kwargs)

Bases: NiaPy.algorithms.basic.es.EvolutionStrategyMpL

Implementation of (mu, lambda) evolution strategy algorithm. Algorithm is good for dynamic environments. Mu individual create lambda chields. Only best mu chields go to new generation. Mu parents are discarded.

Algorithm:

(\(\mu + \lambda\)) Evolution Strategy Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

Reference paper:

Variables:Name (List[str]) – List of strings representing algorithm names

See also

• NiaPy.algorithm.basic.es.EvolutionStrategyMpL

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['EvolutionStrategyML', 'EvolutionStrategy(mu,lambda)', 'ES(m,l)']

initPopulation(task)

Initialize starting population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.

2. Initialized populations fitness/function values. 2. Additional arguments.

Return type:Tuple[numpy.ndarray[Individual], numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithm.basic.es.EvolutionStrategyMpL.initPopulation()

newPop(pop)

Return new population.

Parameters:pop (numpy.ndarray) – Current population. Returns:New population. Return type:numpy.ndarray

runIteration(task, c, fpop, xb, fxb, **dparams)

Core function of EvolutionStrategyML algorithm.

Parameters:

• task (Task) – Optimization task.
• c (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current population fitness/function values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individuals fitness/function value.
• Dict[str, Any] (**dparams) – Additional arguments.

Returns:

1. New population.
2. New populations fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

class NiaPy.algorithms.basic.CovarianceMatrixAdaptionEvolutionStrategy(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of (mu, lambda) evolution strategy algorithm. Algorithm is good for dynamic environments. Mu individual create lambda chields. Only best mu chields go to new generation. Mu parents are discarded.

Algorithm:

(\(\mu + \lambda\)) Evolution Strategy Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://arxiv.org/abs/1604.00772

Reference paper:

Hansen, Nikolaus. “The CMA evolution strategy: A tutorial.” arXiv preprint arXiv:1604.00772 (2016).

Variables:

• Name (List[str]) – List of names representing algorithm names
• epsilon (float) – TODO

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['CovarianceMatrixAdaptionEvolutionStrategy', 'CMA-ES', 'CMAES']

epsilon = 1e-20

runTask(task)

TODO.

Parameters:task (Task) – Optimization task. Returns:TODO.

setParameters(epsilon=1e-20, **ukwargs)

Set core parameters of CovarianceMatrixAdaptionEvolutionStrategy algorithm.

Parameters:

• epsilon (float) – Small number.
• **ukwargs (Dict[str, Any]) – Additional arguments.

static typeParameters()

Return functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Check if number of individuals is \(\in [0, \infty]\).

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.SineCosineAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of sine cosine algorithm.

Algorithm:

Sine Cosine Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.sciencedirect.com/science/article/pii/S0950705115005043

Reference paper:

Seyedali Mirjalili, SCA: A Sine Cosine Algorithm for solving optimization problems, Knowledge-Based Systems, Volume 96, 2016, Pages 120-133, ISSN 0950-7051, https://doi.org/10.1016/j.knosys.2015.12.022.

Variables:

• Name (List[str]) – List of string representing algorithm names.
• a (float) – Parameter for control in \(r_1\) value
• Rmin (float) – Minimu value for \(r_3\) value
• Rmax (float) – Maximum value for \(r_3\) value

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['SineCosineAlgorithm', 'SCA']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get algorithm parameters values.

Returns: Return type:Dict[str, Any]

See also

• NiaPy.algorithms.algorithm.Algorithm.getParameters()

initPopulation(task)

Initialize the individuals.

Parameters:task (Task) – Optimization task Returns:

1. Initialized population of individuals
2. Function/fitness values for individuals
3. Additional arguments

Return type:Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]

nextPos(x, x_b, r1, r2, r3, r4, task)

Move individual to new position in search space.

Parameters:

• x (numpy.ndarray) – Individual represented with components.
• x_b (nmppy.ndarray) – Best individual represented with components.
• r1 (float) – Number dependent on algorithm iteration/generations.
• r2 (float) – Random number in range of 0 and 2 * PI.
• r3 (float) – Random number in range [Rmin, Rmax].
• r4 (float) – Random number in range [0, 1].
• task (Task) – Optimization task.

Returns:

New individual that is moved based on individual x.

Return type:

numpy.ndarray

runIteration(task, P, P_f, xb, fxb, **dparams)

Core function of Sine Cosine Algorithm.

Parameters:

• task (Task) – Optimization task.
• P (numpy.ndarray) – Current population individuals.
• P_f (numpy.ndarray[float]) – Current population individulas function/fitness values.
• xb (numpy.ndarray) – Current best solution to optimization task.
• fxb (float) – Current best function/fitness value.
• dparams (Dict[str, Any]) – Additional parameters.

Returns:

1. New population.
2. New populations fitness/function values.
3. New global best solution
4. New global best fitness/objective value
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=25, a=3, Rmin=0, Rmax=2, **ukwargs)

Set the arguments of an algorithm.

Parameters:

• NP (Optional[int]) – Number of individual in population
• a (Optional[float]) – Parameter for control in \(r_1\) value
• Rmin (Optional[float]) – Minimu value for \(r_3\) value
• Rmax (Optional[float]) – Maximum value for \(r_3\) value

See also

• NiaPy.algorithms.algorithm.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• a (Callable[[Union[float, int]], bool]): TODO
• Rmin (Callable[[Union[float, int]], bool]): TODO
• Rmax (Callable[[Union[float, int]], bool]): TODO

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

class NiaPy.algorithms.basic.GlowwormSwarmOptimization(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of glowwarm swarm optimization.

Algorithm:

Glowwarm Swarm Optimization Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.springer.com/gp/book/9783319515946

Reference paper:

Kaipa, Krishnanand N., and Debasish Ghose. Glowworm swarm optimization: theory, algorithms, and applications. Vol. 698. Springer, 2017.

Variables:

• Name (List[str]) – List of strings represeinting algorithm name.
• l0 (float) – Initial luciferin quantity for each glowworm.
• nt (float) –

  –

• rs (float) – Maximum sensing range.
• rho (float) – Luciferin decay constant.
• gamma (float) – Luciferin enhancement constant.
• beta (float) –

  –

• s (float) –

  –

• Distance (Callable[[numpy.ndarray, numpy.ndarray], float]]) – Measure distance between two individuals.

See also

• NiaPy.algorithms.algorithm.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['GlowwormSwarmOptimization', 'GSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information. Return type:str

calcLuciferin(L, GS_f)

TODO.

Parameters:

• L –
• GS_f –

Returns:

getNeighbors(i, r, GS, L)

Get neighbours of glowworm.

Parameters:

• i (int) – Index of glowworm.
• r (float) – Neighborhood distance.
• GS (numpy.ndarray) –
• L (numpy.ndarray[float]) – Luciferin value of glowworm.

Returns:

Indexes of neighborhood glowworms.

Return type:

numpy.ndarray[int]

getParameters()

Get algorithms parameters values.

Returns:TODO. Return type:Dict[str, Any]

initPopulation(task)

Initialize population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population of glowwarms.
2. Initialized populations function/fitness values.

3. Additional arguments:

   • L (numpy.ndarray): TODO.
   • R (numpy.ndarray): TODO.
   • rs (numpy.ndarray): TODO.

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

moveSelect(pb, i)

TODO.

Parameters:

• pb –
• i –

Returns:

probabilityes(i, N, L)

Calculate probabilities for glowworm to movement.

Parameters:

• i (int) – Index of glowworm to search for probable movement.
• N (numpy.ndarray[float]) –
• L (numpy.ndarray[float]) –

Returns:

Probabilities for each glowworm in swarm.

Return type:

numpy.ndarray[float]

rangeUpdate(R, N, rs)

TODO.

Parameters:

• R –
• N –
• rs –

Returns:

runIteration(task, GS, GS_f, xb, fxb, L, R, rs, **dparams)

Core function of GlowwormSwarmOptimization algorithm.

Parameters:

• task (Task) – Optimization taks.
• GS (numpy.ndarray) – Current population.
• GS_f (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individuals function/fitness value.
• L (numpy.ndarray) –
• R (numpy.ndarray) –
• rs (numpy.ndarray) –
• Dict[str, Any] (**dparams) – Additional arguments.

Returns:

1. Initialized population of glowwarms.
2. Initialized populations function/fitness values.
3. New global best solution
4. New global best sloutions fitness/objective value.

5. Additional arguments:

   • L (numpy.ndarray): TODO.
   • R (numpy.ndarray): TODO.
   • rs (numpy.ndarray): TODO.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(n=25, l0=5, nt=5, rho=0.4, gamma=0.6, beta=0.08, s=0.03, Distance=<function euclidean>, **ukwargs)

Set the arguments of an algorithm.

Parameters:

• n (Optional[int]) – Number of glowworms in population.
• l0 (Optional[float]) – Initial luciferin quantity for each glowworm.
• nt (Optional[float]) –

  –

• rs (Optional]float]) – Maximum sensing range.
• rho (Optional[float]) – Luciferin decay constant.
• gamma (Optional[float]) – Luciferin enhancement constant.
• beta (Optional[float]) –

  –

• s (Optional[float]) –

  –

• Distance (Optional[Callable[[numpy.ndarray, numpy.ndarray], float]]]) – Measure distance between two individuals.

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• n (Callable[[int], bool])
• l0 (Callable[[Union[float, int]], bool])
• nt (Callable[[Union[float, int]], bool])
• rho (Callable[[Union[float, int]], bool])
• gamma (Callable[[float], bool])
• beta (Callable[[float], bool])
• s (Callable[[float], bool])

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.GlowwormSwarmOptimizationV1(**kwargs)

Bases: NiaPy.algorithms.basic.gso.GlowwormSwarmOptimization

Implementation of glowwarm swarm optimization.

Algorithm:

Glowwarm Swarm Optimization Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.springer.com/gp/book/9783319515946

Reference paper:

Kaipa, Krishnanand N., and Debasish Ghose. Glowworm swarm optimization: theory, algorithms, and applications. Vol. 698. Springer, 2017.

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• alpha (float) –

  –

See also

• NiaPy.algorithms.basic.GlowwormSwarmOptimization

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['GlowwormSwarmOptimizationV1', 'GSOv1']

calcLuciferin(L, GS_f)

TODO.

Parameters:

• L –
• GS_f –

Returns:

rangeUpdate(R, N, rs)

TODO.

Parameters:

• R –
• N –
• rs –

Returns:

setParameters(**kwargs)

Set default parameters of the algorithm.

Parameters:**kwargs (dict) – Additional arguments.

class NiaPy.algorithms.basic.GlowwormSwarmOptimizationV2(**kwargs)

Bases: NiaPy.algorithms.basic.gso.GlowwormSwarmOptimization

Implementation of glowwarm swarm optimization.

Algorithm:

Glowwarm Swarm Optimization Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.springer.com/gp/book/9783319515946

Reference paper:

Kaipa, Krishnanand N., and Debasish Ghose. Glowworm swarm optimization: theory, algorithms, and applications. Vol. 698. Springer, 2017.

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• alpha (float) –

  –

See also

• NiaPy.algorithms.basic.GlowwormSwarmOptimization

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['GlowwormSwarmOptimizationV2', 'GSOv2']

rangeUpdate(P, N, rs)

TODO.

Parameters:

• P –
• N –
• rs –

Returns:

TODO

Return type:

float

setParameters(alpha=0.2, **kwargs)

Set core parameters for GlowwormSwarmOptimizationV2 algorithm.

Parameters:

• alpha (Optional[float]) –

  –

• **kwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.basic.GlowwormSwarmOptimization.setParameters()

class NiaPy.algorithms.basic.GlowwormSwarmOptimizationV3(**kwargs)

Bases: NiaPy.algorithms.basic.gso.GlowwormSwarmOptimization

Implementation of glowwarm swarm optimization.

Algorithm:

Glowwarm Swarm Optimization Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.springer.com/gp/book/9783319515946

Reference paper:

Kaipa, Krishnanand N., and Debasish Ghose. Glowworm swarm optimization: theory, algorithms, and applications. Vol. 698. Springer, 2017.

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• beta1 (float) –

  –

See also

• NiaPy.algorithms.basic.GlowwormSwarmOptimization

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['GlowwormSwarmOptimizationV3', 'GSOv3']

rangeUpdate(R, N, rs)

TODO.

Parameters:

• R –
• N –
• rs –

Returns:

setParameters(beta1=0.2, **kwargs)

Set core parameters for GlowwormSwarmOptimizationV3 algorithm.

Parameters:

• beta1 (Optional[float]) –

  –

• **kwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.basic.GlowwormSwarmOptimization.setParameters()

class NiaPy.algorithms.basic.HarmonySearch(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of harmony search algorithm.

Algorithm:

Harmony Search Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://link.springer.com/chapter/10.1007/978-3-642-00185-7_1

Reference paper:

Yang, Xin-She. “Harmony search as a metaheuristic algorithm.” Music-inspired harmony search algorithm. Springer, Berlin, Heidelberg, 2009. 1-14.

Variables:

• Name (List[str]) – List of strings representing algorithm names
• r_accept (float) – Probability of accepting new bandwidth into harmony.
• r_pa (float) – Probability of accepting random bandwidth into harmony.
• b_range (float) – Range of bandwidth.

See also

• NiaPy.algorithms.algorithm.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['HarmonySearch', 'HS']

adjustment(x, task)

Adjust value based on bandwidth.

Parameters:

• x (Union[int, float]) – Current position.
• task (Task) – Optimization task.

Returns:

New position.

Return type:

float

static algorithmInfo()

Get basic information about the algorithm.

Returns:Basic information. Return type:str

bw(task)

Get bandwidth.

Parameters:task (Task) – Optimization task. Returns:Bandwidth. Return type:float

getParameters()

Get parameters of the algorithm.

Returns:

• Parameter name (str): Represents a parameter name
• Value of parameter (Any): Represents the value of the parameter

Return type:Dict[str, Any]

improvize(HM, task)

Create new individual.

Parameters:

• HM (numpy.ndarray) – Current population.
• task (Task) – Optimization task.

Returns:

New individual.

Return type:

numpy.ndarray

initPopulation(task)

Initialize first population.

Parameters:task (Task) – Optimization task. Returns:

1. New harmony/population.
2. New population fitness/function values.
3. Additional parameters.

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.algorithm.Algorithm.initPopulation()

runIteration(task, HM, HM_f, xb, fxb, **dparams)

Core function of HarmonySearch algorithm.

Parameters:

• task (Task) – Optimization task.
• HM (numpy.ndarray) – Current population.
• HM_f (numpy.ndarray) – Current populations function/fitness values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best fitness/function value.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New harmony/population.
2. New populations function/fitness values.
3. New global best solution
4. New global best solution fitness/objective value
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(HMS=30, r_accept=0.7, r_pa=0.35, b_range=1.42, **ukwargs)

Set the arguments of the algorithm.

Parameters:

• HMS (Optional[int]) – Number of harmony in the memory
• r_accept (Optional[float]) – Probability of accepting new bandwidth to harmony.
• r_pa (Optional[float]) – Probability of accepting random bandwidth into harmony.
• b_range (Optional[float]) – Bandwidth range.

See also

• NiaPy.algorithms.algorithm.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• HMS (Callable[[int], bool])
• r_accept (Callable[[float], bool])
• r_pa (Callable[[float], bool])
• b_range (Callable[[float], bool])

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.HarmonySearchV1(**kwargs)

Bases: NiaPy.algorithms.basic.hs.HarmonySearch

Implementation of harmony search algorithm.

Algorithm:

Harmony Search Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://link.springer.com/chapter/10.1007/978-3-642-00185-7_1

Reference paper:

Yang, Xin-She. “Harmony search as a metaheuristic algorithm.” Music-inspired harmony search algorithm. Springer, Berlin, Heidelberg, 2009. 1-14.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• bw_min (float) – Minimal bandwidth.
• bw_max (float) – Maximal bandwidth.

See also

• NiaPy.algorithms.basic.hs.HarmonySearch

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['HarmonySearchV1', 'HSv1']

static algorithmInfo()

Get basic information about algorihtm.

Returns:Basic information. Return type:str

bw(task)

Get new bandwidth.

Parameters:task (Task) – Optimization task. Returns:New bandwidth. Return type:float

getParameters()

Get parameters of the algorithm.

Returns:

• Parameter name (str): Represents a parameter name
• Value of parameter (Any): Represents the value of the parameter

Return type:Dict[str, Any]

setParameters(bw_min=1, bw_max=2, **kwargs)

Set the parameters of the algorithm.

Parameters:

• bw_min (Optional[float]) – Minimal bandwidth
• bw_max (Optional[float]) – Maximal bandwidth
• kwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.basic.hs.HarmonySearch.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:Function for testing correctness of parameters. Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.HarmonySearch.typeParameters()

class NiaPy.algorithms.basic.KrillHerdV1(**kwargs)

Bases: NiaPy.algorithms.basic.kh.KrillHerd

Implementation of krill herd algorithm.

Algorithm:

Krill Herd Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

http://www.sciencedirect.com/science/article/pii/S1007570412002171

Reference paper:

Amir Hossein Gandomi, Amir Hossein Alavi, Krill herd: A new bio-inspired optimization algorithm, Communications in Nonlinear Science and Numerical Simulation, Volume 17, Issue 12, 2012, Pages 4831-4845, ISSN 1007-5704, https://doi.org/10.1016/j.cnsns.2012.05.010.

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• :func:NiaPy.algorithms.basic.kh.KrillHerd.KrillHerd`

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['KrillHerdV1', 'KHv1']

crossover(x, xo, Cr)

Preform a crossover operation on individual.

Parameters:

• x (numpy.ndarray) – Current individual.
• xo (numpy.ndarray) – New individual.
• Cr (float) – Crossover probability.

Returns:

Crossover individual.

Return type:

numpy.ndarray

mutate(x, x_b, Mu)

Mutate individual.

Parameters:

• x (numpy.ndarray) – Current individual.
• x_b (numpy.ndarray) – Global best individual.
• Mu (float) – Mutation probability.

Returns:

Mutated krill.

Return type:

numpy.ndarray

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:Dictionary with testing functions for parameters. Return type:Dict[str, Callable]

See also

• :func:NiaPy.algorithms.basic.kh.KrillHerd.typeParameters`

class NiaPy.algorithms.basic.KrillHerdV2(**kwargs)

Bases: NiaPy.algorithms.basic.kh.KrillHerd

Implementation of krill herd algorithm.

Algorithm:

Krill Herd Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

http://www.sciencedirect.com/science/article/pii/S1007570412002171

Reference paper:

Amir Hossein Gandomi, Amir Hossein Alavi, Krill herd: A new bio-inspired optimization algorithm, Communications in Nonlinear Science and Numerical Simulation, Volume 17, Issue 12, 2012, Pages 4831-4845, ISSN 1007-5704, https://doi.org/10.1016/j.cnsns.2012.05.010.

Variables:Name (List[str]) – List of strings representing algorithm name.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['KrillHerdV2', 'KHv2']

mutate(x, x_b, Mu)

Mutate individual.

Parameters:

• x (numpy.ndarray) – Individual to mutate.
• x_b (numpy.ndarray) – Global best individual.
• Mu (float) – Mutation probability.

Returns:

Mutated individual.

Return type:

numpy.ndarray

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:Dictionary with testing functions for algorithms parameters. Return type:Dict[str, Callable]

See also

• :func:NiaPy.algorithms.basic.kh.KrillHerd.typeParameters`

class NiaPy.algorithms.basic.KrillHerdV3(**kwargs)

Bases: NiaPy.algorithms.basic.kh.KrillHerd

Implementation of krill herd algorithm.

Algorithm:

Krill Herd Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

http://www.sciencedirect.com/science/article/pii/S1007570412002171

Reference paper:

Amir Hossein Gandomi, Amir Hossein Alavi, Krill herd: A new bio-inspired optimization algorithm, Communications in Nonlinear Science and Numerical Simulation, Volume 17, Issue 12, 2012, Pages 4831-4845, ISSN 1007-5704, https://doi.org/10.1016/j.cnsns.2012.05.010.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['KrillHerdV3', 'KHv3']

crossover(x, xo, Cr)

Crossover operator.

Parameters:

• x (numpy.ndarray) – Krill/individual being applied with operator.
• xo (numpy.ndarray) – Krill/individual being used in operator.
• Cr (float) – Crossover probability.

Returns:

Crossover krill/individual.

Return type:

numpy.ndarray

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:Dictionary with testing functions for algorithms parameters. Return type:Dict[str, Callable]

See also

• :func:NiaPy.algorithms.basic.kh.KrillHerd.typeParameters`

class NiaPy.algorithms.basic.KrillHerdV4(**kwargs)

Bases: NiaPy.algorithms.basic.kh.KrillHerd

Implementation of krill herd algorithm.

Algorithm:

Krill Herd Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

http://www.sciencedirect.com/science/article/pii/S1007570412002171

Reference paper:

Amir Hossein Gandomi, Amir Hossein Alavi, Krill herd: A new bio-inspired optimization algorithm, Communications in Nonlinear Science and Numerical Simulation, Volume 17, Issue 12, 2012, Pages 4831-4845, ISSN 1007-5704, https://doi.org/10.1016/j.cnsns.2012.05.010.

Variables:Name (List[str]) – List of strings representing algorithm name.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['KrillHerdV4', 'KHv4']

setParameters(NP=50, N_max=0.01, V_f=0.02, D_max=0.002, C_t=0.93, W_n=0.42, W_f=0.38, d_s=2.63, **ukwargs)

Set algorithm core parameters.

Parameters:

• NP (int) – Number of kills in herd.
• N_max (Optional[float]) – TODO
• V_f (Optional[float]) – TODO
• D_max (Optional[float]) – TODO
• C_t (Optional[float]) – TODO
• W_n (Optional[Union[int, float, numpy.ndarray, list]]) – Weights for neighborhood.
• W_f (Optional[Union[int, float, numpy.ndarray, list]]) – Weights for foraging.
• d_s (Optional[float]) – TODO
• **ukwargs (Dict[str, Any]) – Additional arguments.

See also

• :func:NiaPy.algorithms.basic.kh.KrillHerd.KrillHerd.setParameters`

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:Dictionary with testing functions for parameters. Return type:Dict[str, Callable]

See also

• :func:NiaPy.algorithms.basic.kh.KrillHerd.typeParameters`

class NiaPy.algorithms.basic.KrillHerdV11(**kwargs)

Bases: NiaPy.algorithms.basic.kh.KrillHerd

Implementation of krill herd algorithm.

Algorithm:

Krill Herd Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

Reference paper:

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Cr(KH_f, KHb_f, KHw_f)

Calculate crossover probability.

Parameters:

• KH_f (float) – Krill/individuals function/fitness value.
• KHb_f (float) – Best krill/individual function/fitness value.
• KHw_f (float) – Worst krill/individual function/fitness value.

Returns:

Crossover probability.

Return type:

float

ElitistSelection(KH, KH_f, KHo, KHo_f)

Select krills/individuals that are better than odl krills.

Parameters:

• KH (numpy.ndarray) – Current herd/population.
• KH_f (numpy.ndarray[float]) – Current herd/populations function/fitness values
• KHo (numpy.ndarray) – New herd/population.
• KHo_f (numpy.ndarray[float]) – New herd/populations function/fitness vales.

Returns:

1. New herd/population.
2. New herd/populations function/fitness values.

Return type:

Tuple[numpy.ndarray, numpy.numpy[float]]

Foraging(KH, KH_f, KHo, KHo_f, W_f, F, KH_wf, KH_bf, x_food, x_food_f, task)

Foraging operator.

Parameters:

• KH (numpy.ndarray) – Current heard/population.
• KH_f (numpy.ndarray[float]) – Current herd/populations function/fitness values.
• KHo (numpy.ndarray) – New heard/population.
• KHo_f (numpy.ndarray[float]) – New heard/population function/fitness values.
• W_f (numpy.ndarray) – Weights for foraging.
• () (F) –

  –

• KH_wf (numpy.ndarray) – Worst krill in herd/population.
• KH_bf (numpy.ndarray) – Best krill in herd/population.
• x_food (numpy.ndarray) – Foods position.
• x_food_f (float) – Foods function/fitness value.
• task (Task) – Optimization task.

Returns:

–

Return type:

numpy.ndarray

Name = ['KrillHerdV11', 'KHv11']

Neighbors(i, KH, KH_f, iw, ib, N, W_n, task)

Neighbors operator.

Parameters:

• i (int) – Index of krill being applied with operator.
• KH (numpy.ndarray) – Current herd/population.
• KH_f (numpy.ndarray[float]) – Current herd/populations function/fitness values.
• iw (int) – Index of worst krill/individual.
• ib (int) – Index of best krill/individual.
• () (N) –

  –

• W_n (numpy.ndarray) – Weights for neighbors operator.
• task (Task) – Optimization task.

Returns:

–

Return type:

numpy.ndarray

initPopulation(task)

Initialize firt herd/population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized herd/population.
2. Initialized herd/populations function/fitness values.

3. Additional arguments:

   • KHo (): –
   • KHo_f (): –
   • N (): –
   • F (): –
   • Dt (): –

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

runIteration(task, KH, KH_f, xb, fxb, KHo, KHo_f, N, F, Dt, **dparams)

Core function of KrillHerdV11 algorithm.

Parameters:

• task (Task) – Optimization task.
• KH (numpy.ndarray) – Current herd/population.
• KH_f (numpy.ndarray[float]) – Current herd/populations function/fitness values.
• xb (numpy.ndarray) – Global best krill.
• fxb (float) – Global best krill function/fitness value.
• () (Dt) –
• () –
• () –
• () –
• () –
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New herd/population.
2. New herd/populations function/fitness values.
3. Additional arguments:

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

class NiaPy.algorithms.basic.FireworksAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of fireworks algorithm.

Algorithm:

Fireworks Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://www.springer.com/gp/book/9783662463529

Reference paper:

Tan, Ying. “Firework Algorithm: A Novel Swarm Intelligence Optimization Method.” (2015).

Variables:Name (List[str]) – List of stirngs representing algorithm names.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

ExplodeSpark(x, A, task)

Explode a spark.

Parameters:

• x (numpy.ndarray) – Individuals creating spark.
• A (numpy.ndarray) – Amplitude of spark.
• task (Task) – Optimization task.

Returns:

Sparks exploded in with specified amplitude.

Return type:

numpy.ndarray

ExplosionAmplitude(x_f, xb_f, A, As)

Calculate explosion amplitude.

Parameters:

• x_f (float) – Individuals function/fitness value.
• xb_f (float) – Best individuals function/fitness value.
• A (numpy.ndarray) – Amplitudes.
• () (As) –

Returns:

TODO.

Return type:

numpy.ndarray

GaussianSpark(x, task)

Create gaussian spark.

Parameters:

• x (numpy.ndarray) – Individual creating a spark.
• task (Task) – Optimization task.

Returns:

Spark exploded based on gaussian amplitude.

Return type:

numpy.ndarray

Mapping(x, task)

Fix value to bounds..

Parameters:

• x (numpy.ndarray) – Individual to fix.
• task (Task) – Optimization task.

Returns:

Individual in search range.

Return type:

numpy.ndarray

Name = ['FireworksAlgorithm', 'FWA']

NextGeneration(FW, FW_f, FWn, task)

Generate new generation of individuals.

Parameters:

• FW (numpy.ndarray) – Current population.
• FW_f (numpy.ndarray[float]) – Currents population fitness/function values.
• FWn (numpy.ndarray) – New population.
• task (Task) – Optimization task.

Returns:

1. New population.
2. New populations fitness/function values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float]]

R(x, FW)

Calculate ranges.

Parameters:

• x (numpy.ndarray) – Individual in population.
• FW (numpy.ndarray) – Current population.

Returns:

Ranges values.

Return type:

numpy,ndarray[float]

SparsksNo(x_f, xw_f, Ss)

Calculate number of sparks based on function value of individual.

Parameters:

• x_f (float) – Individuals function/fitness value.
• xw_f (float) – Worst individual function/fitness value.
• () (Ss) – TODO

Returns:

Number of sparks that individual will create.

Return type:

int

static algorithmInfo()

Get default information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

initAmplitude(task)

Initialize amplitudes for dimensions.

Parameters:task (Task) – Optimization task. Returns:Starting amplitudes. Return type:numpy.ndarray[float]

initPopulation(task)

Initialize starting population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized populations function/fitness values.

3. Additional arguments:

   • Ah (numpy.ndarray): Initialized amplitudes.

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.algorithm.Algorithm.initPopulation()

p(r, Rs)

Calculate p.

Parameters:

• r (float) – Range of individual.
• Rs (float) – Sum of ranges.

Returns:

p value.

Return type:

float

runIteration(task, FW, FW_f, xb, fxb, Ah, **dparams)

Core function of Fireworks algorithm.

Parameters:

• task (Task) – Optimization task.
• FW (numpy.ndarray) – Current population.
• FW_f (numpy.ndarray[float]) – Current populations function/fitness values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individuals fitness/function value.
• Ah (numpy.ndarray) – Current amplitudes.
• **dparams (Dict[str, Any) – Additional arguments

Returns:

1. Initialized population.
2. Initialized populations function/fitness values.
3. New global best solution.
4. New global best solutions fitness/objective value.

5. Additional arguments:

   • Ah (numpy.ndarray): Initialized amplitudes.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

See also

• FireworksAlgorithm.SparsksNo().
• FireworksAlgorithm.ExplosionAmplitude()
• FireworksAlgorithm.ExplodeSpark()
• FireworksAlgorithm.GaussianSpark()
• FireworksAlgorithm.NextGeneration()

setParameters(N=40, m=40, a=1, b=2, A=40, epsilon=1e-31, **ukwargs)

Set the arguments of an algorithm.

Parameters:

• N (int) – Number of Fireworks
• m (int) – Number of sparks
• a (int) – Limitation of sparks
• b (int) – Limitation of sparks
• A (float) –

  –

• epsilon (float) – Small number for non 0 devision

static typeParameters()

Return functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Check if number of individuals is \(\in [0, \infty]\).

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.EnhancedFireworksAlgorithm(**kwargs)

Bases: NiaPy.algorithms.basic.fwa.FireworksAlgorithm

Implementation of enganced fireworks algorithm.

Algorithm:

Enhanced Fireworks Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://ieeexplore.ieee.org/document/6557813/

Reference paper:

19. Zheng, A. Janecek and Y. Tan, “Enhanced Fireworks Algorithm,” 2013 IEEE Congress on Evolutionary Computation, Cancun, 2013, pp. 2069-2077. doi: 10.1109/CEC.2013.6557813

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• Ainit (float) – Initial amplitude of sparks.
• Afinal (float) – Maximal amplitude of sparks.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

ExplosionAmplitude(x_f, xb_f, Ah, As, A_min=None)

Calculate explosion amplitude.

Parameters:

• x_f (float) – Individuals function/fitness value.
• xb_f (float) – Best individual function/fitness value.
• Ah (numpy.ndarray) –
• () (As) – TODO.
• A_min (Optional[numpy.ndarray]) – Minimal amplitude values.
• task (Task) – Optimization task.

Returns:

New amplitude.

Return type:

numpy.ndarray

GaussianSpark(x, xb, task)

Create new individual.

Parameters:

• x (numpy.ndarray) –
• xb (numpy.ndarray) –
• task (Task) – Optimization task.

Returns:

New individual generated by gaussian noise.

Return type:

numpy.ndarray

Name = ['EnhancedFireworksAlgorithm', 'EFWA']

NextGeneration(FW, FW_f, FWn, task)

Generate new population.

Parameters:

• FW (numpy.ndarray) – Current population.
• FW_f (numpy.ndarray[float]) – Current populations fitness/function values.
• FWn (numpy.ndarray) – New population.
• task (Task) – Optimization task.

Returns:

1. New population.
2. New populations fitness/function values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float]]

static algorithmInfo()

Get default information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

initPopulation(task)

Initialize population.

Parameters:task (Task) – Optimization task. Returns:

1. Initial population.
2. Initial populations fitness/function values.

3. Additional arguments:

   • Ainit (numpy.ndarray): Initial amplitude values.
   • Afinal (numpy.ndarray): Final amplitude values.
   • A_min (numpy.ndarray): Minimal amplitude values.

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• FireworksAlgorithm.initPopulation()

initRanges(task)

Initialize ranges.

Parameters:task (Task) – Optimization task. Returns:

1. Initial amplitude values over dimensions.
2. Final amplitude values over dimensions.
3. uAmin.

Return type:Tuple[numpy.ndarray[float], numpy.ndarray[float], numpy.ndarray[float]]

runIteration(task, FW, FW_f, xb, fxb, Ah, Ainit, Afinal, A_min, **dparams)

Core function of EnhancedFireworksAlgorithm algorithm.

Parameters:

• task (Task) – Optimization task.
• FW (numpy.ndarray) – Current population.
• FW_f (numpy.ndarray[float]) – Current populations fitness/function values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individuals function/fitness value.
• Ah (numpy.ndarray[float]) – Current amplitude.
• Ainit (numpy.ndarray[float]) – Initial amplitude.
• Afinal (numpy.ndarray[float]) – Final amplitude values.
• A_min (numpy.ndarray[float]) – Minial amplitude values.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. Initial population.
2. Initial populations fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.

5. Additional arguments:

   • Ainit (numpy.ndarray): Initial amplitude values.
   • Afinal (numpy.ndarray): Final amplitude values.
   • A_min (numpy.ndarray): Minimal amplitude values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(Ainit=20, Afinal=5, **ukwargs)

Set EnhancedFireworksAlgorithm algorithms core parameters.

Parameters:

• Ainit (float) – TODO
• Afinal (float) – TODO
• **ukwargs (Dict[str, Any]) – Additional arguments.

See also

• FireworksAlgorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• Ainit (Callable[[Union[int, float]], bool]): TODO
• Afinal (Callable[[Union[int, float]], bool]): TODO

Return type:Dict[str, Callable]

See also

• FireworksAlgorithm.typeParameters()

uAmin(Ainit, Afinal, task)

Calculate the value of uAmin.

Parameters:

• Ainit (numpy.ndarray[float]) – Initial amplitude values over dimensions.
• Afinal (numpy.ndarray[float]) – Final amplitude values over dimensions.
• task (Task) – Optimization task.

Returns:

uAmin.

Return type:

numpy.ndarray[float]

class NiaPy.algorithms.basic.DynamicFireworksAlgorithm(**kwargs)

Bases: NiaPy.algorithms.basic.fwa.DynamicFireworksAlgorithmGauss

Implementation of dynamic fireworks algorithm.

Algorithm:

Dynamic Fireworks Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=6900485&isnumber=6900223

Reference paper:

19. Zheng, A. Janecek, J. Li and Y. Tan, “Dynamic search in fireworks algorithm,” 2014 IEEE Congress on Evolutionary Computation (CEC), Beijing, 2014, pp. 3222-3229. doi: 10.1109/CEC.2014.6900485

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• NiaPy.algorithms.basic.DynamicFireworksAlgorithmGauss

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynamicFireworksAlgorithm', 'dynFWA']

static algorithmInfo()

Get default information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

runIteration(task, FW, FW_f, xb, fxb, Ah, Ab, **dparams)

Core function of Dynamic Fireworks Algorithm.

Parameters:

• task (Task) – Optimization task
• FW (numpy.ndarray) – Current population
• FW_f (numpy.ndarray[float]) – Current population fitness/function values
• xb (numpy.ndarray) – Current best solution
• fxb (float) – Current best solution’s fitness/function value
• () (Ab) – TODO
• () – TODO
• **dparams –

Returns:

1. New population.
2. New population function/fitness values.

3. Additional arguments:

   • Ah (): TODO
   • Ab (): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

class NiaPy.algorithms.basic.DynamicFireworksAlgorithmGauss(**kwargs)

Bases: NiaPy.algorithms.basic.fwa.EnhancedFireworksAlgorithm

Implementation of dynamic fireworks algorithm.

Algorithm:

Dynamic Fireworks Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=6900485&isnumber=6900223

Reference paper:

19. Zheng, A. Janecek, J. Li and Y. Tan, “Dynamic search in fireworks algorithm,” 2014 IEEE Congress on Evolutionary Computation (CEC), Beijing, 2014, pp. 3222-3229. doi: 10.1109/CEC.2014.6900485

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• A_cf (Union[float, int]) – TODO
• C_a (Union[float, int]) – Amplification factor.
• C_r (Union[float, int]) – Reduction factor.
• epsilon (Union[float, int]) – Small value.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

ExplosionAmplitude(x_f, xb_f, Ah, As, A_min=None)

Calculate explosion amplitude.

Parameters:

• x_f (float) – Individuals function/fitness value.
• xb_f (float) – Best individual function/fitness value.
• Ah (numpy.ndarray) –
• () (As) – TODO.
• A_min (Optional[numpy.ndarray]) – Minimal amplitude values.
• task (Task) – Optimization task.

Returns:

New amplitude.

Return type:

numpy.ndarray

Mapping(x, task)

Fix out of bound solution/individual.

Parameters:

• x (numpy.ndarray) – Individual.
• task (Task) – Optimization task.

Returns:

Fixed individual.

Return type:

numpy.ndarray

Name = ['DynamicFireworksAlgorithmGauss', 'dynFWAG']

NextGeneration(FW, FW_f, FWn, task)

TODO.

Parameters:

• FW (numpy.ndarray) – Current population.
• FW_f (numpy.ndarray[float]) – Current populations function/fitness values.
• FWn (numpy.ndarray) – New population.
• task (Task) – Optimization task.

Returns:

1. New population.
2. New populations function/fitness values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float]]

static algorithmInfo()

Get default information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

initAmplitude(task)

Initialize amplitude.

Parameters:task (Task) – Optimization task. Returns:

1. Initial amplitudes.
2. Amplitude for best spark.

Return type:Tuple[numpy.ndarray, numpy.ndarray]

initPopulation(task)

Initialize population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized population function/fitness values.

3. Additional arguments:

   • Ah (): TODO
   • Ab (): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

repair(x, d, epsilon)

Repair solution.

Parameters:

• x (numpy.ndarray) – Individual.
• d (numpy.ndarray) – Default value.
• epsilon (float) – Limiting value.

Returns:

Fixed solution.

Return type:

numpy.ndarray

runIteration(task, FW, FW_f, xb, fxb, Ah, Ab, **dparams)

Core function of DynamicFireworksAlgorithmGauss algorithm.

Parameters:

• task (Task) – Optimization task.
• FW (numpy.ndarray) – Current population.
• FW_f (numpy.ndarray) – Current populations function/fitness values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best fitness/function value.
• Ah (Union[numpy.ndarray, float]) – TODO
• Ab (Union[numpy.ndarray, float]) – TODO
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New populations fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.

5. Additional arguments:

   • Ah (Union[numpy.ndarray, float]): TODO
   • Ab (Union[numpy.ndarray, float]): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(A_cf=20, C_a=1.2, C_r=0.9, epsilon=1e-08, **ukwargs)

Set core arguments of DynamicFireworksAlgorithmGauss.

Parameters:

• A_cf (Union[int, float]) –
• C_a (Union[int, float]) –
• C_r (Union[int, float]) –
• epsilon (Union[int, float]) –
• **ukwargs (Dict[str, Any]) – Additional arguments.

See also

• FireworksAlgorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• A_cr (Callable[[Union[float, int], bool]): TODo

Return type:Dict[str, Callable]

See also

• FireworksAlgorithm.typeParameters()

uCF(xnb, xcb, xcb_f, xb, xb_f, Acf, task)

TODO.

Parameters:

• xnb –
• xcb –
• xcb_f –
• xb –
• xb_f –
• Acf –
• task (Task) – Optimization task.

Returns:

1. TODO

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray]

class NiaPy.algorithms.basic.GravitationalSearchAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of gravitational search algorithm.

Algorithm:

Gravitational Search Algorithm

Date:

2018

Author:

Klemen Berkoivč

License:

MIT

Reference URL:

https://doi.org/10.1016/j.ins.2009.03.004

Reference paper:

Esmat Rashedi, Hossein Nezamabadi-pour, Saeid Saryazdi, GSA: A Gravitational Search Algorithm, Information Sciences, Volume 179, Issue 13, 2009, Pages 2232-2248, ISSN 0020-0255

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• NiaPy.algorithms.algorithm.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

G(t)

TODO.

Parameters:t (int) – TODO Returns:TODO Return type:float

Name = ['GravitationalSearchAlgorithm', 'GSA']

static algorithmInfo()

Get algorithm information.

Returns:Algorithm information. Return type:str

d(x, y, ln=2)

TODO.

Parameters:

• x –
• y –
• ln –

Returns:

TODO

getParameters()

Get algorithm parameters values.

Returns:TODO. Return type:Dict[str, Any]

See also

• NiaPy.algorithms.algorithm.Algorithm.getParameters()

initPopulation(task)

Initialize staring population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized populations fitness/function values.

3. Additional arguments:

   • v (numpy.ndarray[float]): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.algorithm.Algorithm.initPopulation()

runIteration(task, X, X_f, xb, fxb, v, **dparams)

Core function of GravitationalSearchAlgorithm algorithm.

Parameters:

• task (Task) – Optimization task.
• X (numpy.ndarray) – Current population.
• X_f (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best fitness/function value.
• v (numpy.ndarray) – TODO
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New populations fitness/function values.
3. New global best solution
4. New global best solutions fitness/objective value

5. Additional arguments:

   • v (numpy.ndarray): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=40, G_0=2.467, epsilon=1e-17, **ukwargs)

Set the algorithm parameters.

Parameters:

• G_0 (float) – Starting gravitational constant.
• epsilon (float) – TODO.

See also

• NiaPy.algorithms.algorithm.Algorithm.setParameters()

static typeParameters()

TODO.

Returns:

• G_0 (Callable[[Union[int, float]], bool]): TODO
• epsilon (Callable[[float], bool]): TODO

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.algorithm.Algorithm.typeParameters()

class NiaPy.algorithms.basic.MothFlameOptimizer(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

MothFlameOptimizer of Moth flame optimizer.

Algorithm:

Moth flame optimizer

Date:

2018

Author:

Kivanc Guckiran and Klemen Berkovič

License:

MIT

Reference paper:

Mirjalili, Seyedali. “Moth-flame optimization algorithm: A novel nature-inspired heuristic paradigm.” Knowledge-Based Systems 89 (2015): 228-249.

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• NiaPy.algorithms.algorithm.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MothFlameOptimizer', 'MFO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

initPopulation(task)

Initialize starting population.

Parameters:task (Task) – Optimization task Returns:

1. Initialized population
2. Initialized population function/fitness values

3. Additional arguments:

   • best_flames (numpy.ndarray): Best individuals
   • best_flame_fitness (numpy.ndarray): Best individuals fitness/function values
   • previous_population (numpy.ndarray): Previous population
   • previous_fitness (numpy.ndarray[float]): Previous population fitness/function values

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.algorithm.Algorithm.initPopulation()

runIteration(task, moth_pos, moth_fitness, xb, fxb, best_flames, best_flame_fitness, previous_population, previous_fitness, **dparams)

Core function of MothFlameOptimizer algorithm.

Parameters:

• task (Task) – Optimization task.
• moth_pos (numpy.ndarray) – Current population.
• moth_fitness (numpy.ndarray) – Current population fitness/function values.
• xb (numpy.ndarray) – Current population best individual.
• fxb (float) – Current best individual
• best_flames (numpy.ndarray) – Best found individuals
• best_flame_fitness (numpy.ndarray) – Best found individuals fitness/function values
• previous_population (numpy.ndarray) – Previous population
• previous_fitness (numpy.ndarray) – Previous population fitness/function values
• **dparams (Dict[str, Any]) – Additional parameters

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution
4. New global best fitness/objective value

5. Additional arguments:

   • best_flames (numpy.ndarray): Best individuals.
   • best_flame_fitness (numpy.ndarray): Best individuals fitness/function values.
   • previous_population (numpy.ndarray): Previous population.
   • previous_fitness (numpy.ndarray): Previous population fitness/function values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=25, **ukwargs)

Set the algorithm parameters.

Parameters:NP (int) – Number of individuals in population

See also

• NiaPy.algorithms.algorithm.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:TODO Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.algorithm.Algorithm.typeParameters()

class NiaPy.algorithms.basic.FishSchoolSearch(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Fish School Search algorithm.

Algorithm:

Fish School Search algorithm

Date:

2019

Authors:

Clodomir Santana Jr, Elliackin Figueredo, Mariana Maceds, Pedro Santos. Ported to NiaPy with small changes by Kristian Järvenpää (2018). Ported to the NiaPy 2.0 by Klemen Berkovič (2019).

License:

MIT

Reference paper:

Bastos Filho, Lima Neto, Lins, D. O. Nascimento and P. Lima, “A novel search algorithm based on fish school behavior,” in 2008 IEEE International Conference on Systems, Man and Cybernetics, Oct 2008, pp. 2646–2651.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• SI_init (int) – Length of initial individual step.
• SI_final (int) – Length of final individual step.
• SV_init (int) – Length of initial volatile step.
• SV_final (int) – Length of final volatile step.
• min_w (float) – Minimum weight of a fish.
• w_scale (float) – Maximum weight of a fish.

See also

• NiaPy.algorithms.algorithm.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['FSS', 'FishSchoolSearch']

calculate_barycenter(school, task)

Calculate barycenter of fish school.

Parameters:

• school (numpy.ndarray) – Current school fish.
• task (Task) – Optimization task.

Returns:

TODO.

Return type:

numpy.ndarray

collective_instinctive_movement(school, task)

Perform collective instinctive movement.

Parameters:

• school (numpy.ndarray) – Current population.
• task (Task) – Optmization task.

Returns:

New populaiton

Return type:

numpy.ndarray

collective_volitive_movement(school, curr_step_volitive, prev_weight_school, curr_weight_school, xb, fxb, task)

Perform collective volitive movement.

Parameters:

• school (numpy.ndarray) –
• curr_step_volitive –
• prev_weight_school –
• curr_weight_school –
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solutions fitness/objective value.
• task (Task) – Optimization task.

Returns:

New population.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

feeding(school)

Feed all fishes.

Parameters:school (numpy.ndarray) – Current school fish population. Returns:New school fish population. Return type:numpy.ndarray

gen_weight()

Get initial weight for fish.

Returns:Weight for fish. Return type:float

generate_uniform_coordinates(task)

Return Numpy array with uniform distribution.

Parameters:task (Task) – Optimization task. Returns:Array with uniform distribution. Return type:numpy.ndarray

getParameters()

Get algorithm parameters.

Returns:TODO. Return type:Dict[str, Any]

See also

• NiaPy.algorithms.Algorithm.setParameters()

individual_movement(school, curr_step_individual, xb, fxb, task)

Perform individual movement for each fish.

Parameters:

• school (numpy.ndarray) – School fish population.
• curr_step_individual (numpy.ndarray) – TODO
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solutions fitness/objecive value.
• task (Task) – Optimization task.

Returns:

1. New school of fishes.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

initPopulation(task)

Initialize the school.

Parameters:task (Task) – Optimization task. Returns:TODO. Return type:Tuple[numpy.ndarray, numpy.ndarray, dict]

init_fish(pos, task)

Create a new fish to a given position.

Parameters:

• pos –
• task (Task) –

Returns:

init_school(task)

Initialize fish school with uniform distribution.

max_delta_cost(school)

Find maximum delta cost - return 0 if none of the fishes moved.

Parameters:school (numpy.ndarray) –

Returns:

runIteration(task, school, fschool, xb, fxb, curr_step_individual, curr_step_volitive, curr_weight_school, prev_weight_school, **dparams)

Core function of algorithm.

Parameters:

• task (Task) –
• school (numpy.ndarray) –
• fschool (numpy.ndarray) –
• best_fish (numpy.ndarray) –
• fxb (float) –
• curr_step_individual –
• curr_step_volitive –
• curr_weight_school –
• prev_weight_school –
• **dparams –

Returns:

TODO.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, dict]

setParameters(NP=25, SI_init=3, SI_final=10, SV_init=3, SV_final=13, min_w=0.3, w_scale=0.7, **ukwargs)

Set core arguments of FishSchoolSearch algorithm.

Parameters:

• NP (Optional[int]) – Number of fishes in school.
• SI_init (Optional[int]) – Length of initial individual step.
• SI_final (Optional[int]) – Length of final individual step.
• SV_init (Optional[int]) – Length of initial volatile step.
• SV_final (Optional[int]) – Length of final volatile step.
• min_w (Optional[float]) – Minimum weight of a fish.
• w_scale (Optional[float]) – Maximum weight of a fish.

See also

• NiaPy.algorithms.Algorithm.setParameters()

total_school_weight(school, prev_weight_school, curr_weight_school)

Calculate and update current weight of fish school.

Parameters:

• school (numpy.ndarray) –
• prev_weight_school (numpy.ndarray) –
• curr_weight_school (numpy.ndarray) –

Returns:

TODO.

Return type:

Tuple[numpy.ndarray, numpy.ndarray]

static typeParameters()

Return functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Check if number of individuals is \(\in [0, \infty]\).

Return type:Dict[str, Callable]

update_steps(task)

Update step length for individual and volatile steps.

Parameters:task (Task) – Optimization task Returns:TODO. Return type:Tuple[numpy.ndarray, numpy.ndarray]

class NiaPy.algorithms.basic.CuckooSearch(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Cuckoo behaviour and levy flights.

Algorithm:

Cuckoo Search

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference:

Yang, Xin-She, and Suash Deb. “Cuckoo search via Lévy flights.” Nature & Biologically Inspired Computing, 2009. NaBIC 2009. World Congress on. IEEE, 2009.

Variables:

• Name (List[str]) – list of strings representing algorithm names.
• N (int) – Population size.
• pa (float) – Proportion of worst nests.
• alpha (float) – Scale factor for levy flight.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['CuckooSearch', 'CS']

static algorithmInfo()

Get algorithms information.

Returns:Algorithm information. Return type:str

emptyNests(pop, fpop, pa_v, task)

Empty ensts.

Parameters:

• pop (numpy.ndarray) – Current population
• fpop (numpy.ndarray[float]) – Current population fitness/funcion values
• () (pa_v) – TODO.
• task (Task) – Optimization task

Returns:

1. New population
2. New population fitness/function values

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float]]

getParameters()

Get parameters of the algorithm.

Returns:

• Parameter name (str): Represents a parameter name
• Value of parameter (Any): Represents the value of the parameter

Return type:Dict[str, Any]

initPopulation(task)

Initialize starting population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized populations fitness/function values.

3. Additional arguments:

   • pa_v (float): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

runIteration(task, pop, fpop, xb, fxb, pa_v, **dparams)

Core function of CuckooSearch algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individual function/fitness values.
• pa_v (float) – TODO
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. Initialized population.
2. Initialized populations fitness/function values.
3. New global best solution
4. New global best solutions fitness/objective value

5. Additional arguments:

   • pa_v (float): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(N=50, pa=0.2, alpha=0.5, **ukwargs)

Set the arguments of an algorithm.

Parameters:

• N (int) – Population size \(\in [1, \infty)\)
• pa (float) – factor \(\in [0, 1]\)
• alpah (float) – TODO
• **ukwargs (Dict[str, Any]) – Additional arguments

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

TODO.

Returns:

• N (Callable[[int], bool]): TODO
• pa (Callable[[float], bool]): TODO
• alpha (Callable[[Union[int, float]], bool]): TODO

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.CoralReefsOptimization(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Coral Reefs Optimization Algorithm.

Algorithm:

Coral Reefs Optimization Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference Paper:

19. Salcedo-Sanz, J. Del Ser, I. Landa-Torres, S. Gil-López, and J. A. Portilla-Figueras, “The Coral Reefs Optimization Algorithm: A Novel Metaheuristic for Efficiently Solving Optimization Problems,” The Scientific World Journal, vol. 2014, Article ID 739768, 15 pages, 2014.

Reference URL:

https://doi.org/10.1155/2014/739768.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• phi (float) – Range of neighborhood.
• Fa (int) – Number of corals used in asexsual reproduction.
• Fb (int) – Number of corals used in brooding.
• Fd (int) – Number of corals used in depredation.
• k (int) – Nomber of trys for larva setting.
• P_F (float) – Mutation variable \(\in [0, \infty]\).
• P_Cr (float) – Crossover rate in [0, 1].
• Distance (Callable[[numpy.ndarray, numpy.ndarray], float]) – Funciton for calculating distance between corals.
• SexualCrossover (Callable[[numpy.ndarray, float, Task, mtrand.RandomState, Dict[str, Any]], Tuple[numpy.ndarray, numpy.ndarray[float]]]) – Crossover function.
• Brooding (Callable[[numpy.ndarray, float, Task, mtrand.RandomState, Dict[str, Any]], Tuple[numpy.ndarray, numpy.ndarray]]) – Brooding function.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['CoralReefsOptimization', 'CRO']

asexualReprodution(Reef, Reef_f, xb, fxb, task)

Asexual reproduction of corals.

Parameters:

• Reef (numpy.ndarray) – Current population of reefs.
• Reef_f (numpy.ndarray) – Current populations function/fitness values.
• task (Task) – Optimization task.

Returns:

1. New population.
2. New population fitness/funciton values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray]

See also

• NiaPy.algorithms.basic.CoralReefsOptimization.setting()
• NiaPy.algorithms.basic.BroodingSimple()

depredation(Reef, Reef_f)

Depredation operator for reefs.

Parameters:

• Reef (numpy.ndarray) – Current reefs.
• Reef_f (numpy.ndarray) – Current reefs function/fitness values.

Returns:

1. Best individual
2. Best individual fitness/function value

Return type:

Tuple[numpy.ndarray, numpy.ndarray]

getParameters()

Get parameters values of the algorithm.

Returns:TODO. Return type:Dict[str, Any]

runIteration(task, Reef, Reef_f, xb, fxb, **dparams)

Core function of Coral Reefs Optimization algorithm.

Parameters:

• task (Task) – Optimization task.
• Reef (numpy.ndarray) – Current population.
• Reef_f (numpy.ndarray) – Current population fitness/function value.
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solution fitness/function value.
• **dparams – Additional arguments

Returns:

1. New population.
2. New population fitness/function values.
3. New global bset solution
4. New global best solutions fitness/objective value
5. Additional arguments:

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

See also

• NiaPy.algorithms.basic.CoralReefsOptimization.SexualCrossover()
• NiaPy.algorithms.basic.CoralReefsOptimization.Brooding()

setParameters(N=25, phi=0.4, Fa=0.5, Fb=0.5, Fd=0.3, k=25, P_Cr=0.5, P_F=0.36, SexualCrossover=<function SexualCrossoverSimple>, Brooding=<function BroodingSimple>, Distance=<function euclidean>, **ukwargs)

Set the parameters of the algorithm.

Parameters:

• N (int) – population size for population initialization.
• phi (int) – TODO.
• Fa (float) – Value $in [0, 1]$ for Asexual reproduction size.
• Fb (float) – Value $in [0, 1]$ for Brooding size.
• Fd (float) – Value $in [0, 1]$ for Depredation size.
• k (int) – Trys for larvae setting.
• SexualCrossover (Callable[[numpy.ndarray, float, Task, mtrand.RandomState, Dict[str, Any]], Tuple[numpy.ndarray, numpy.ndarray]]) – Crossover function.
• P_Cr (float) – Crossover rate $in [0, 1]$.
• Brooding (Callable[[numpy.ndarray, float, Task, mtrand.RandomState, Dict[str, Any]], Tuple[numpy.ndarray, numpy.ndarray]]) – Brooding function.
• P_F (float) – Crossover rate $in [0, 1]$.
• Distance (Callable[[numpy.ndarray, numpy.ndarray], float]) – Funciton for calculating distance between corals.

See also

• NiaPy.algorithms.Algorithm.setParameters()

setting(X, X_f, Xn, Xn_f, xb, fxb, task)

Operator for setting reefs.

New reefs try to seatle to selected position in search space. New reefs are successful if theyr fitness values is better or if they have no reef ocupying same search space.

Parameters:

• X (numpy.ndarray) – Current population of reefs.
• X_f (numpy.ndarray) – Current populations function/fitness values.
• Xn (numpy.ndarray) – New population of reefs.
• Xn_f (array of float) – New populations function/fitness values.
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solutions fitness/objective value.
• task (Task) – Optimization task.

Returns:

1. New seatled population.
2. New seatled population fitness/function values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float]

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• N (func): TODO
• phi (func): TODO
• Fa (func): TODO
• Fb (func): TODO
• Fd (func): TODO
• k (func): TODO

Return type:Dict[str, Callable]

class NiaPy.algorithms.basic.ForestOptimizationAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Forest Optimization Algorithm.

Algorithm:

Forest Optimization Algorithm

Date:

2019

Authors:

Luka Pečnik

License:

MIT

Reference paper:

Manizheh Ghaemi, Mohammad-Reza Feizi-Derakhshi, Forest Optimization Algorithm, Expert Systems with Applications, Volume 41, Issue 15, 2014, Pages 6676-6687, ISSN 0957-4174, https://doi.org/10.1016/j.eswa.2014.05.009.

References URL:

Implementation is based on the following MATLAB code: https://github.com/cominsys/FOA

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• lt (int) – Life time of trees parameter.
• al (int) – Area limit parameter.
• lsc (int) – Local seeding changes parameter.
• gsc (int) – Global seeding changes parameter.
• tr (float) – Transfer rate parameter.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['ForestOptimizationAlgorithm', 'FOA']

static algorithmInfo()

Get algorithms information.

Returns:Algorithm information. Return type:str

getParameters()

Get parameters values of the algorithm.

Returns:TODO. Return type:Dict[str, Any]

globalSeeding(task, candidates, size)

Global optimum search stage that should prevent getting stuck in a local optimum.

Parameters:

• task (Task) – Optimization task.
• candidates (numpy.ndarray) – Candidate population for global seeding.
• size (int) – Number of trees to produce.

Returns:

Resulting trees.

Return type:

numpy.ndarray

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task Returns:

1. New population.
2. New population fitness/function values.

3. Additional arguments:

   • age (numpy.ndarray[int32]): Age of trees.

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

localSeeding(task, trees)

Local optimum search stage.

Parameters:

• task (Task) – Optimization task.
• trees (numpy.ndarray) – Zero age trees for local seeding.

Returns:

Resulting zero age trees.

Return type:

numpy.ndarray

removeLifeTimeExceeded(trees, candidates, age)

Remove dead trees.

Parameters:

• trees (numpy.ndarray) – Population to test.
• candidates (numpy.ndarray) – Candidate population array to be updated.
• age (numpy.ndarray[int32]) – Age of trees.

Returns:

1. Alive trees.
2. New candidate population.
3. Age of trees.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray[int32]]

runIteration(task, Trees, Evaluations, xb, fxb, age, **dparams)

Core function of Forest Optimization Algorithm.

Parameters:

• task (Task) – Optimization task.
• Trees (numpy.ndarray) – Current population.
• Evaluations (numpy.ndarray[float]) – Current population function/fitness values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individual fitness/function value.
• age (numpy.ndarray[int32]) – Age of trees.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.

3. Additional arguments:

   • age (numpy.ndarray[int32]): Age of trees.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

setParameters(NP=10, lt=3, al=10, lsc=1, gsc=1, tr=0.3, **ukwargs)

Set the parameters of the algorithm.

Parameters:

• NP (Optional[int]) – Population size.
• lt (Optional[int]) – Life time parameter.
• al (Optional[int]) – Area limit parameter.
• lsc (Optional[int]) – Local seeding changes parameter.
• gsc (Optional[int]) – Global seeding changes parameter.
• tr (Optional[float]) – Transfer rate parameter.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

survivalOfTheFittest(task, trees, candidates, age)

Evaluate and filter current population.

Parameters:

• task (Task) – Optimization task.
• trees (numpy.ndarray) – Population to evaluate.
• candidates (numpy.ndarray) – Candidate population array to be updated.
• age (numpy.ndarray[int32]) – Age of trees.

Returns:

1. Trees sorted by fitness value.
2. Updated candidate population.
3. Population fitness values.
4. Age of trees

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray[float], numpy.ndarray[int32]]

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• lt (Callable[[int], bool]): Checks if life time parameter has a proper value.
• al (Callable[[int], bool]): Checks if area limit parameter has a proper value.
• lsc (Callable[[int], bool]): Checks if local seeding changes parameter has a proper value.
• gsc (Callable[[int], bool]): Checks if global seeding changes parameter has a proper value.
• tr (Callable[[float], bool]): Checks if transfer rate parameter has a proper value.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.algorithm.Algorithm.typeParameters()

class NiaPy.algorithms.basic.MonarchButterflyOptimization(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Monarch Butterfly Optimization.

Algorithm:

Monarch Butterfly Optimization

Date:

2019

Authors:

Jan Banko

License:

MIT

Reference paper:

Wang, Gai-Ge & Deb, Suash & Cui, Zhihua. (2015). Monarch Butterfly Optimization. Neural Computing and Applications. 10.1007/s00521-015-1923-y. , https://www.researchgate.net/publication/275964443_Monarch_Butterfly_Optimization.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• PAR (float) – Partition.
• PER (float) – Period.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MonarchButterflyOptimization', 'MBO']

adjustingOperator(t, max_t, D, NP1, NP2, Butterflies, best)

Apply the adjusting operator.

Parameters:

• t (int) – Current generation.
• max_t (int) – Maximum generation.
• D (int) – Number of dimensions.
• NP1 (int) – Number of butterflies in Land 1.
• NP2 (int) – Number of butterflies in Land 2.
• Butterflies (numpy.ndarray) – Current butterfly population.
• best (numpy.ndarray) – The best butterfly currently.

Returns:

Adjusted butterfly population.

Return type:

numpy.ndarray

static algorithmInfo()

Get information of the algorithm.

Returns:Algorithm information. Return type:str

See also

• NiaPy.algorithms.algorithm.Algorithm.algorithmInfo()

evaluateAndSort(task, Butterflies)

Evaluate and sort the butterfly population.

Parameters:

• task (Task) – Optimization task
• Butterflies (numpy.ndarray) – Current butterfly population.

Returns:

Tuple[numpy.ndarray, float, numpy.ndarray]:

1. Best butterfly according to the evaluation.
2. The best fitness value.
3. Butterfly population.

Return type:

numpy.ndarray

getParameters()

Get parameters values for the algorithm.

Returns:TODO. Return type:Dict[str, Any]

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task Returns:

1. New population.
2. New population fitness/function values.

3. Additional arguments:

   • dx (float): A small value used in local seeding stage.

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

levy(step_size, D)

Calculate levy flight.

Parameters:

• step_size (float) – Size of the walk step.
• D (int) – Number of dimensions.

Returns:

Calculated values for levy flight.

Return type:

numpy.ndarray

migrationOperator(D, NP1, NP2, Butterflies)

Apply the migration operator.

Parameters:

• D (int) – Number of dimensions.
• NP1 (int) – Number of butterflies in Land 1.
• NP2 (int) – Number of butterflies in Land 2.
• Butterflies (numpy.ndarray) – Current butterfly population.

Returns:

Adjusted butterfly population.

Return type:

numpy.ndarray

repair(x, lower, upper)

Truncate exceeded dimensions to the limits.

Parameters:

• x (numpy.ndarray) – Individual to repair.
• lower (numpy.ndarray) – Lower limits for dimensions.
• upper (numpy.ndarray) – Upper limits for dimensions.

Returns:

Repaired individual.

Return type:

numpy.ndarray

runIteration(task, Butterflies, Evaluations, xb, fxb, tmp_best, **dparams)

Core function of Forest Optimization Algorithm.

Parameters:

• task (Task) – Optimization task.
• Butterflies (numpy.ndarray) – Current population.
• Evaluations (numpy.ndarray[float]) – Current population function/fitness values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individual fitness/function value.
• tmp_best (numpy.ndarray) – Best individual currently.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution
4. New global best solutions fitness/objective value

5. Additional arguments:

   • dx (float): A small value used in local seeding stage.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=20, PAR=0.4166666666666667, PER=1.2, **ukwargs)

Set the parameters of the algorithm.

Parameters:

• NP (Optional[int]) – Population size.
• PAR (Optional[int]) – Partition.
• PER (Optional[int]) – Period.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• PAR (Callable[[float], bool]): Checks if partition parameter has a proper value.
• PER (Callable[[float], bool]): Checks if period parameter has a proper value.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.algorithm.Algorithm.typeParameters()

class NiaPy.algorithms.basic.BeesAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Bees algorithm.

Algorithm:

The Bees algorithm

Date:

2019

Authors:

Rok Potočnik

License:

MIT

Reference paper:

DT Pham, A Ghanbarzadeh, E Koc, S Otri, S Rahim, and M Zaidi. The bees algorithm-a novel tool for complex optimisation problems. In Proceedings of the 2nd Virtual International Conference on Intelligent Production Machines and Systems (IPROMS 2006), pages 454–459, 2006

Variables:

• NP (Optional[int]) – Number of scout bees parameter.
• m (Optional[int]) – Number of sites selected out of n visited sites parameter.
• e (Optional[int]) – Number of best sites out of m selected sitest parameter.
• nep (Optional[int]) – Number of bees recruited for best e sites parameter.
• nsp (Optional[int]) – Number of bees recruited for the other selected sites parameter.
• ngh (Optional[float]) – Initial size of patches parameter.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['BeesAlgorithm', 'BEA']

static algorithmInfo()

Get algorithm information.

Returns:Bit item. Return type:str

beeDance(x, task, ngh)

Bees Dance. Search for new positions.

Parameters:

• x (numpy.ndarray) – One instance from the population.
• task (Task) – Optimization task
• ngh (float) – A small value for patch search.

Returns:

1. New population.
2. New population fitness/function values.

Return type:

Tuple[numpy.ndarray, float]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

getParameters()

Get parameters of the algorithm.

Returns: Return type:Dict[str, Any]

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task Returns:

1. New population.
2. New population fitness/function values.

Return type:Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

repair(x, lower, upper)

Truncate exceeded dimensions to the limits.

Parameters:

• x (numpy.ndarray) – Individual to repair.
• lower (numpy.ndarray) – Lower limits for dimensions.
• upper (numpy.ndarray) – Upper limits for dimensions.

Returns:

Repaired individual.

Return type:

numpy.ndarray

runIteration(task, BeesPosition, BeesCost, xb, fxb, ngh, **dparams)

Core function of Forest Optimization Algorithm.

Parameters:

• task (Task) – Optimization task.
• BeesPosition (numpy.ndarray[float]) – Current population.
• BeesCost (numpy.ndarray[float]) – Current population function/fitness values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best individual fitness/function value.
• ngh (float) – A small value used for patches.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution
4. New global best fitness/objective value

5. Additional arguments:

   • ngh (float): A small value used for patches.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=40, m=5, e=4, ngh=1, nep=4, nsp=2, **ukwargs)

Set the parameters of the algorithm.

Parameters:

• NP (Optional[int]) – Number of scout bees parameter.
• m (Optional[int]) – Number of sites selected out of n visited sites parameter.
• e (Optional[int]) – Number of best sites out of m selected sitest parameter.
• nep (Optional[int]) – Number of bees recruited for best e sites parameter.
• nsp (Optional[int]) – Number of bees recruited for the other selected sites parameter.
• ngh (Optional[float]) – Initial size of patches parameter.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Checks if number of bees parameter has a proper value.
• m (Callable[[int], bool]): Checks if number of selected sites parameter has a proper value.
• e (Callable[[int], bool]): Checks if number of elite selected sites parameter has a proper value.
• nep (Callable[[int], bool]): Checks if number of elite bees parameter has a proper value.
• nsp (Callable[[int], bool]): Checks if number of other bees parameter has a proper value.
• ngh (Callable[[float], bool]): Checks if size of patches parameter has a proper value.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.algorithm.Algorithm.typeParameters()

class NiaPy.algorithms.basic.ParticleSwarmOptimization(**kwargs)

Bases: NiaPy.algorithms.basic.pso.ParticleSwarmAlgorithm

Implementation of Particle Swarm Optimization algorithm.

Algorithm:

Particle Swarm Optimization algorithm

Date:

2018

Authors:

Lucija Brezočnik, Grega Vrbančič, Iztok Fister Jr. and Klemen Berkovič

License:

MIT

Reference paper:

Kennedy, J. and Eberhart, R. “Particle Swarm Optimization”. Proceedings of IEEE International Conference on Neural Networks. IV. pp. 1942–1948, 1995.

Variables:

• Name (List[str]) – List of strings representing algorithm names
• C1 (float) – Cognitive component.
• C2 (float) – Social component.
• Repair (Callable[[numpy.ndarray, numpy.ndarray, numpy.ndarray, mtrnd.RandomState], numpy.ndarray]) – Repair method for velocity.

See also

• NiaPy.algorithms.basic.WeightedVelocityClampingParticleSwarmAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['ParticleSwarmAlgorithm', 'PSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get value of parametrs for this instance of algorithm.

Returns:Dictionari which has parameters maped to values. Return type:Dict[str, Union[int, float, np.ndarray]]

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm.getParameters()

setParameters(**ukwargs)

Set core parameters of algorithm.

Parameters:**ukwargs (Dict[str, Any]) – Additional parameters.

See also

• NiaPy.algorithms.basic.WeightedVelocityClampingParticleSwarmAlgorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• NP: Population size.
• C1: Cognitive component.
• C2: Social component.

Return type:Dict[str, Callable[[Union[int, float]], bool]]

class NiaPy.algorithms.basic.MutatedParticleSwarmOptimization(**kwargs)

Bases: NiaPy.algorithms.basic.pso.ParticleSwarmAlgorithm

Implementation of Mutated Particle Swarm Optimization.

Algorithm:

Mutated Particle Swarm Optimization

Date:

2019

Authors:

Klemen Berkovič

License:

MIT

Reference paper:

8. Wang, C. Li, Y. Liu, S. Zeng, A hybrid particle swarm algorithm with cauchy mutation, Proceedings of the 2007 IEEE Swarm Intelligence Symposium (2007) 356–360.

Variables:nmutt (int) – Number of mutations of global best particle.

See also

• NiaPy.algorithms.basic.WeightedVelocityClampingParticleSwarmAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MutatedParticleSwarmOptimization', 'MPSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get value of parametrs for this instance of algorithm.

Returns:Dictionari which has parameters maped to values. Return type:Dict[str, Union[int, float, np.ndarray]]

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm.getParameters()

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population of particles.
• fpop (numpy.ndarray) – Current particles function/fitness values.
• xb (numpy.ndarray) – Current global best particle.
• fxb (float) – Current global best particles function/fitness value.
• **dparams – Additional arguments.

Returns:

1. New population of particles.
2. New populations function/fitness values.
3. New global best particle.
4. New global best particle function/fitness value.
5. Additional arguments.

Return type:

Tuple[np.ndarray, np.ndarray, np.ndarray, float, dict]

See also

• NiaPy.algorithm.basic.WeightedVelocityClampingParticleSwarmAlgorithm.runIteration()

setParameters(nmutt=10, **kwargs)

Set core algorithm parameters.

Parameters:

• nmutt (int) – Number of mutations of global best particle.
• **kwargs – Additional arguments.

See also

NiaPy.algorithm.basic.WeightedVelocityClampingParticleSwarmAlgorithm.setParameters()

class NiaPy.algorithms.basic.MutatedCenterUnifiedParticleSwarmOptimization(**kwargs)

Bases: NiaPy.algorithms.basic.pso.MutatedCenterParticleSwarmOptimization

Implementation of Mutated Particle Swarm Optimization.

Algorithm:

Mutated Center Unified Particle Swarm Optimization

Date:

2019

Authors:

Klemen Berkovič

License:

MIT

Reference paper:

Tsai, Hsing-Chih. “Unified particle swarm delivers high efficiency to particle swarm optimization.” Applied Soft Computing 55 (2017): 371-383.

Variables:nmutt (int) – Number of mutations of global best particle.

See also

• NiaPy.algorithms.basic.CenterParticleSwarmOptimization

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MutatedCenterUnifiedParticleSwarmOptimization', 'MCUPSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

setParameters(**kwargs)

Set core algorithm parameters.

Parameters:**kwargs – Additional arguments.

See also

NiaPy.algorithm.basic.MutatedCenterParticleSwarmOptimization.setParameters()

updateVelocity(V, p, pb, gb, w, vMin, vMax, task, **kwargs)

Update particle velocity.

Parameters:

• V (numpy.ndarray) – Current velocity of particle.
• p (numpy.ndarray) – Current position of particle.
• pb (numpy.ndarray) – Personal best position of particle.
• gb (numpy.ndarray) – Global best position of particle.
• w (numpy.ndarray) – Weights for velocity adjustment.
• vMin (numpy.ndarray) – Minimal velocity allowed.
• vMax (numpy.ndarray) – Maxmimal velocity allowed.
• task (Task) – Optimization task.
• kwargs – Additional arguments.

Returns:

Updated velocity of particle.

Return type:

numpy.ndarray

class NiaPy.algorithms.basic.MutatedCenterParticleSwarmOptimization(**kwargs)

Bases: NiaPy.algorithms.basic.pso.CenterParticleSwarmOptimization

Implementation of Mutated Particle Swarm Optimization.

Algorithm:

Mutated Center Particle Swarm Optimization

Date:

2019

Authors:

Klemen Berkovič

License:

MIT

Reference paper:

TODO find one

Variables:nmutt (int) – Number of mutations of global best particle.

See also

• NiaPy.algorithms.basic.CenterParticleSwarmOptimization

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MutatedCenterParticleSwarmOptimization', 'MCPSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get value of parametrs for this instance of algorithm.

Returns:Dictionari which has parameters maped to values. Return type:Dict[str, Union[int, float, np.ndarray]]

See also

• NiaPy.algorithms.basic.CenterParticleSwarmOptimization.getParameters()

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population of particles.
• fpop (numpy.ndarray) – Current particles function/fitness values.
• xb (numpy.ndarray) – Current global best particle.
• (float (fxb) – Current global best particles function/fitness value.
• **dparams – Additional arguments.

Returns:

1. New population of particles.
2. New populations function/fitness values.
3. New global best particle.
4. New global best particle function/fitness value.
5. Additional arguments.

Return type:

Tuple[np.ndarray, np.ndarray, np.ndarray, float, dict]

See also

• NiaPy.algorithm.basic.WeightedVelocityClampingParticleSwarmAlgorithm.runIteration()

setParameters(nmutt=10, **kwargs)

Set core algorithm parameters.

Parameters:

• nmutt (int) – Number of mutations of global best particle.
• **kwargs – Additional arguments.

See also

NiaPy.algorithm.basic.CenterParticleSwarmOptimization.setParameters()

class NiaPy.algorithms.basic.OppositionVelocityClampingParticleSwarmOptimization(**kwargs)

Bases: NiaPy.algorithms.basic.pso.ParticleSwarmAlgorithm

Implementation of Opposition-Based Particle Swarm Optimization with Velocity Clamping.

Algorithm:

Opposition-Based Particle Swarm Optimization with Velocity Clamping

Date:

2019

Authors:

Klemen Berkovič

License:

MIT

Reference paper:

Shahzad, Farrukh, et al. “Opposition-based particle swarm optimization with velocity clamping (OVCPSO).” Advances in Computational Intelligence. Springer, Berlin, Heidelberg, 2009. 339-348

Variables:

• p0 – Probability of opposite learning phase.
• w_min – Minimum inertial weight.
• w_max – Maximum inertial weight.
• sigma – Velocity scaling factor.

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['OppositionVelocityClampingParticleSwarmOptimization', 'OVCPSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get value of parametrs for this instance of algorithm.

Returns:Dictionari which has parameters maped to values. Return type:Dict[str, Union[int, float, np.ndarray]]

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm.getParameters()

initPopulation(task)

Init starting population and dynamic parameters.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized populations function/fitness values.

3. Additional arguments:

   • popb (numpy.ndarray): particles best population.
   • fpopb (numpy.ndarray[float]): particles best positions function/fitness value.
   • vMin (numpy.ndarray): Minimal velocity.
   • vMax (numpy.ndarray): Maximal velocity.
   • V (numpy.ndarray): Initial velocity of particle.
   • S_u (numpy.ndarray): Upper bound for opposite learning.
   • S_l (numpy.ndarray): Lower bound for opposite learning.

Return type:Tuple[np.ndarray, np.ndarray, dict]

oppositeLearning(S_l, S_h, pop, fpop, task)

Run opposite learning phase.

Parameters:

• S_l (numpy.ndarray) – Lower limit of opposite particles.
• S_h (numpy.ndarray) – Upper limit of opposite particles.
• pop (numpy.ndarray) – Current populations positions.
• fpop (numpy.ndarray) – Current populations functions/fitness values.
• task (Task) – Optimization task.

Returns:

1. New particles position
2. New particles function/fitness values
3. New best position of opposite learning phase
4. new best function/fitness value of opposite learning phase

Return type:

Tuple[np.ndarray, np.ndarray, np.ndarray, float]

runIteration(task, pop, fpop, xb, fxb, popb, fpopb, vMin, vMax, V, S_l, S_h, **dparams)

Core function of Opposite-based Particle Swarm Optimization with velocity clamping algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations function/fitness values.
• xb (numpy.ndarray) – Current global best position.
• fxb (float) – Current global best positions function/fitness value.
• popb (numpy.ndarray) – Personal best position.
• fpopb (numpy.ndarray) – Personal best positions function/fitness values.
• vMin (numpy.ndarray) – Minimal allowed velocity.
• vMax (numpy.ndarray) – Maximal allowed velocity.
• V (numpy.ndarray) – Populations velocity.
• S_l (numpy.ndarray) – Lower bound of opposite learning.
• S_h (numpy.ndarray) – Upper bound of opposite learning.
• **dparams – Additional arguments.

Returns:

1. New population.
2. New populations function/fitness values.
3. New global best position.
4. New global best positions function/fitness value.

5. Additional arguments:

   • popb: particles best population.
   • fpopb: particles best positions function/fitness value.
   • vMin: Minimal velocity.
   • vMax: Maximal velocity.
   • V: Initial velocity of particle.
   • S_u: Upper bound for opposite learning.
   • S_l: Lower bound for opposite learning.

Return type:

Tuple[np.ndarray, np.ndarray, np.ndarray, float, dict]

setParameters(p0=0.3, w_min=0.4, w_max=0.9, sigma=0.1, C1=1.49612, C2=1.49612, **kwargs)

Set core algorithm parameters.

Parameters:

• p0 (float) – Probability of running Opposite learning.
• w_min (numpy.ndarray) – Minimal value of weights.
• w_max (numpy.ndarray) – Maximum value of weights.
• sigma (numpy.ndarray) – Velocity range factor.
• **kwargs – Additional arguments.

See also

• NiaPy.algorithm.basic.ParticleSwarmAlgorithm.setParameters()

class NiaPy.algorithms.basic.ComprehensiveLearningParticleSwarmOptimizer(**kwargs)

Bases: NiaPy.algorithms.basic.pso.ParticleSwarmAlgorithm

Implementation of Mutated Particle Swarm Optimization.

Algorithm:

Comprehensive Learning Particle Swarm Optimizer

Date:

2019

Authors:

Klemen Berkovič

License:

MIT

Reference paper:

10. 10. Liang, A. K. Qin, P. N. Suganthan and S. Baskar, “Comprehensive learning particle swarm optimizer for global optimization of multimodal functions,” in IEEE Transactions on Evolutionary Computation, vol. 10, no. 3, pp. 281-295, June 2006. doi: 10.1109/TEVC.2005.857610

Reference URL:

http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=1637688&isnumber=34326

Variables:

• w0 (float) – Inertia weight.
• w1 (float) – Inertia weight.
• C (float) – Velocity constant.
• m (int) – Refresh rate.

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['ComprehensiveLearningParticleSwarmOptimizer', 'CLPSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

generatePbestCL(i, Pc, pbs, fpbs)

Generate new personal best position for learning.

Parameters:

• i (int) – Current particle.
• Pc (float) – Learning probability.
• pbs (numpy.ndarray) – Personal best positions for population.
• fpbs (numpy.ndarray) – Personal best positions function/fitness values for persolan best position.

Returns:

Personal best for learning.

Return type:

numpy.ndarray

getParameters()

Get value of parametrs for this instance of algorithm.

Returns:Dictionari which has parameters maped to values. Return type:Dict[str, Union[int, float, np.ndarray]]

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm.getParameters()

init(task)

Initialize dynamic arguments of Particle Swarm Optimization algorithm.

Parameters:task (Task) – Optimization task. Returns:

• vMin: Mininal velocity.
• vMax: Maximal velocity.
• V: Initial velocity of particle.
• flag: Refresh gap counter.

Return type:Dict[str, np.ndarray]

runIteration(task, pop, fpop, xb, fxb, popb, fpopb, vMin, vMax, V, flag, Pc, **dparams)

Core function of algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current populations.
• fpop (numpy.ndarray) – Current population fitness/function values.
• xb (numpy.ndarray) – Current best particle.
• fxb (float) – Current best particle fitness/function value.
• popb (numpy.ndarray) – Particles best position.
• fpopb (numpy.ndarray) – Particles best positions fitness/function values.
• vMin (numpy.ndarray) – Minimal velocity.
• vMax (numpy.ndarray) – Maximal velocity.
• V (numpy.ndarray) – Velocity of particles.
• flag (numpy.ndarray) – Refresh rate counter.
• Pc (numpy.ndarray) – Learning rate.
• **dparams (Dict[str, Any]) – Additional function arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best position.
4. New global best positions function/fitness value.

5. Additional arguments:

   • popb: Particles best population.
   • fpopb: Particles best positions function/fitness value.
   • vMin: Minimal velocity.
   • vMax: Maximal velocity.
   • V: Initial velocity of particle.
   • flag: Refresh gap counter.
   • Pc: Learning rate.

Return type:

Tuple[np.ndarray, np.ndarray, np.ndarray, dict]

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm.runIteration

setParameters(m=10, w0=0.9, w1=0.4, C=1.49445, **ukwargs)

Set Particle Swarm Algorithm main parameters.

Parameters:

• w0 (int) – Inertia weight.
• w1 (float) – Inertia weight.
• C (float) – Velocity constant.
• m (float) – Refresh rate.
• **ukwargs – Additional arguments

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm.setParameters()

updateVelocityCL(V, p, pb, w, vMin, vMax, task, **kwargs)

Update particle velocity.

Parameters:

• V (numpy.ndarray) – Current velocity of particle.
• p (numpy.ndarray) – Current position of particle.
• pb (numpy.ndarray) – Personal best position of particle.
• w (numpy.ndarray) – Weights for velocity adjustment.
• vMin (numpy.ndarray) – Minimal velocity allowed.
• vMax (numpy.ndarray) – Maxmimal velocity allowed.
• task (Task) – Optimization task.
• kwargs – Additional arguments.

Returns:

Updated velocity of particle.

Return type:

numpy.ndarray

class NiaPy.algorithms.basic.CenterParticleSwarmOptimization(**kwargs)

Bases: NiaPy.algorithms.basic.pso.ParticleSwarmAlgorithm

Implementation of Center Particle Swarm Optimization.

Algorithm:

Center Particle Swarm Optimization

Date:

2019

Authors:

Klemen Berkovič

License:

MIT

Reference paper:

H.-C. Tsai, Predicting strengths of concrete-type specimens using hybrid multilayer perceptrons with center-Unified particle swarm optimization, Adv. Eng. Softw. 37 (2010) 1104–1112.

See also

• NiaPy.algorithms.basic.WeightedVelocityClampingParticleSwarmAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['CenterParticleSwarmOptimization', 'CPSO']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get value of parametrs for this instance of algorithm.

Returns:Dictionari which has parameters maped to values. Return type:Dict[str, Union[int, float, np.ndarray]]

See also

• NiaPy.algorithms.basic.ParticleSwarmAlgorithm.getParameters()

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population of particles.
• fpop (numpy.ndarray) – Current particles function/fitness values.
• xb (numpy.ndarray) – Current global best particle.
• fxb (numpy.ndarray) – Current global best particles function/fitness value.
• **dparams – Additional arguments.

Returns:

1. New population of particles.
2. New populations function/fitness values.
3. New global best particle.
4. New global best particle function/fitness value.
5. Additional arguments.

Return type:

Tuple[np.ndarray, np.ndarray, np.ndarray, float, dict]

See also

• NiaPy.algorithm.basic.WeightedVelocityClampingParticleSwarmAlgorithm.runIteration()

setParameters(**kwargs)

Set core algorithm parameters.

Parameters:**kwargs – Additional arguments.

See also

NiaPy.algorithm.basic.WeightedVelocityClampingParticleSwarmAlgorithm.setParameters()

NiaPy.algorithms.modified

Implementation of modified nature-inspired algorithms.

class NiaPy.algorithms.modified.HybridBatAlgorithm(**kwargs)

Bases: NiaPy.algorithms.basic.ba.BatAlgorithm

Implementation of Hybrid bat algorithm.

Algorithm:

Hybrid bat algorithm

Date:

2018

Author:

Grega Vrbancic and Klemen Berkovič

License:

MIT

Reference paper:

Fister Jr., Iztok and Fister, Dusan and Yang, Xin-She. “A Hybrid Bat Algorithm”. Elektrotehniski vestnik, 2013. 1-7.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• F (float) – Scaling factor.
• CR (float) – Crossover.

See also

• NiaPy.algorithms.basic.BatAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['HybridBatAlgorithm', 'HBA']

static algorithmInfo()

Get basic information about the algorithm.

Returns:Basic information. Return type:str

localSearch(best, task, i, Sol, **kwargs)

Improve the best solution.

Parameters:

• best (numpy.ndarray) – Global best individual.
• task (Task) – Optimization task.
• i (int) – Index of current individual.
• Sol (numpy.ndarray) – Current best population.
• **kwargs (Dict[str, Any]) –

Returns:

New solution based on global best individual.

Return type:

numpy.ndarray

setParameters(F=0.5, CR=0.9, CrossMutt=<function CrossBest1>, **ukwargs)

Set core parameters of HybridBatAlgorithm algorithm.

Parameters:

• F (Optional[float]) – Scaling factor.
• CR (Optional[float]) – Crossover.

See also

• NiaPy.algorithms.basic.BatAlgorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• F (Callable[[Union[int, float]], bool]): Scaling factor.
• CR (Callable[[float], bool]): Crossover probability.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.BatAlgorithm.typeParameters()

class NiaPy.algorithms.modified.DifferentialEvolutionMTS(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution, NiaPy.algorithms.other.mts.MultipleTrajectorySearch

Implementation of Differential Evolution with MTS local searches.

Algorithm:

Differential Evolution withm MTS local searches

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:

• Name (List[str]) – List of strings representing algorithm names.
• LSs (Iterable[Callable[[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray, Task, Dict[str, Any]], Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, int, numpy.ndarray]]]) – Local searches to use.
• BONUS1 (int) – Bonus for improving global best solution.
• BONUS2 (int) – Bonus for improving solution.
• NoLsTests (int) – Number of test runs on local search algorithms.
• NoLs (int) – Number of local search algorithm runs.
• NoEnabled (int) – Number of best solution for testing.

See also

• NiaPy.algorithms.basic.de.DifferentialEvolution
• NiaPy.algorithms.other.mts.MultipleTrajectorySearch

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DifferentialEvolutionMTS', 'DEMTS']

getParameters()

Get parameters values of the algorithm.

Returns:TODO Return type:Dict[str, Any]

See also

• NiaPy.algorithms.Algorithm.getParameters()

postSelection(X, task, xb, fxb, **kwargs)

Post selection operator.

Parameters:

• X (numpy.ndarray) – Current populaiton.
• task (Task) – Optimization task.
• xb (numpy.ndarray) – Global best individual.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

New population.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

setParameters(NoLsTests=1, NoLs=2, NoEnabled=2, BONUS1=10, BONUS2=2, LSs=(<function MTS_LS1>, <function MTS_LS2>, <function MTS_LS3>), **ukwargs)

Set the algorithm parameters.

Parameters:SR (numpy.ndarray) – Search range.

See also

NiaPy.algorithms.basic.de.DifferentialEvolution.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• NoLsTests (Callable[[int], bool]): TODO
• NoLs (Callable[[int], bool]): TODO
• NoEnabled (Callable[[int], bool]): TODO

Return type:Dict[str, Callable]

See also

NiaPy.algorithms.basic.de.DifferentialEvolution.typeParameters()

class NiaPy.algorithms.modified.DifferentialEvolutionMTSv1(**kwargs)

Bases: NiaPy.algorithms.modified.hde.DifferentialEvolutionMTS

Implementation of Differential Evolution withm MTSv1 local searches.

Algorithm:

Differential Evolution withm MTSv1 local searches

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

NiaPy.algorithms.modified.DifferentialEvolutionMTS

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DifferentialEvolutionMTSv1', 'DEMTSv1']

setParameters(**ukwargs)

Set core parameters of DifferentialEvolutionMTSv1 algorithm.

Parameters:**ukwargs (Dict[str, Any]) – Additional arguments.

See also

NiaPy.algorithms.modified.DifferentialEvolutionMTS.setParameters()

class NiaPy.algorithms.modified.DynNpDifferentialEvolutionMTS(**kwargs)

Bases: NiaPy.algorithms.modified.hde.DifferentialEvolutionMTS, NiaPy.algorithms.basic.de.DynNpDifferentialEvolution

Implementation of Differential Evolution withm MTS local searches dynamic and population size.

Algorithm:

Differential Evolution withm MTS local searches and dynamic population size

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name

See also

• NiaPy.algorithms.modified.DifferentialEvolutionMTS
• NiaPy.algorithms.basic.de.DynNpDifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynNpDifferentialEvolutionMTS', 'dynNpDEMTS']

postSelection(X, task, xb, fxb, **kwargs)

Post selection operator.

Parameters:

• X (numpy.ndarray) – Current populaiton.
• task (Task) – Optimization task.
• xb (numpy.ndarray) – Global best individual.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

New population.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

setParameters(pmax=10, rp=3, **ukwargs)

Set core parameters or DynNpDifferentialEvolutionMTS algorithm.

Parameters:

• pmax (Optional[int]) –
• rp (Optional[float]) –
• **ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.modified.hde.DifferentialEvolutionMTS.setParameters()
• :func`NiaPy.algorithms.basic.de.DynNpDifferentialEvolution.setParameters`

class NiaPy.algorithms.modified.DynNpDifferentialEvolutionMTSv1(**kwargs)

Bases: NiaPy.algorithms.modified.hde.DynNpDifferentialEvolutionMTS

Implementation of Differential Evolution withm MTSv1 local searches and dynamic population size.

Algorithm:

Differential Evolution with MTSv1 local searches and dynamic population size

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

NiaPy.algorithms.modified.hde.DifferentialEvolutionMTS

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynNpDifferentialEvolutionMTSv1', 'dynNpDEMTSv1']

setParameters(**ukwargs)

Set core arguments of DynNpDifferentialEvolutionMTSv1 algorithm.

Parameters:**ukwargs (Dict[str, Any]) – Additional arguments.

See also

NiaPy.algorithms.modified.hde.DifferentialEvolutionMTS.setParameters()

class NiaPy.algorithms.modified.MultiStrategyDifferentialEvolutionMTS(**kwargs)

Bases: NiaPy.algorithms.modified.hde.DifferentialEvolutionMTS, NiaPy.algorithms.basic.de.MultiStrategyDifferentialEvolution

Implementation of Differential Evolution withm MTS local searches and multiple mutation strategys.

Algorithm:

Differential Evolution withm MTS local searches and multiple mutation strategys

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• NiaPy.algorithms.modified.hde.DifferentialEvolutionMTS
• NiaPy.algorithms.basic.de.MultiStrategyDifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MultiStrategyDifferentialEvolutionMTS', 'MSDEMTS']

evolve(pop, xb, task, **kwargs)

Evolve population.

Parameters:

• pop (numpy.ndarray[Individual]) – Current population of individuals.
• xb (Individual) – Global best individual.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

Evolved population.

Return type:

numpy.ndarray[Individual]

setParameters(**ukwargs)

TODO.

Parameters:**ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.modified.DifferentialEvolutionMTS.setParameters()
• NiaPy.algorithms.basic.MultiStrategyDifferentialEvolution.setParameters()

class NiaPy.algorithms.modified.MultiStrategyDifferentialEvolutionMTSv1(**kwargs)

Bases: NiaPy.algorithms.modified.hde.MultiStrategyDifferentialEvolutionMTS

Implementation of Differential Evolution with MTSv1 local searches and multiple mutation strategys.

Algorithm:

Differential Evolution withm MTSv1 local searches and multiple mutation strategys

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of stings representing algorithm name.

See also

• NiaPy.algorithms.modified.MultiStrategyDifferentialEvolutionMTS

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MultiStrategyDifferentialEvolutionMTSv1', 'MSDEMTSv1']

setParameters(**ukwargs)

Set core parameters of MultiStrategyDifferentialEvolutionMTSv1 algorithm.

Parameters:**ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.modified.MultiStrategyDifferentialEvolutionMTS.setParameters()

class NiaPy.algorithms.modified.DynNpMultiStrategyDifferentialEvolutionMTS(**kwargs)

Bases: NiaPy.algorithms.modified.hde.MultiStrategyDifferentialEvolutionMTS, NiaPy.algorithms.modified.hde.DynNpDifferentialEvolutionMTS

Implementation of Differential Evolution withm MTS local searches, multiple mutation strategys and dynamic population size.

Algorithm:

Differential Evolution withm MTS local searches, multiple mutation strategys and dynamic population size

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name

See also

• NiaPy.algorithms.modified.MultiStrategyDifferentialEvolutionMTS
• NiaPy.algorithms.modified.DynNpDifferentialEvolutionMTS

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynNpMultiStrategyDifferentialEvolutionMTS', 'dynNpMSDEMTS']

setParameters(**ukwargs)

Set core arguments of DynNpMultiStrategyDifferentialEvolutionMTS algorithm.

Parameters:**ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.modified.MultiStrategyDifferentialEvolutionMTS.setParameters()
• NiaPy.algorithms.modified.DynNpDifferentialEvolutionMTS.setParameters()

class NiaPy.algorithms.modified.DynNpMultiStrategyDifferentialEvolutionMTSv1(**kwargs)

Bases: NiaPy.algorithms.modified.hde.DynNpMultiStrategyDifferentialEvolutionMTS

Implementation of Differential Evolution withm MTSv1 local searches, multiple mutation strategys and dynamic population size.

Algorithm:

Differential Evolution withm MTSv1 local searches, multiple mutation strategys and dynamic population size

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• NiaPy.algorithm.modified.DynNpMultiStrategyDifferentialEvolutionMTS

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynNpMultiStrategyDifferentialEvolutionMTSv1', 'dynNpMSDEMTSv1']

setParameters(**kwargs)

Set core parameters of DynNpMultiStrategyDifferentialEvolutionMTSv1 algorithm.

Parameters:**kwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithm.modified.DynNpMultiStrategyDifferentialEvolutionMTS.setParameters()

class NiaPy.algorithms.modified.SelfAdaptiveDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution

Implementation of Self-adaptive differential evolution algorithm.

Algorithm:

Self-adaptive differential evolution algorithm

Date:

2018

Author:

Uros Mlakar and Klemen Berkovič

License:

MIT

Reference paper:

Brest, J., Greiner, S., Boskovic, B., Mernik, M., Zumer, V. Self-adapting control parameters in differential evolution: A comparative study on numerical benchmark problems. IEEE transactions on evolutionary computation, 10(6), 646-657, 2006.

Variables:

• Name (List[str]) – List of strings representing algorithm name
• F_l (float) – Scaling factor lower limit.
• F_u (float) – Scaling factor upper limit.
• Tao1 (float) – Change rate for F parameter update.
• Tao2 (float) – Change rate for CR parameter update.

See also

• NiaPy.algorithms.basic.DifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

AdaptiveGen(x)

Adaptive update scale factor in crossover probability.

Parameters:x (Individual) – Individual to apply function on. Returns:New individual with new parameters Return type:Individual

Name = ['SelfAdaptiveDifferentialEvolution', 'jDE']

static algorithmInfo()

Get algorithm information.

Returns:Algorithm information. Return type:str

evolve(pop, xb, task, **ukwargs)

Evolve current population.

Parameters:

• pop (numpy.ndarray[Individual]) – Current population.
• xb (Individual) – Global best individual.
• task (Task) – Optimization task.
• ukwargs (Dict[str, Any]) – Additional arguments.

Returns:

New population.

Return type:

numpy.ndarray

getParameters()

TODO.

Returns:TODO. Return type:Dict[str, Any]

setParameters(F_l=0.0, F_u=1.0, Tao1=0.4, Tao2=0.2, **ukwargs)

Set the parameters of an algorithm.

Parameters:

• F_l (Optional[float]) – Scaling factor lower limit.
• F_u (Optional[float]) – Scaling factor upper limit.
• Tao1 (Optional[float]) – Change rate for F parameter update.
• Tao2 (Optional[float]) – Change rate for CR parameter update.

See also

• NiaPy.algorithms.basic.DifferentialEvolution.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• F_l (Callable[[Union[float, int]], bool])
• F_u (Callable[[Union[float, int]], bool])
• Tao1 (Callable[[Union[float, int]], bool])
• Tao2 (Callable[[Union[float, int]], bool])

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.typeParameters()

class NiaPy.algorithms.modified.DynNpSelfAdaptiveDifferentialEvolutionAlgorithm(**kwargs)

Bases: NiaPy.algorithms.modified.jde.SelfAdaptiveDifferentialEvolution, NiaPy.algorithms.basic.de.DynNpDifferentialEvolution

Implementation of Dynamic population size self-adaptive differential evolution algorithm.

Algorithm:

Dynamic population size self-adaptive differential evolution algorithm

Date:

2018

Author:

Jan Popič and Klemen Berkovič

License:

MIT

Reference URL:

https://link.springer.com/article/10.1007/s10489-007-0091-x

Reference paper:

Brest, Janez, and Mirjam Sepesy Maučec. Population size reduction for the differential evolution algorithm. Applied Intelligence 29.3 (2008): 228-247.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• rp (int) – Small non-negative number which is added to value of generations.
• pmax (int) – Number of population reductions.

See also

• NiaPy.algorithms.modified.SelfAdaptiveDifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynNpSelfAdaptiveDifferentialEvolutionAlgorithm', 'dynNPjDE']

static algorithmInfo()

Get algorithm information.

Returns:Algorithm information. Return type:str

postSelection(pop, task, **kwargs)

Post selection operator.

Parameters:

• pop (numpy.ndarray[Individual]) – Current population.
• task (Task) – Optimization task.

Returns:

New population.

Return type:

numpy.ndarray[Individual]

setParameters(rp=0, pmax=10, **ukwargs)

Set the parameters of an algorithm.

Parameters:

• rp (Optional[int]) – Small non-negative number which is added to value of genp (if it’s not divisible).
• pmax (Optional[int]) – Number of population reductions.

See also

• NiaPy.algorithms.modified.SelfAdaptiveDifferentialEvolution.setParameters()

static typeParameters()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

class NiaPy.algorithms.modified.MultiStrategySelfAdaptiveDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.modified.jde.SelfAdaptiveDifferentialEvolution

Implementation of self-adaptive differential evolution algorithm with multiple mutation strategys.

Algorithm:

Self-adaptive differential evolution algorithm with multiple mutation strategys

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name

See also

• NiaPy.algorithms.modified.SelfAdaptiveDifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MultiStrategySelfAdaptiveDifferentialEvolution', 'MsjDE']

evolve(pop, xb, task, **kwargs)

Evolve population with the help multiple mutation strategies.

Parameters:

• pop (numpy.ndarray[Individual]) – Current population.
• xb (Individual) – Current best individual.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

New population of individuals.

Return type:

numpy.ndarray[Individual]

setParameters(strategies=(<function CrossCurr2Rand1>, <function CrossCurr2Best1>, <function CrossRand1>, <function CrossBest1>, <function CrossBest2>), **kwargs)

Set core parameters of MultiStrategySelfAdaptiveDifferentialEvolution algorithm.

Parameters:

• strategys (Optional[Iterable[Callable]]) – Mutations strategies to use in algorithm.
• **kwargs –

See also

• NiaPy.algorithms.modified.SelfAdaptiveDifferentialEvolution.setParameters()

class NiaPy.algorithms.modified.DynNpMultiStrategySelfAdaptiveDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.modified.jde.MultiStrategySelfAdaptiveDifferentialEvolution, NiaPy.algorithms.modified.jde.DynNpSelfAdaptiveDifferentialEvolutionAlgorithm

Implementation of Dynamic population size self-adaptive differential evolution algorithm with multiple mutation strategies.

Algorithm:

Dynamic population size self-adaptive differential evolution algorithm with multiple mutation strategies

Date:

2018

Author:

Klemen Berkovič

License:

MIT

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• NiaPy.algorithms.modified.MultiStrategySelfAdaptiveDifferentialEvolution
• NiaPy.algorithms.modified.DynNpSelfAdaptiveDifferentialEvolutionAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['DynNpMultiStrategySelfAdaptiveDifferentialEvolution', 'dynNpMsjDE']

postSelection(pop, task, **kwargs)

Apply additional operation after selection.

Parameters:

• pop (numpy.ndarray) – Current population.
• task (Task) – Optimization task.
• xb (numpy.ndarray) – Global best solution.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New global best solution.
3. New global best solutions fitness/objective value.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, float]

setParameters(pmax=10, rp=5, **kwargs)

Set core parameters for algorithm instance.

Parameters:

• pmax (Optional[int]) –
• rp (Optional[int]) –
• **kwargs (Dict[str, Any]) –

See also

• NiaPy.algorithms.modified.MultiStrategySelfAdaptiveDifferentialEvolution.setParameters()

class NiaPy.algorithms.modified.AgingSelfAdaptiveDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.modified.jde.SelfAdaptiveDifferentialEvolution

Implementation of Dynamic population size with aging self-adaptive differential evolution algorithm.

Algorithm:

Dynamic population size with aging self-adaptive self adaptive differential evolution algorithm

Date:

2018

Author:

Jan Popič and Klemen Berkovič

License:

MIT

Reference URL:

https://link.springer.com/article/10.1007/s10489-007-0091-x

Reference paper:

Brest, Janez, and Mirjam Sepesy Maučec. Population size reduction for the differential evolution algorithm. Applied Intelligence 29.3 (2008): 228-247.

Variables:Name (List[str]) – List of strings representing algorithm name.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['AgingSelfAdaptiveDifferentialEvolution', 'ANpjDE']

setParameters(LT_min=1, LT_max=7, age=<function proportional>, **ukwargs)

Set core parameters of AgingSelfAdaptiveDifferentialEvolution algorithm.

Parameters:

• LT_min (Optional[int]) – Minimum age.
• LT_max (Optional[int]) – Maximum age.
• age (Optional[Callable[[], int]]) – Function for calculating age of individual.
• **ukwargs (Dict[str, Any]) – Additional arguments.

See also

• SelfAdaptiveDifferentialEvolution.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• F_l (Callable[[Union[float, int]], bool])
• F_u (Callable[[Union[float, int]], bool])
• Tao1 (Callable[[Union[float, int]], bool])
• Tao2 (Callable[[Union[float, int]], bool])

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.typeParameters()

class NiaPy.algorithms.modified.AdaptiveArchiveDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution

Implementation of Adaptive Differential Evolution With Optional External Archive algorithm.

Algorithm:

Adaptive Differential Evolution With Optional External Archive

Date:

2019

Author:

Klemen Berkovič

License:

MIT

Reference URL:

https://ieeexplore.ieee.org/document/5208221

Reference paper:

Zhang, Jingqiao, and Arthur C. Sanderson. “JADE: adaptive differential evolution with optional external archive.” IEEE Transactions on evolutionary computation 13.5 (2009): 945-958.

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

NiaPy.algorithms.basic.DifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['AdaptiveArchiveDifferentialEvolution', 'JADE']

static algorithmInfo()

Get algorithm information.

Returns:Alogrithm information. Return type:str

See also

NiaPy.algorithms.algorithm.Algorithm.algorithmInfo()

getParameters()

Get parameters values of the algorithm.

Returns:TODO Return type:Dict[str, Any]

See also

• NiaPy.algorithms.Algorithm.getParameters()

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of Differential Evolution algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Current best individual.
• fxb (float) – Current best individual function/fitness value.
• **dparams (dict) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.evolve()
• NiaPy.algorithms.basic.DifferentialEvolution.selection()
• NiaPy.algorithms.basic.DifferentialEvolution.postSelection()

setParameters(**kwargs)

Set the algorithm parameters.

Parameters:

• NP (Optional[int]) – Population size.
• F (Optional[float]) – Scaling factor.
• CR (Optional[float]) – Crossover rate.
• CrossMutt (Optional[Callable[[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, list], numpy.ndarray]]) – Crossover and mutation strategy.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

NiaPy.algorithms.modified.CrossRandCurr2Pbest(pop, ic, x_b, f, cr, p=0.2, arc=None, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, *args)

Mutation strategy with crossover.

Mutation strategy uses two different random individuals from population to perform mutation.

Mutation:

Name: DE/curr2pbest/1

Parameters:

• pop (numpy.ndarray) – Current population.
• ic (int) – Index of current individual.
• x_b (numpy.ndarray) – Global best individual.
• f (float) – Scale factor.
• cr (float) – Crossover probability.
• p (float) – Procentage of best individuals to use.
• arc (numpy.ndarray) – Achived individuals.
• rnd (mtrand.RandomState) – Random generator.
• *args (Dict[str, Any]) – Additional argumets.

Returns:

New position.

Return type:

numpy.ndarray

class NiaPy.algorithms.modified.StrategyAdaptationDifferentialEvolution(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution

Implementation of Differential Evolution Algorithm With Strategy Adaptation algorihtm.

Algorithm:

Differential Evolution Algorithm With StrategyAdaptation

Date:

2019

Author:

Klemen Berkovič

License:

MIT

Reference URL:

https://ieeexplore.ieee.org/document/1554904

Reference paper:

Qin, A. Kai, and Ponnuthurai N. Suganthan. “Self-adaptive differential evolution algorithm for numerical optimization.” 2005 IEEE congress on evolutionary computation. Vol. 2. IEEE, 2005.

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

NiaPy.algorithms.basic.DifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['StrategyAdaptationDifferentialEvolution', 'SADE', 'SaDE']

static algorithmInfo()

Geg basic algorithm information.

Returns:Basic algorithm information. Return type:str

See also

NiaPy.algorithms.algorithm.Algorithm.algorithmInfo()

getParameters()

Get parameters values of the algorithm.

Returns:TODO Return type:Dict[str, Any]

See also

• NiaPy.algorithms.Algorithm.getParameters()

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of Differential Evolution algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Current best individual.
• fxb (float) – Current best individual function/fitness value.
• **dparams (dict) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.evolve()
• NiaPy.algorithms.basic.DifferentialEvolution.selection()
• NiaPy.algorithms.basic.DifferentialEvolution.postSelection()

setParameters(**kwargs)

Set the algorithm parameters.

Parameters:

• NP (Optional[int]) – Population size.
• F (Optional[float]) – Scaling factor.
• CR (Optional[float]) – Crossover rate.
• CrossMutt (Optional[Callable[[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, list], numpy.ndarray]]) – Crossover and mutation strategy.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

class NiaPy.algorithms.modified.StrategyAdaptationDifferentialEvolutionV1(**kwargs)

Bases: NiaPy.algorithms.basic.de.DifferentialEvolution

Implementation of Differential Evolution Algorithm With Strategy Adaptation algorihtm.

Algorithm:

Differential Evolution Algorithm With StrategyAdaptation

Date:

2019

Author:

Klemen Berkovič

License:

MIT

Reference URL:

https://ieeexplore.ieee.org/document/4632146

Reference paper:

Qin, A. Kai, Vicky Ling Huang, and Ponnuthurai N. Suganthan. “Differential evolution algorithm with strategy adaptation for global numerical optimization.” IEEE transactions on Evolutionary Computation 13.2 (2009): 398-417.

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

NiaPy.algorithms.basic.DifferentialEvolution

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['StrategyAdaptationDifferentialEvolutionV1', 'SADEV1', 'SaDEV1']

static algorithmInfo()

Get algorithm information.

Returns:Get algorithm information. Return type:str

See also

NiaPy.algorithms.algorithm.Algorithm.algorithmInfo()

getParameters()

Get parameters values of the algorithm.

Returns:TODO Return type:Dict[str, Any]

See also

• NiaPy.algorithms.Algorithm.getParameters()

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of Differential Evolution algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Current best individual.
• fxb (float) – Current best individual function/fitness value.
• **dparams (dict) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution.
4. New global best solutions fitness/objective value.
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

See also

• NiaPy.algorithms.basic.DifferentialEvolution.evolve()
• NiaPy.algorithms.basic.DifferentialEvolution.selection()
• NiaPy.algorithms.basic.DifferentialEvolution.postSelection()

setParameters(**kwargs)

Set the algorithm parameters.

Parameters:

• NP (Optional[int]) – Population size.
• F (Optional[float]) – Scaling factor.
• CR (Optional[float]) – Crossover rate.
• CrossMutt (Optional[Callable[[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, list], numpy.ndarray]]) – Crossover and mutation strategy.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.Algorithm.setParameters()

class NiaPy.algorithms.modified.AdaptiveBatAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Adaptive bat algorithm.

Algorithm:

Adaptive bat algorithm

Date:

April 2019

Authors:

Klemen Berkovič

License:

MIT

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• epsilon (float) – Scaling factor.
• alpha (float) – Constant for updating loudness.
• r (float) – Pulse rate.
• Qmin (float) – Minimum frequency.
• Qmax (float) – Maximum frequency.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['AdaptiveBatAlgorithm', 'ABA']

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task Returns:

1. New population.
2. New population fitness/function values.

3. Additional arguments:

   • A (float): Loudness.
   • S (numpy.ndarray): TODO
   • Q (numpy.ndarray[float]): TODO
   • v (numpy.ndarray[float]): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

localSearch(best, A, task, **kwargs)

Improve the best solution according to the Yang (2010).

Parameters:

• best (numpy.ndarray) – Global best individual.
• A (float) – Loudness.
• task (Task) – Optimization task.
• **kwargs (Dict[str, Any]) – Additional arguments.

Returns:

New solution based on global best individual.

Return type:

numpy.ndarray

runIteration(task, Sol, Fitness, xb, fxb, A, S, Q, v, **dparams)

Core function of Bat Algorithm.

Parameters:

• task (Task) – Optimization task.
• Sol (numpy.ndarray) – Current population
• Fitness (numpy.ndarray[float]) – Current population fitness/funciton values
• best (numpy.ndarray) – Current best individual
• f_min (float) – Current best individual function/fitness value
• S (numpy.ndarray) – TODO
• Q (numpy.ndarray[float]) – TODO
• v (numpy.ndarray[float]) – TODO
• dparams (Dict[str, Any]) – Additional algorithm arguments

Returns:

1. New population
2. New population fitness/function vlues

3. Additional arguments:

   • A (numpy.ndarray[float]): Loudness.
   • S (numpy.ndarray): TODO
   • Q (numpy.ndarray[float]): TODO
   • v (numpy.ndarray[float]): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

setParameters(NP=40, A=0.5, epsilon=1, alpha=0.77, r=0.5, Qmin=0.0, Qmax=2.0, **ukwargs)

Set the parameters of the algorithm.

Parameters:

• A (Optional[float]) – Starting loudness.
• epsilon (Optional[float]) – Scaling factor.
• alpha (Optional[float]) – Constant for updating loudness.
• r (Optional[float]) – Pulse rate.
• Qmin (Optional[float]) – Minimum frequency.
• Qmax (Optional[float]) – Maximum frequency.

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Return dict with where key of dict represents parameter name and values represent checking functions for selected parameter.

Returns:

• epsilon (Callable[[Union[float, int]], bool]): Scale factor.
• alpha (Callable[[Union[float, int]], bool]): Constant for updating loudness.
• r (Callable[[Union[float, int]], bool]): Pulse rate.
• Qmin (Callable[[Union[float, int]], bool]): Minimum frequency.
• Qmax (Callable[[Union[float, int]], bool]): Maximum frequency.

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

updateLoudness(A)

Update loudness when the prey is found.

Parameters:A (float) – Loudness. Returns:New loudness. Return type:float

class NiaPy.algorithms.modified.SelfAdaptiveBatAlgorithm(**kwargs)

Bases: NiaPy.algorithms.modified.saba.AdaptiveBatAlgorithm

Implementation of Hybrid bat algorithm.

Algorithm:

Hybrid bat algorithm

Date:

April 2019

Author:

Klemen Berkovič

License:

MIT

Reference paper:

Fister Jr., Iztok and Fister, Dusan and Yang, Xin-She. “A Hybrid Bat Algorithm”. Elektrotehniski vestnik, 2013. 1-7.

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• A_l (Optional[float]) – Lower limit of loudness.
• A_u (Optional[float]) – Upper limit of loudness.
• r_l (Optional[float]) – Lower limit of pulse rate.
• r_u (Optional[float]) – Upper limit of pulse rate.
• tao_1 (Optional[float]) – Learning rate for loudness.
• tao_2 (Optional[float]) – Learning rate for pulse rate.

See also

• NiaPy.algorithms.basic.BatAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['SelfAdaptiveBatAlgorithm', 'SABA']

static algorithmInfo()

Get basic information about the algorithm.

Returns:Basic information. Return type:str

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task Returns:

1. New population.
2. New population fitness/function values.

3. Additional arguments:

   • A (float): Loudness.
   • S (numpy.ndarray): TODO
   • Q (numpy.ndarray[float]): TODO
   • v (numpy.ndarray[float]): TODO

Return type:Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

See also

• NiaPy.algorithms.Algorithm.initPopulation()

runIteration(task, Sol, Fitness, xb, fxb, A, r, S, Q, v, **dparams)

Core function of Bat Algorithm.

Parameters:

• task (Task) – Optimization task.
• Sol (numpy.ndarray) – Current population
• Fitness (numpy.ndarray[float]) – Current population fitness/funciton values
• xb (numpy.ndarray) – Current best individual
• fxb (float) – Current best individual function/fitness value
• A (numpy.ndarray[flaot]) – Loudness of individuals.
• r (numpy.ndarray[float[) – Pulse rate of individuals.
• S (numpy.ndarray) – TODO
• Q (numpy.ndarray[float]) – TODO
• v (numpy.ndarray[float]) – TODO
• dparams (Dict[str, Any]) – Additional algorithm arguments

Returns:

1. New population
2. New population fitness/function vlues

3. Additional arguments:

   • A (numpy.ndarray[float]): Loudness.
   • r (numpy.ndarray[float]): Pulse rate.
   • S (numpy.ndarray): TODO
   • Q (numpy.ndarray[float]): TODO
   • v (numpy.ndarray[float]): TODO

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float], Dict[str, Any]]

selfAdaptation(A, r)

Adaptation step.

Parameters:

• A (float) – Current loudness.
• r (float) – Current pulse rate.

Returns:

1. New loudness.
2. Nwq pulse rate.

Return type:

Tuple[float, float]

setParameters(A_l=0.001, A_u=0.1, r_l=0.1, r_u=0.9, tao_1=0.5, tao_2=0.5, **ukwargs)

Set core parameters of HybridBatAlgorithm algorithm.

Parameters:

• A_l (Optional[float]) – Lower limit of loudness.
• A_u (Optional[float]) – Upper limit of loudness.
• r_l (Optional[float]) – Lower limit of pulse rate.
• r_u (Optional[float]) – Upper limit of pulse rate.
• tao_1 (Optional[float]) – Learning rate for loudness.
• tao_2 (Optional[float]) – Learning rate for pulse rate.

See also

• NiaPy.algorithms.basic.BatAlgorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:TODO Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.BatAlgorithm.typeParameters()

class NiaPy.algorithms.modified.HybridSelfAdaptiveBatAlgorithm(**kwargs)

Bases: NiaPy.algorithms.modified.saba.SelfAdaptiveBatAlgorithm

Implementation of Hybrid self adaptive bat algorithm.

Algorithm:

Hybrid self adaptive bat algorithm

Date:

April 2019

Author:

Klemen Berkovič

License:

MIT

Reference paper:

Fister, Iztok, Simon Fong, and Janez Brest. “A novel hybrid self-adaptive bat algorithm.” The Scientific World Journal 2014 (2014).

Reference URL:

https://www.hindawi.com/journals/tswj/2014/709738/cta/

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• F (float) – Scaling factor for local search.
• CR (float) – Probability of crossover for local search.
• CrossMutt (Callable[[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, Dict[str, Any]) – Local search method based of Differential evolution strategy.

See also

• NiaPy.algorithms.basic.BatAlgorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['HybridSelfAdaptiveBatAlgorithm', 'HSABA']

static algorithmInfo()

Get basic information about the algorithm.

Returns:Basic information. Return type:str

localSearch(best, A, i, Sol, task, **kwargs)

Improve the best solution.

Parameters:

• best (numpy.ndarray) – Global best individual.
• task (Task) – Optimization task.
• i (int) – Index of current individual.
• Sol (numpy.ndarray) – Current best population.
• **kwargs (Dict[str, Any]) –

Returns:

New solution based on global best individual.

Return type:

numpy.ndarray

setParameters(F=3, CR=0.5, CrossMutt=<function CrossBest1>, **ukwargs)

Set core parameters of HybridBatAlgorithm algorithm.

Parameters:

• F (Optional[float]) – Scaling factor for local search.
• CR (Optional[float]) – Probability of crossover for local search.
• CrossMutt (Optional[Callable[[numpy.ndarray, int, numpy.ndarray, float, float, mtrand.RandomState, Dict[str, Any], numpy.ndarray]]) – Local search method based of Differential evolution strategy.
• ukwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.basic.BatAlgorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:Additional arguments. Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.basic.BatAlgorithm.typeParameters()

NiaPy.algorithms.other

Implementation of basic nature-inspired algorithms.

class NiaPy.algorithms.other.NelderMeadMethod(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Nelder Mead method or downhill simplex method or amoeba method.

Algorithm:

Nelder Mead Method

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method

Variables:

• Name (List[str]) – list of strings represeing algorithm name
• alpha (float) – Reflection coefficient parameter
• gamma (float) – Expansion coefficient parameter
• rho (float) – Contraction coefficient parameter
• sigma (float) – Shrink coefficient parameter

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['NelderMeadMethod', 'NMM']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get parameters of the algorithm.

Returns:

• Parameter name (str): Represents a parameter name
• Value of parameter (Any): Represents the value of the parameter

Return type:Dict[str, Any]

initPop(task, NP, **kwargs)

Init starting population.

Parameters:

• NP (int) – Number of individuals in population.
• task (Task) – Optimization task.
• rnd (mtrand.RandomState) – Random number generator.
• kwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New initialized population.
2. New initialized population fitness/function values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float]]

method(X, X_f, task)

Run the main function.

Parameters:

• X (numpy.ndarray) – Current population.
• X_f (numpy.ndarray[float]) – Current population function/fitness values.
• task (Task) – Optimization task.

Returns:

1. New population.
2. New population fitness/function values.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float]]

runIteration(task, X, X_f, xb, fxb, **dparams)

Core iteration function of NelderMeadMethod algorithm.

Parameters:

• task (Task) – Optimization task.
• X (numpy.ndarray) – Current population.
• X_f (numpy.ndarray) – Current populations fitness/function values.
• xb (numpy.ndarray) – Global best individual.
• fxb (float) – Global best function/fitness value.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New population.
2. New population fitness/function values.
3. New global best solution
4. New global best solutions fitness/objective value
5. Additional arguments.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(NP=None, alpha=0.1, gamma=0.3, rho=-0.2, sigma=-0.2, **ukwargs)

Set the arguments of an algorithm.

Parameters:

• NP (Optional[int]) – Number of individuals.
• alpha (Optional[float]) – Reflection coefficient parameter
• gamma (Optional[float]) – Expansion coefficient parameter
• rho (Optional[float]) – Contraction coefficient parameter
• sigma (Optional[float]) – Shrink coefficient parameter

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with function for testing correctness of parameters.

Returns:

• alpha (Callable[[Union[int, float]], bool])
• gamma (Callable[[Union[int, float]], bool])
• rho (Callable[[Union[int, float]], bool])
• sigma (Callable[[Union[int, float]], bool])

Return type:Dict[str, Callable]

See Also

• NiaPy.algorithms.Algorithm.typeParameters()

class NiaPy.algorithms.other.HillClimbAlgorithm(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of iterative hill climbing algorithm.

Algorithm:

Hill Climbing Algorithm

Date:

2018

Authors:

Jan Popič

License:

MIT

Reference URL:

Reference paper:

See also

• NiaPy.algorithms.Algorithm

Variables:

• delta (float) – Change for searching in neighborhood.
• Neighborhood (Callable[numpy.ndarray, float, Task], Tuple[numpy.ndarray, float]]) – Function for getting neighbours.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['HillClimbAlgorithm', 'BBFA']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information. Return type:str

getParameters()

Get parameters of the algorithm.

Returns:

• Parameter name (str): Represents a parameter name
• Value of parameter (Any): Represents the value of the parameter

Return type:Dict[str, Any]

initPopulation(task)

Initialize stating point.

Parameters:task (Task) – Optimization task. Returns:

1. New individual.
2. New individual function/fitness value.
3. Additional arguments.

Return type:Tuple[numpy.ndarray, float, Dict[str, Any]]

runIteration(task, x, fx, xb, fxb, **dparams)

Core function of HillClimbAlgorithm algorithm.

Parameters:

• task (Task) – Optimization task.
• x (numpy.ndarray) – Current solution.
• fx (float) – Current solutions fitness/function value.
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solutions function/fitness value.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. New solution.
2. New solutions function/fitness value.
3. Additional arguments.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, Dict[str, Any]]

setParameters(delta=0.5, Neighborhood=<function Neighborhood>, **ukwargs)

Set the algorithm parameters/arguments.

Parameters:

• delta (*) – Change for searching in neighborhood.
• Neighborhood (*) – Function for getting neighbours.

static typeParameters()

TODO.

Returns:

• delta (Callable[[Union[int, float]], bool]): TODO

Return type:Dict[str, Callable]

class NiaPy.algorithms.other.SimulatedAnnealing(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Simulated Annealing Algorithm.

Algorithm:

Simulated Annealing Algorithm

Date:

2018

Authors:

Jan Popič and Klemen Berkovič

License:

MIT

Reference URL:

Reference paper:

Variables:

• Name (List[str]) – List of strings representing algorithm name.
• delta (float) – Movement for neighbour search.
• T (float) –
• deltaT (float) – Change in temperature.
• coolingMethod (Callable) – Neighbourhood function.
• epsilon (float) – Error value.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['SimulatedAnnealing', 'SA']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get algorithms parametes values.

Returns: Return type:Dict[str, Any]

See Also

• NiaPy.algorithms.Algorithm.getParameters()

initPopulation(task)

Initialize the starting population.

Parameters:task (Task) – Optimization task. Returns:

1. Initial solution
2. Initial solutions fitness/objective value
3. Additional arguments

Return type:Tuple[numpy.ndarray, float, dict]

runIteration(task, x, xfit, xb, fxb, curT, **dparams)

Core funciton of the algorithm.

Parameters:

• task (Task) –
• x (numpy.ndarray) –
• xfit (float) –
• xb (numpy.ndarray) –
• fxb (float) –
• curT (float) –
• **dparams (dict) – Additional arguments.

Returns:

1. New solution
2. New solutions fitness/objective value
3. New global best solution
4. New global best solutions fitness/objective value
5. Additional arguments

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, dict]

setParameters(delta=0.5, T=2000, deltaT=0.8, coolingMethod=<function coolDelta>, epsilon=1e-23, **ukwargs)

Set the algorithm parameters/arguments.

Parameters:

• delta (Optional[float]) – Movement for neighbour search.
• T (Optional[float]) –
• deltaT (Optional[float]) – Change in temperature.
• coolingMethod (Optional[Callable]) – Neighbourhood function.
• epsilon (Optional[float]) – Error value.

See Also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• delta (Callable[[Union[float, int], bool]): TODO

Return type:Dict[str, Callable]

class NiaPy.algorithms.other.MultipleTrajectorySearch(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Multiple trajectory search.

Algorithm:

Multiple trajectory search

Date:

2018

Authors:

Klemen Berkovic

License:

MIT

Reference URL:

https://ieeexplore.ieee.org/document/4631210/

Reference paper:

Lin-Yu Tseng and Chun Chen, “Multiple trajectory search for Large Scale Global Optimization,” 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence), Hong Kong, 2008, pp. 3052-3059. doi: 10.1109/CEC.2008.4631210

Variables:

• Name (List[Str]) – List of strings representing algorithm name.
• LSs (Iterable[Callable[[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray, Task, Dict[str, Any]], Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, int, numpy.ndarray]]]) – Local searches to use.
• BONUS1 (int) – Bonus for improving global best solution.
• BONUS2 (int) – Bonus for improving solution.
• NoLsTests (int) – Number of test runs on local search algorithms.
• NoLs (int) – Number of local search algorithm runs.
• NoLsBest (int) – Number of locals search algorithm runs on best solution.
• NoEnabled (int) – Number of best solution for testing.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

GradingRun(x, x_f, xb, fxb, improve, SR, task)

Run local search for getting scores of local searches.

Parameters:

• x (numpy.ndarray) – Solution for grading.
• x_f (float) – Solutions fitness/function value.
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solutions function/fitness value.
• improve (bool) – Info if solution has improved.
• SR (numpy.ndarray) – Search range.
• task (Task) – Optimization task.

Returns:

1. New solution.
2. New solutions function/fitness value.
3. Global best solution.
4. Global best solutions fitness/function value.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float]

LsRun(k, x, x_f, xb, fxb, improve, SR, g, task)

Run a selected local search.

Parameters:

• k (int) – Index of local search.
• x (numpy.ndarray) – Current solution.
• x_f (float) – Current solutions function/fitness value.
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solutions fitness/function value.
• improve (bool) – If the solution has improved.
• SR (numpy.ndarray) – Search range.
• g (int) – Grade.
• task (Task) – Optimization task.

Returns:

1. New best solution found.
2. New best solutions found function/fitness value.
3. Global best solution.
4. Global best solutions function/fitness value.
5. If the solution has improved.
6. Grade of local search run.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray, int]

Name = ['MultipleTrajectorySearch', 'MTS']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

getParameters()

Get parameters values for the algorithm.

Returns: Return type:Dict[str, Any]

initPopulation(task)

Initialize starting population.

Parameters:task (Task) – Optimization task. Returns:

1. Initialized population.
2. Initialized populations function/fitness value.

3. Additional arguments:

   • enable (numpy.ndarray): If solution/individual is enabled.
   • improve (numpy.ndarray): If solution/individual is improved.
   • SR (numpy.ndarray): Search range.
   • grades (numpy.ndarray): Grade of solution/individual.

Return type:Tuple[numpy.ndarray, numpy.ndarray, Dict[str, Any]]

runIteration(task, X, X_f, xb, xb_f, enable, improve, SR, grades, **dparams)

Core function of MultipleTrajectorySearch algorithm.

Parameters:

• task (Task) – Optimization task.
• X (numpy.ndarray) – Current population of individuals.
• X_f (numpy.ndarray) – Current individuals function/fitness values.
• xb (numpy.ndarray) – Global best individual.
• xb_f (float) – Global best individual function/fitness value.
• enable (numpy.ndarray) – Enabled status of individuals.
• improve (numpy.ndarray) – Improved status of individuals.
• SR (numpy.ndarray) – Search ranges of individuals.
• grades (numpy.ndarray) – Grades of individuals.
• **dparams (Dict[str, Any]) – Additional arguments.

Returns:

1. Initialized population.
2. Initialized populations function/fitness value.
3. New global best solution.
4. New global best solutions fitness/objective value.

5. Additional arguments:

   • enable (numpy.ndarray): If solution/individual is enabled.
   • improve (numpy.ndarray): If solution/individual is improved.
   • SR (numpy.ndarray): Search range.
   • grades (numpy.ndarray): Grade of solution/individual.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, Dict[str, Any]]

setParameters(M=40, NoLsTests=5, NoLs=5, NoLsBest=5, NoEnabled=17, BONUS1=10, BONUS2=1, LSs=(<function MTS_LS1>, <function MTS_LS2>, <function MTS_LS3>), **ukwargs)

Set the arguments of the algorithm.

Parameters:

• M (int) – Number of individuals in population.
• NoLsTests (int) – Number of test runs on local search algorithms.
• NoLs (int) – Number of local search algorithm runs.
• NoLsBest (int) – Number of locals search algorithm runs on best solution.
• NoEnabled (int) – Number of best solution for testing.
• BONUS1 (int) – Bonus for improving global best solution.
• BONUS2 (int) – Bonus for improving self.
• LSs (Iterable[Callable[[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray, Task, Dict[str, Any]], Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, int, numpy.ndarray]]]) – Local searches to use.

See also

• NiaPy.algorithms.Algorithm.setParameters()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• M (Callable[[int], bool])
• NoLsTests (Callable[[int], bool])
• NoLs (Callable[[int], bool])
• NoLsBest (Callable[[int], bool])
• NoEnabled (Callable[[int], bool])
• BONUS1 (Callable([[Union[int, float], bool])
• BONUS2 (Callable([[Union[int, float], bool])

Return type:Dict[str, Callable]

class NiaPy.algorithms.other.MultipleTrajectorySearchV1(**kwargs)

Bases: NiaPy.algorithms.other.mts.MultipleTrajectorySearch

Implementation of Multiple trajectory search.

Algorithm:

Multiple trajectory search

Date:

2018

Authors:

Klemen Berkovic

License:

MIT

Reference URL:

https://ieeexplore.ieee.org/document/4983179/

Reference paper:

Tseng, Lin-Yu, and Chun Chen. “Multiple trajectory search for unconstrained/constrained multi-objective optimization.” Evolutionary Computation, 2009. CEC’09. IEEE Congress on. IEEE, 2009.

Variables:Name (List[str]) – List of strings representing algorithm name.

See also

• NiaPy.algorithms.other.MultipleTrajectorySearch`

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['MultipleTrajectorySearchV1', 'MTSv1']

static algorithmInfo()

Get basic information of algorithm.

Returns:Basic information of algorithm. Return type:str

See also

• NiaPy.algorithms.Algorithm.algorithmInfo()

setParameters(**kwargs)

Set core parameters of MultipleTrajectorySearchV1 algorithm.

Parameters:**kwargs (Dict[str, Any]) – Additional arguments.

See also

• NiaPy.algorithms.other.MultipleTrajectorySearch.setParameters()

NiaPy.algorithms.other.MTS_LS1(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, BONUS1=10, BONUS2=1, sr_fix=0.4, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **ukwargs)

Multiple trajectory local search one.

Parameters:

• Xk (numpy.ndarray) – Current solution.
• Xk_fit (float) – Current solutions fitness/function value.
• Xb (numpy.ndarray) – Global best solution.
• Xb_fit (float) – Global best solutions fitness/function value.
• improve (bool) – Has the solution been improved.
• SR (numpy.ndarray) – Search range.
• task (Task) – Optimization task.
• BONUS1 (int) – Bonus reward for improving global best solution.
• BONUS2 (int) – Bonus reward for improving solution.
• sr_fix (numpy.ndarray) – Fix when search range is to small.
• rnd (mtrand.RandomState) – Random number generator.
• **ukwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New solution.
2. New solutions fitness/function value.
3. Global best if found else old global best.
4. Global bests function/fitness value.
5. If solution has improved.
6. Search range.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]

NiaPy.algorithms.other.MTS_LS2(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, BONUS1=10, BONUS2=1, sr_fix=0.4, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **ukwargs)

Multiple trajectory local search two.

Parameters:

• Xk (numpy.ndarray) – Current solution.
• Xk_fit (float) – Current solutions fitness/function value.
• Xb (numpy.ndarray) – Global best solution.
• Xb_fit (float) – Global best solutions fitness/function value.
• improve (bool) – Has the solution been improved.
• SR (numpy.ndarray) – Search range.
• task (Task) – Optimization task.
• BONUS1 (int) – Bonus reward for improving global best solution.
• BONUS2 (int) – Bonus reward for improving solution.
• sr_fix (numpy.ndarray) – Fix when search range is to small.
• rnd (mtrand.RandomState) – Random number generator.
• **ukwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New solution.
2. New solutions fitness/function value.
3. Global best if found else old global best.
4. Global bests function/fitness value.
5. If solution has improved.
6. Search range.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]

See also

• NiaPy.algorithms.other.genNewX()

NiaPy.algorithms.other.MTS_LS3(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, BONUS1=10, BONUS2=1, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **ukwargs)

Multiple trajectory local search three.

Parameters:

• Xk (numpy.ndarray) – Current solution.
• Xk_fit (float) – Current solutions fitness/function value.
• Xb (numpy.ndarray) – Global best solution.
• Xb_fit (float) – Global best solutions fitness/function value.
• improve (bool) – Has the solution been improved.
• SR (numpy.ndarray) – Search range.
• task (Task) – Optimization task.
• BONUS1 (int) – Bonus reward for improving global best solution.
• BONUS2 (int) – Bonus reward for improving solution.
• rnd (mtrand.RandomState) – Random number generator.
• **ukwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New solution.
2. New solutions fitness/function value.
3. Global best if found else old global best.
4. Global bests function/fitness value.
5. If solution has improved.
6. Search range.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]

NiaPy.algorithms.other.MTS_LS1v1(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, BONUS1=10, BONUS2=1, sr_fix=0.4, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **ukwargs)

Multiple trajectory local search one version two.

Parameters:

• Xk (numpy.ndarray) – Current solution.
• Xk_fit (float) – Current solutions fitness/function value.
• Xb (numpy.ndarray) – Global best solution.
• Xb_fit (float) – Global best solutions fitness/function value.
• improve (bool) – Has the solution been improved.
• SR (numpy.ndarray) – Search range.
• task (Task) – Optimization task.
• BONUS1 (int) – Bonus reward for improving global best solution.
• BONUS2 (int) – Bonus reward for improving solution.
• sr_fix (numpy.ndarray) – Fix when search range is to small.
• rnd (mtrand.RandomState) – Random number generator.
• **ukwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New solution.
2. New solutions fitness/function value.
3. Global best if found else old global best.
4. Global bests function/fitness value.
5. If solution has improved.
6. Search range.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]

NiaPy.algorithms.other.MTS_LS3v1(Xk, Xk_fit, Xb, Xb_fit, improve, SR, task, phi=3, BONUS1=10, BONUS2=1, rnd=<module 'numpy.random' from '/home/docs/.pyenv/versions/3.6.12/lib/python3.6/site-packages/numpy/random/__init__.py'>, **ukwargs)

Multiple trajectory local search three version one.

Parameters:

• Xk (numpy.ndarray) – Current solution.
• Xk_fit (float) – Current solutions fitness/function value.
• Xb (numpy.ndarray) – Global best solution.
• Xb_fit (float) – Global best solutions fitness/function value.
• improve (bool) – Has the solution been improved.
• SR (numpy.ndarray) – Search range.
• task (Task) – Optimization task.
• phi (int) – Number of new generated positions.
• BONUS1 (int) – Bonus reward for improving global best solution.
• BONUS2 (int) – Bonus reward for improving solution.
• rnd (mtrand.RandomState) – Random number generator.
• **ukwargs (Dict[str, Any]) – Additional arguments.

Returns:

1. New solution.
2. New solutions fitness/function value.
3. Global best if found else old global best.
4. Global bests function/fitness value.
5. If solution has improved.
6. Search range.

Return type:

Tuple[numpy.ndarray, float, numpy.ndarray, float, bool, numpy.ndarray]

class NiaPy.algorithms.other.AnarchicSocietyOptimization(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Anarchic Society Optimization algorithm.

Algorithm:

Anarchic Society Optimization algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference paper:

Ahmadi-Javid, Amir. “Anarchic Society Optimization: A human-inspired method.” Evolutionary Computation (CEC), 2011 IEEE Congress on. IEEE, 2011.

Variables:

• Name (list of str) – List of stings representing name of algorithm.
• alpha (List[float]) – Factor for fickleness index function \(\in [0, 1]\).
• gamma (List[float]) – Factor for external irregularity index function \(\in [0, \infty)\).
• theta (List[float]) – Factor for internal irregularity index function \(\in [0, \infty)\).
• d (Callable[[float, float], float]) – function that takes two arguments that are function values and calcs the distance between them.
• dn (Callable[[numpy.ndarray, numpy.ndarray], float]) – function that takes two arguments that are points in function landscape and calcs the distance between them.
• nl (float) – Normalized range for neighborhood search \(\in (0, 1]\).
• F (float) – Mutation parameter.
• CR (float) – Crossover parameter \(\in [0, 1]\).
• Combination (Callable[numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray, float, float, float, float, float, float, Task, mtrand.RandomState]) – Function for combining individuals to get new position/individual.

See also

• NiaPy.algorithms.Algorithm

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

EI(x_f, xnb_f, gamma)

Get external irregularity index.

Parameters:

• x_f (float) – Individuals fitness/function value.
• xnb_f (float) – Individuals new fitness/function value.
• gamma (float) – TODO.

Returns:

External irregularity index.

Return type:

float

FI(x_f, xpb_f, xb_f, alpha)

Get fickleness index.

Parameters:

• x_f (float) – Individuals fitness/function value.
• xpb_f (float) – Individuals personal best fitness/function value.
• xb_f (float) – Current best found individuals fitness/function value.
• alpha (float) – TODO.

Returns:

Fickleness index.

Return type:

float

II(x_f, xpb_f, theta)

Get internal irregularity index.

Parameters:

• x_f (float) – Individuals fitness/function value.
• xpb_f (float) – Individuals personal best fitness/function value.
• theta (float) – TODO.

Returns:

Internal irregularity index

Return type:

float

Name = ['AnarchicSocietyOptimization', 'ASO']

getBestNeighbors(i, X, X_f, rs)

Get neighbors of individual.

Mesurment of distance for neighborhud is defined with self.nl. Function for calculating distances is define with self.dn.

Parameters:

• i (int) – Index of individual for hum we are looking for neighbours.
• X (numpy.ndarray) – Current population.
• X_f (numpy.ndarray[float]) – Current population fitness/function values.
• rs (numpy.ndarray[float]) – Distance between individuals.

Returns:

Indexes that represent individuals closest to i-th individual.

Return type:

numpy.ndarray[int]

init(task)

Initialize dynamic parameters of algorithm.

Parameters:task (Task) – Optimization task. Returns:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]

1. Array of self.alpha propagated values
2. Array of self.gamma propagated values
3. Array of self.theta propagated values

initPopulation(task)

Initialize first population and additional arguments.

Parameters:task (Task) – Optimization task Returns:

1. Initialized population
2. Initialized population fitness/function values

3. Dict[str, Any]:

   • Xpb (numpy.ndarray): Initialized populations best positions.
   • Xpb_f (numpy.ndarray): Initialized populations best positions function/fitness values.
   • alpha (numpy.ndarray):
   • gamma (numpy.ndarray):
   • theta (numpy.ndarray):
   • rs (float): Distance of search space.

Return type:Tuple[numpy.ndarray, numpy.ndarray, dict]

See also

• NiaPy.algorithms.algorithm.Algorithm.initPopulation()
• NiaPy.algorithms.other.aso.AnarchicSocietyOptimization.init()

runIteration(task, X, X_f, xb, fxb, Xpb, Xpb_f, alpha, gamma, theta, rs, **dparams)

Core function of AnarchicSocietyOptimization algorithm.

Parameters:

• task (Task) – Optimization task.
• X (numpy.ndarray) – Current populations positions.
• X_f (numpy.ndarray) – Current populations function/fitness values.
• xb (numpy.ndarray) – Current global best individuals position.
• fxb (float) – Current global best individual function/fitness value.
• Xpb (numpy.ndarray) – Current populations best positions.
• Xpb_f (numpy.ndarray) – Current population best positions function/fitness values.
• alpha (numpy.ndarray) – TODO.
• gamma (numpy.ndarray) –
• theta (numpy.ndarray) –
• **dparams – Additional arguments.

Returns:

1. Initialized population
2. Initialized population fitness/function values
3. New global best solution
4. New global best solutions fitness/objective value

5. Dict[str, Union[float, int, numpy.ndarray]:

   • Xpb (numpy.ndarray): Initialized populations best positions.
   • Xpb_f (numpy.ndarray): Initialized populations best positions function/fitness values.
   • alpha (numpy.ndarray):
   • gamma (numpy.ndarray):
   • theta (numpy.ndarray):
   • rs (float): Distance of search space.

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, dict]

setParameters(NP=43, alpha=(1, 0.83), gamma=(1.17, 0.56), theta=(0.932, 0.832), d=<function euclidean>, dn=<function euclidean>, nl=1, F=1.2, CR=0.25, Combination=<function Elitism>, **ukwargs)

Set the parameters for the algorith.

Parameters:

• alpha (Optional[List[float]]) – Factor for fickleness index function \(\in [0, 1]\).
• gamma (Optional[List[float]]) – Factor for external irregularity index function \(\in [0, \infty)\).
• theta (Optional[List[float]]) – Factor for internal irregularity index function \(\in [0, \infty)\).
• d (Optional[Callable[[float, float], float]]) – function that takes two arguments that are function values and calcs the distance between them.
• dn (Optional[Callable[[numpy.ndarray, numpy.ndarray], float]]) – function that takes two arguments that are points in function landscape and calcs the distance between them.
• nl (Optional[float]) – Normalized range for neighborhood search \(\in (0, 1]\).
• F (Optional[float]) – Mutation parameter.
• CR (Optional[float]) – Crossover parameter \(\in [0, 1]\).
• Combination (Optional[Callable[numpy.ndarray, numpy.ndarray, numpy.ndarray, numpy.ndarray, float, float, float, float, float, float, Task, mtrand.RandomState]]) – Function for combining individuals to get new position/individual.

See also

• NiaPy.algorithms.Algorithm.setParameters()

• Combination methods:

  • :func:`NiaPy.algorithms.other.Elitism’
  • NiaPy.algorithms.other.Crossover()
  • NiaPy.algorithms.other.Sequential()

static typeParameters()

Get dictionary with functions for checking values of parameters.

Returns:

• alpha (Callable): TODO
• gamma (Callable): TODO
• theta (Callable): TODO
• nl (Callable): TODO
• F (Callable[[Union[float, int]], bool]): TODO
• CR (Callable[[Union[float, int]], bool]): TODO

Return type:Dict[str, Callable]

See also

• NiaPy.algorithms.Algorithm.typeParameters()

uBestAndPBest(X, X_f, Xpb, Xpb_f)

Update personal best solution of all individuals in population.

Parameters:

• X (numpy.ndarray) – Current population.
• X_f (numpy.ndarray[float]) – Current population fitness/function values.
• Xpb (numpy.ndarray) – Current population best positions.
• Xpb_f (numpy.ndarray[float]) – Current populations best positions fitness/function values.

Returns:

1. New personal best positions for current population.
2. New personal best positions function/fitness values for current population.
3. New best individual.
4. New best individual fitness/function value.

Return type:

Tuple[numpy.ndarray, numpy.ndarray[float], numpy.ndarray, float]

class NiaPy.algorithms.other.TabuSearch(**kwargs)

Bases: NiaPy.algorithms.algorithm.Algorithm

Implementation of Tabu Search Algorithm.

Algorithm:

Tabu Search Algorithm

Date:

2018

Authors:

Klemen Berkovič

License:

MIT

Reference URL:

http://www.cleveralgorithms.com/nature-inspired/stochastic/tabu_search.html

Reference paper:

Variables:Name (List[str]) – List of strings representing algorithm name.

Initialize algorithm and create name for an algorithm.

Parameters:seed (int) – Starting seed for random generator.

See also

• NiaPy.algorithms.Algorithm.setParameters()

Name = ['TabuSearch', 'TS']

move()

runIteration(task, pop, fpop, xb, fxb, **dparams)

Core function of the algorithm.

Parameters:

• task (Task) – Optimization task.
• pop (numpy.ndarray) – Current population.
• fpop (numpy.ndarray) – Individuals fitness/objective values.
• xb (numpy.ndarray) – Global best solution.
• fxb (float) – Global best solutions fitness/objective value.
• **dparams (dict) –

Returns:

Return type:

Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray, float, dict]

setParameters(**ukwargs)

Set the algorithm parameters/arguments.

static typeParameters()

Return functions for checking values of parameters.

Returns:

• NP (Callable[[int], bool]): Check if number of individuals is \(\in [0, \infty]\).

Return type:Dict[str, Callable]