py4sci

News

10/2013 V1.1.5 is out!

03/2013 PyGMO tries GSoC. Project pages

Get PyGMO: UNIX

First you need to prepare your system to run PyGMO. (and install third-party optional packages)

Then you may get PyGMO

As a last step, compile and install PyGMO

Get PyGMO: win32

Download the autoinstaller

Shortcuts

Algorithms

Problems

Topologies

Report a Bug

Go to our bugtracker

Request for support

Contact our mailinglist

Problems

A Quick Look

Problems in PyGMO are objects, first constructed and then used in conjunction to an algorithm. The user can implement its own problem directly in Python, in which case he needs to inherit from PyGMO.problem.base or PyGMO.problem.base_stochastic class. You may see Adding a new optimization problem or Adding a new stochastic optimization problem

Meta-problems

Common Name Name in PyGMO Comments
Rotated PyGMO.problem.rotated  
Shifted PyGMO.problem.shifted  
Normalized PyGMO.problem.normalized  
Noisy PyGMO.problem.noisy  
Decompose PyGMO.problem.decompose  
Death-penalty PyGMO.problem.death_penalty Minimization assumed.
Constrained to MO PyGMO.problem.con2mo  
Constrained to Unconstrained PyGMO.problem.con2uncon  

Box-Constrained Continuous Single-Objective

Common Name Name in PyGMO Comments
Ackley PyGMO.problem.ackley  
Bukin F6 PyGMO.problem.bukin A difficult bi-dimensional problem
Branin PyGMO.problem.branin Bi-dimensional problem
CEC2013 PyGMO.problem.cec2013 28 problems part of CEC2013 Competition
De Jong PyGMO.problem.dejong  
De Jong PyGMO.problem.py_example Implemented directly in Python
Griewank PyGMO.problem.griewank  
Himmelblau PyGMO.problem.himmelblau Bi-dimensional problem
Lennard-Jones PyGMO.problem.lennard_jones  
Michalewicz PyGMO.problem.michalewicz  
Rosenbrock PyGMO.problem.rosenbrock  
Rastrigin PyGMO.problem.rastrigin  
Schwefel PyGMO.problem.schwefel  
MGA-1DSM (tof encoding) PyGMO.problem.mga_1dsm_tof Requires the GTOP database option active
MGA-1DSM (alpha encoding) PyGMO.problem.mga_1dsm_alpha Requires the GTOP database option active
Cassini 1 PyGMO.problem.cassini_1 Requires the GTOP database option active
Cassini 2 PyGMO.problem.cassini_2 Requires the GTOP database option active
Rosetta PyGMO.problem.rosetta Requires the GTOP database option active
Tandem PyGMO.problem.tandem Requires the GTOP database option active
Laplace PyGMO.problem.tandem Requires the GTOP database option active
Messenger (Full Problem) PyGMO.problem.messenger_full Requires the GTOP database option active
GTOC1 PyGMO.problem.gtoc_1 Requires the GTOP database option active
Sagas PyGMO.problem.sagas Requires the GTOP database option active

Box-Constrained Continuous Multi-Objective

Common Name Name in PyGMO Comments
Kursawe’s study PyGMO.problem.kur  
Fonseca and Fleming’s study PyGMO.problem.fon  
Poloni’s study PyGMO.problem.pol  
Shaffer’s study PyGMO.problem.sch  
ZDT PyGMO.problem.zdt  
DTLZ PyGMO.problem.dtlz  
CEC2009 (UF1-UF10) PyGMO.problem.cec2009 UF problems from CEC2009 Competition.
MGA-1DSM (tof encoding) PyGMO.problem.mga_1dsm_tof Requires the GTOP database option active
MGA-1DSM (alpha encoding) PyGMO.problem.mga_1dsm_alpha Requires the GTOP database option active
Cassini 1 PyGMO.problem.cassini_1 Requires the GTOP database option active

Constrained Continuous Single-Objective

Common Name Name in PyGMO Comments
CEC2006 PyGMO.problem.cec2006 24 problems part of CEC2006 Competition
Pressure vessel design PyGMO.problem.pressure_vessel  
Welded beam design PyGMO.problem.welded_beam  
Tension compression string design PyGMO.problem.tens_comp_string  
Luksan Vlcek 1 PyGMO.problem.luksan_vlcek_1  
Luksan Vlcek 2 PyGMO.problem.luksan_vlcek_2  
Luksan Vlcek 3 PyGMO.problem.luksan_vlcek_3  
Planet to Planet LT Transfer PyGMO.problem.py_pl2pl Requires PyKEP. Implemented in Python
SNOPT Toy-Problem PyGMO.problem.snopt_toyprob  
GTOC2 (Full Problem) PyGMO.problem.gtoc_2 Requires the GTOP database option active

Constrained Continuous Multi-Objective

Common Name Name in PyGMO Comments
CEC2009 (CF1-CF10) PyGMO.problem.cec2009 CF problems from CEC2009 Competition.

Box-Constrained Integer Single-Objective

Common Name Name in PyGMO Comments
String Match PyGMO.problem.string_match  

Constrained Integer Single-Objective

Common Name Name in PyGMO Comments
Golomb Ruler PyGMO.problem.golomb_ruler  
Traveling Salesman PyGMO.problem.tsp  
Knapsack PyGMO.problem.knapsack  

Stochastic Objective Function

Common Name Name in PyGMO Comments
Inventory Problem PyGMO.problem.inventory  
MIT SPHERES PyGMO.problem.mit_spheres  
Noisy De Jong PyGMO.problem.py_example_stochastic  

Detailed Documentation

class PyGMO.problem.base
base.__init__(*args)

Base problem constructor. It must be called from within the derived class constructor __init__()

USAGE: super(derived_class_name,self).__init__(dim, i_dim, n_obj, c_dim, c_ineq_dim, c_tol)

  • dim: Total dimension of the decision vector
  • i_dim: dimension of the integer part of decision vector (the integer part is placed at the end of the decision vector). Defaults to 0
  • n_obj: number of objectives. Defaults to 1
  • c_dim: total dimension of the constraint vector. dDefaults to 0
  • c_ineq_dim: dimension of the inequality part of the constraint vector (inequality const. are placed at the end of the decision vector). Defaults to 0
  • c_tol: constraint tolerance. When comparing individuals, this tolerance is used to decide whether a constraint is considered satisfied.
base.best_x

Best known decision vector(s).

base.best_f

Best known fitness vector(s).

base.best_c

Best known constraints vector(s).

base.dimension

Global dimension.

base.f_dimension

Fitness dimension.

base.i_dimension

Integer dimension.

base.c_dimension

Global constraints dimension.

base.ic_dimension

Inequality constraints dimension.

base.c_tol

Tolerance used in constraints analysis.

_objfun_impl(self, x)

This is a virtual function tham must be re-implemented in the derived class and must return a tuple packing as many numbers as the problem objectives (n_obj)

_compute_constraints_impl(self, x)

This is a virtual function that can be re-implemented in the derived class (if c_dim>0) and must return a tuple packing as many numbers as the declared dimension of the problem constraints (c_dim). Inequality constarints need to be packed at last.

_compare_fitness_impl(self, f1, f2)

This is a virtual function that can be re-implemented in the derived class and must return a boolean value. Return true if f1 Pareto dominate f2, false otherwise. The default implementation will assume minimisation for each one of the f components i.e., each pair of corresponding elements in f1 and f2 is compared: if all elements in f1 are less or equal to the corresponding element in f2 (and at least one is less), true will be returned. Otherwise, false will be returned.

_compare_constraints_impl(self, c1, c2)

This is a virtual function tham can be re-implemented in the derived class (if c_dim>0) and must return a boolean value. Return true if c1 is a strictly better constraint vector than c2, false otherwise. Default implementation will return true under the following conditions, tested in order: c1 satisfies more constraints than c2, c1 and c2 satisfy the same number of constraints and the L2 norm of the constraint mismatches for c1 is smaller than for c2. Otherwise, false will be returned.

_compare_fc_impl(self, f1, c1, f2, c2)

This is a virtual function that can be re-implemented in the derived class (if c_dim>0) and must return a boolean value. By default, the function will perform sanity checks on the input arguments and will then call _compare_constraints_impl() if the constraint dimensions is not null, _compare_fitness_impl() otherwise.

base.reset_caches((_base)arg1) → None :

Resets the internal caching system of PyGMO that stores previos calls to the objective function/ constraint function. This method should be called whenever a problem object is changed and the change affects the objective function.

base.set_bounds((_base)arg1, (float)arg2, (float)arg3) → None :
Set all bounds to the input values.
set_bounds( (_base)arg1, (object)arg2, (object)arg3) -> None :
Set bounds to the input vectors.
base.feasibility_x((_base)arg1, (object)arg2) → bool :

Determine feasibility of decision vector.

base.feasibility_c((_base)arg1, (object)arg2) → bool :

Determine feasibility of constraint vector.


class PyGMO.problem.death_penalty
death_penalty.__init__(problem=None, method=None, penalty_factors=None)

Implements a meta-problem class that wraps some other constrained problems, resulting in death penalty constraints handling. Three implementations of the death penalty are available. The first one is the most common simple death penalty. The second one is the death penalty defined by Angel Kuri Morales et al. (Kuri Morales, A. and Quezada, C.C. A Universal eclectic genetic algorithm for constrained optimization, Proceedings 6th European Congress on Intelligent Techniques & Soft Computing, EUFIT‘98, 518-522, 1998.) Simple death penalty penalizes the fitness function with a high value, Kuri method penalizes the fitness function according to the rate of satisfied constraints. The third one is a weighted static penalization. It penalizes the objective with the sum of the constraints violation, each one penalized with a given factor.

USAGE: problem.death_penalty(problem=PyGMO.cec2006(4), method=death_penalty.method.SIMPLE)

  • problem: PyGMO constrained problem one wants to treat with a death penalty approach
  • method: Simple death method set with SIMPLE, Kuri method set with KURI, weighted static penalization with WEIGHTED

class PyGMO.problem.con2mo
con2mo.__init__(problem=None, method=None)

Implements a meta-problem class that wraps some other constrained problems, resulting in multi-objective problem.

Three implementations of the constrained to multi-objective are available. For a problem with m constraints, m+1 objective functions, the first objective function is the original objective function. The first implementation is the constrained to multi-objective defined by Coello Coello. The objectives defined from constraints includes number of violated constraints and objective functions. The second implementation is the COMOGA multi-objective problem: a biobjective problem with the second objective the sum of the violations of the constraints. The third implementation is the same as the second one but splitting the sum of violations between equality and inequality constraints, resulting in a total of three objectives problem.

USAGE: problem.con2mo(problem=PyGMO.cec2006(4), method=con2mo.method.OBJ_CSTRS)

  • problem: original PyGMO constrained problem

  • method: Coello constraints to multi-objective set with OBJ_CSTRS, COMOGA method

    set with OBJ_CSTRSVIO and COMOGA with splitting of inequality and equality constraints set with OBJ_EQVIO_INEQVIO


class PyGMO.problem.con2uncon
con2uncon.__init__(problem=None, method=None)

Implements a meta-problem class that wraps constrained problems, resulting in an unconstrained problem. Two methods are available for definig the objective function of the meta-problem: OPTIMALITY and FEASIBILITY. The OPTIMALITY uses as objective function the original objective function, it basically removes the constraints from the original problem. The FEASIBILITY uses as objective function the sum of the violation of the constraints, the meta-problem hence optimize just the level of infeasibility.

Implements a meta-problem class that wraps some other constrained problems, resulting in multi-objective problem.

USAGE: problem.con2uncon(problem=PyGMO.cec2006(4), method=con2uncon.method.OPTIMALITY)

  • problem: original PyGMO constrained problem
  • method: OPTIMALITY uses the objective function of the original problem. The FEASIBILITY computes the sum of the constraints violation

class PyGMO.problem.shifted
shifted.__init__(problem=None, shift=None)

Shifts a problem.

NOTE: this meta-problem constructs a new problem where the objective function will be f(x+b),
where b is the shift (bounds are also chaged accordingly)

USAGE: problem.shifted(problem=PyGMO.ackley(1), shift = a random vector)

  • problem: PyGMO problem one wants to shift
  • shift: a value or a list containing the shifts. By default, a radnom shift is created within the problem bounds
shift_vector

The shift vector defining the new problem

deshift((tuple) x)

Returns the de-shifted decision vector


class PyGMO.problem.rotated
rotated.__init__(problem=None, rotation=None)

Rotates a problem. (also reflections are possible) The new objective function will be f(Rx_{normal}), where R is an orthogonal matrix and x_{normal} is the decision vector normailized to [-1,1]

NOTE: To ensure all of the original space is included in the new box-constrained search space, bounds of the normalized variables are expanded to [-sqrt(2),sqrt(2)]. It is still guaranteed theat the original objective function will not be called outside of the original bounds by projecting points outside the original space onto the boundary

USAGE: problem.rotated(problem=PyGMO.ackley(1), rotation = a random orthogonal matrix)

  • problem: PyGMO problem one wants to rotate
  • rotation: a list of lists (matrix). If not specified, a random orthogonal matrix is used.
rotation

The rotation matrix defining the new problem

derotate((tuple) x)

Returns the de-rotated decision vector


class PyGMO.problem.noisy
noisy.__init__(problem=None, trials=1, param_first=0.0, param_second=1.0, noise_type=PyGMO.problem._problem._noise_distribution.NORMAL, seed=0)

Inject noise to a problem. The new objective function will become stochastic, influence by a normally distributed noise.

USAGE: problem.noisy(problem=PyGMO.ackley(1), trials = 1, param_first=0.0, param_second=1.0, noise_type = problem.noisy.noise_distribution.NORMAL, seed=0)

  • problem: PyGMO problem on which one wants to add noises
  • trials: number of trials to average around
  • param_first: Mean of the Gaussian noise / Lower bound of the uniform noise
  • param_second: Standard deviation of the Gaussian noise / Upper bound of the uniform noise
  • noise_type: Whether to inject a normally distributed noise or uniformly distributed noise
  • seed: Seed for the underlying RNG

class PyGMO.problem.normalized
normalized.__init__(problem=None)

Normalizes a problem (e.g. maps all variables to [-1,1])

NOTE: this meta-problem constructs a new problem having normalized bounds/variables

USAGE: problem.normalized(problem=PyGMO.ackley(1))

  • problem: PyGMO problem one wants to normalize
denormalize((tuple) x)

Returns the de-normalized decision vector


class PyGMO.problem.decompose
decompose.__init__(problem=None, method=PyGMO.problem._problem._decomposition_method.WEIGHTED, weights=[], z=[])

Implements a meta-problem class resulting in a decomposed version of the multi-objective input problem, i.e. a single-objective problem having as fitness function some kind of combination of the original fitness functions.

NOTE: this meta-problem constructs a new single-objective problem

USAGE: problem.decompose(problem=PyGMO.zdt(1, 2), method = problem.decompose.WEIGHTED, weights=a random vector (summing to one), z= a zero vector)

  • problem: PyGMO problem one wants to decompose
  • method: the decomposition method to use (WEIGHTED, TCHEBYCHEEF or BI)
  • weights: the weight vector to build the new fitness function
  • z: the reference point (used in TCHEBYCHEEF and BI methods)
weights

The weights vector

WEIGHTED

Weighted decomposition method

TCHEBYCHEFF

Tchebycheff decomposition method

BI

Boundary Intersection decomposition method


class PyGMO.problem.ackley
ackley.__init__(dim=10)

Constructs a Ackley problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.ackley(dim=10)

  • dim: problem dimension

class PyGMO.problem.bukin
bukin.__init__()

Constructs a Bukin’s f6 problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.bukin()


class PyGMO.problem.cec2006
cec2006.__init__(prob_id=1)

Constructs one of the 24 CEC2006 Competition Problems (Constrained Continuous Single-Objective)

USAGE: problem.cec2006(prob_id=1)

  • prob_id: Problem number, one of [1,2,...24]

class PyGMO.problem.pressure_vessel
pressure_vessel.__init__()

Constructs a pressure vessel design problem (Constrained Continuous Single-Objective)

USAGE: problem.pressure_vessel()


class PyGMO.problem.welded_beam
welded_beam.__init__()

Constructs a welded beam design problem (Constrained Continuous Single-Objective)

USAGE: problem.welded_beam()


class PyGMO.problem.tens_comp_string
tens_comp_string.__init__()

Constructs a tension compression string design problem (Constrained Continuous Single-Objective)

USAGE: problem.tens_comp_string()


class PyGMO.problem.cec2009
cec2009.__init__(prob_id=1, dim=30, is_constrained=False)

Constructs one of the 20 CEC2009 Competition Problems (Constrained / Unconstrained Multi-Objective)

USAGE: problem.cec2009(prob_id=1, dim=30, is_constrained=False)

  • prob_id: Problem number, one of [1,2,...10]
  • dim: Problem’s dimension (default is 30, corresponding to the competition set-up)
  • is_constrained: if True constructs the CF problems, otherwise the UF (constrained/unconstrained)

class PyGMO.problem.cec2013
cec2013.__init__(prob_id=1, dim=10, path='input_data/')

Constructs one of the 28 CEC2013 Competition Problems (Box-Constrained Continuous Single-Objective)

NOTE: this problem requires two files to be put in the path indicated: “M_Dxx.txt” and “shift_data.txt”. These files can be downloaded from the CEC2013 competition site: http://web.mysites.ntu.edu.sg/epnsugan/PublicSite/Shared%20Documents/CEC2013/cec13-c-code.zip

USAGE: problem.cec2013(dim = 10, prob_id=1, path=”input_data/”)

  • prob_id: Problem number, one of [1,2,...10]
  • dim: Problem’s dimension (default is 10)
  • path: Whether the problem is constrained or unconstrained

class PyGMO.problem.rosenbrock
rosenbrock.__init__(dim=10)

Constructs a Rosenbrock problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.rosenbrock(dim=10)

  • dim: problem dimension

class PyGMO.problem.string_match
string_match.__init__(string='Can we use it for space?')

Constructs a string-match problem (Box-Constrained Integer Single-Objective)

NOTE: This is the problem of matching a string. Transcribed as an optimization problem

USAGE: problem.string_match(string = “mah”)

  • string: string to match
PyGMO.problem.pretty(x)

Returns a string decoding the chromosome


class PyGMO.problem.rastrigin
rastrigin.__init__(dim=10)

Constructs a Rastrigin problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.rastrigin(dim=10)

  • dim: problem dimension

class PyGMO.problem.schwefel
schwefel.__init__(dim=10)

Constructs a Schwefel problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.schwefel(dim=10)

  • dim: problem dimension

class PyGMO.problem.dejong
dejong.__init__(dim=10)

Constructs a De Jong problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.dejong(dim=10)

  • dim: problem dimension

class PyGMO.problem.py_example
py_example.__init__(dim=10)

class PyGMO.problem.griewank
griewank.__init__(dim=10)

Constructs a De Jong problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.dejong(dim=10)

  • dim: problem dimension

class PyGMO.problem.lennard_jones
lennard_jones.__init__(n_atoms=4)

Constructs a Lennard-Jones problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.lennard_jones(n_atoms=4)

  • n_atoms: number of atoms

class PyGMO.problem.branin
branin.__init__()

Constructs a Branin problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.branin()


class PyGMO.problem.himmelblau
himmelblau.__init__()

Constructs a Himmelblau problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.himmelblau()


class PyGMO.problem.michalewicz
michalewicz.__init__(dim=10)

Constructs a Michalewicz problem (Box-Constrained Continuous Single-Objective)

USAGE: problem.michalewicz(dim=5)

NOTE: Minimum is -4.687 for dim=5 and -9.66 for dim = 10

  • dim: problem dimension

class PyGMO.problem.kur
kur.__init__(dim=10)

Constructs a Kursawe’s study problem (Box-Constrained Continuous Multi-Objective)

NOTE: K Deb, A Pratap, S Agarwal: A fast and elitist multiobjective genetic algorithm: NSGA-II, IEEE Transactions on, 2002

USAGE: problem.kur(dim = 10)

  • dim: problem dimension

class PyGMO.problem.fon
fon.__init__()

Constructs a Fonseca and Fleming’s study problem (Box-Constrained Continuous Multi-Objective)

NOTE: K Deb, A Pratap, S Agarwal: A fast and elitist multiobjective genetic algorithm: NSGA-II, IEEE Transactions on, 2002

USAGE: problem.fon()


class PyGMO.problem.pol
pol.__init__()

Constructs a Poloni’s study study problem (Box-Constrained Continuous Multi-Objective)

NOTE: K Deb, A Pratap, S Agarwal: A fast and elitist multiobjective genetic algorithm: NSGA-II, IEEE Transactions on, 2002

USAGE: problem.pol()


class PyGMO.problem.sch
sch.__init__()

Constructs a Schaffer’s study problem (Box-Constrained Continuous Multi-Objective)

NOTE: K Deb, A Pratap, S Agarwal: A fast and elitist multiobjective genetic algorithm: NSGA-II, IEEE Transactions on, 2002

USAGE: problem.sch()


class PyGMO.problem.zdt
zdt.__init__(prob_id=1, param_1=None)

Constructs a multi-objective box-constrained problem from the ZDT testsuite

NOTE: K Deb, A Pratap, S Agarwal: A fast and elitist multiobjective genetic algorithm: NSGA-II, IEEE Transactions on, 2002

USAGE: problem.zdt(prob_id = 1, param_1 = 30)

  • prob_id: Problem number, one of [1,2,...6]
  • param_1: problem dimension for all ZDT problems except ZDT5 (here it is the number of binary strings used)
zdt.p_distance((zdt)arg1, (object)arg2) → float :

The p distance is a convergence metric measuring the distance of a population or individual from the pareto front. It is typically 0.0 if the individuals lie on the Pareto-front.

USAGE: x = prob.p_distance(pop) USAGE: x = prob.p_distance(x)

  • pop: population to evaluate
  • x: chromosome to evaluate

p_distance( (zdt)arg1, (population)arg2) -> float


class PyGMO.problem.dtlz
dtlz.__init__(prob_id=1, k=None, fdim=3, alpha=100)

Constructs a multi-objective box-constrained problem from the DTLZ testsuite

NOTE: K Deb, L Thiele, M Laumanns, E Zitzler, Scalable test problems for evolutionary multiobjective optimization

USAGE: problem.dtlz(prob_id = 1, k = 20, fdim = 4)

  • prob_id: Problem number, one of [1,2,...7]
  • k: paramter defining integer dimension of the problem: k + fdim - 1
  • fdim: number of objectives
  • alpha: controls density of solutions (just used for prob_id = 4)
dtlz.p_distance((dtlz)arg1, (object)arg2) → float :

The p distance is a convergence metric measuring the distance of a population or individual from the pareto front. It is typically 0.0 if the individuals lie on the Pareto-front.

USAGE: x = prob.p_distance(pop) USAGE: x = prob.p_distance(x)

  • pop: population to evaluate
  • x: chromosome to evaluate

p_distance( (dtlz)arg1, (population)arg2) -> float

dtlz.plot(pop, a=40, comp=[0, 1, 2])

Generic plot-method for multi-objective optimization problems with more then 2 objectives

USAGE: prob.plot(pop, comp[0,2,3]) * pop: population of solutions to the problem * a: angle of view on which the 3d-plot is created * comp: indexes the fitness dimension for x,y and z axis in that order


class PyGMO.problem.tsp
tsp.__init__(matrix=[[0, 1, 2], [1, 0, 5], [2, 5, 0]])

Constructs a Travelling Salesman problem (Constrained Integer Single-Objective)

USAGE: problem.tsp(matrix = [0,1,2],[1,0,5],[2,5,0])

  • matrix: inter-city distances (symmetric matrix)

class PyGMO.problem.golomb_ruler
golomb_ruler.__init__(order=5, length=10)

Constructs a Golomb Ruler problem (Constrained Integer Single-Objective)

NOTE: see http://en.wikipedia.org/wiki/Golomb_ruler

USAGE: problem.golomb_ruler(order = 5, length=10)

  • order: order of the Golomb ruler
  • length: length of the Golomb ruler

class PyGMO.problem.knapsack
knapsack.__init__(values=[1, 2, 3, 4, 5], weights=[10, 40, 30, 50, 20], max_weight=100)

Constructs a 0-1 Knapsack Problem (Constrained Integer Single-Objective)

USAGE: problem.knapsack(values = [1,2,3,4,5], weights = [10, 40, 30, 50, 20], max_weight = 100)

  • values: raw array of values
  • weights: raw array of weights
  • max_weight: maximum weight

class PyGMO.problem.luksan_vlcek_1
luksan_vlcek_1.__init__(dim=3)

Constructs the first Luksan Vlcek problem (Constrained Continuous Single-Objective)

NOTE: L. Luksan and J. Vlcek, “Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization”

USAGE: problem.luksan_vlcek_1(dim=3)

  • dim: problem dimension

class PyGMO.problem.luksan_vlcek_2
luksan_vlcek_2.__init__(dim=16)

Constructs the second Luksan Vlcek problem (Constrained Continuous Single-Objective)

NOTE: L. Luksan and J. Vlcek, “Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization”

USAGE: problem.luksan_vlcek_2(dim=16)

  • dim: problem dimension

class PyGMO.problem.luksan_vlcek_3
luksan_vlcek_3.__init__(dim=8)

Constructs the third Luksan Vlcek problem (Constrained Continuous Single-Objective)

NOTE: L. Luksan and J. Vlcek, “Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization”

USAGE: problem.luksan_vlcek_3(dim=8)

  • dim: problem dimension

class PyGMO.problem.snopt_toyprob
snopt_toyprob.__init__()

Constructs SNOPT toy-problem (Box-Constrained Continuous Multi-Objective)

USAGE: problem.snopt_toyprob()


class PyGMO.problem.inventory
inventory.__init__(weeks=4, sample_size=10, seed=0)

Constructs an Inventory Problem (Stochastic Objective Function)

NOTE: see www2.isye.gatech.edu/people/faculty/Alex_Shapiro/SPbook.pdf

USAGE: problem.inventory(weeks = 4, sample_size = 10, seed = 0):

  • week: dimension of the problem corresponding to the numer of weeks

    to plan the inventory for.

  • sample_size: dimension of the sample used to approximate the expected value

  • seed: integer used as starting random seed to build the

    pseudorandom sequences used to generate the sample


class PyGMO.problem.py_example_stochastic
py_example_stochastic.__init__(dim=10, seed=0)

class PyGMO.problem.mit_spheres
mit_spheres.__init__(sample_size=10, n_hidden=10, ode_prec=0.001, seed=0, symmetric=False, simulation_time=50.0, sides=[0.6, 0.7, 0.8])

Construct a Neurocontroller Evolution problem that seeks to drive three point masses to form a triangle This problem was used to design a contorller for the MIT SPHERES test bed on boear the ISS

USAGE: problem.mit_spheres(sample_size = 10, n_hidden = 10, ode_prec = 1E-3, seed = 0, symmetric = False, simulation_time = 50.0):

  • sample_size: number of initial conditions the neurocontroller is tested from
  • n_hidden: number of hidden for the feed-forward neural network
  • ode_prec: relative numerical precision of neurons the ODE integrator
  • seed: integer used as starting random seed to build the pseudorandom sequences used to generate the sample
  • symmetric: when True activates a Neural Network having symmetric weights (i.e. purely homogeneuos agents)
  • simulation_time: when True activates a Neural Network having symmetric weights (i.e. purely homogeneuos agents)
  • sides: sides of the triangle
post_evaluate((tuple) x, (int) N, (int) seed) → (tuple) out

Returns a tuple with the N post evaluation results of chromosome x w.r.t. conditions generated by seed. The returned tuple has the structure [ic, fit] and is sorted by fit. Where ic are the initial conditions and fit the Evaluated fitness.

simulate((tuple) x, (tuple) ic, (int) N) → (tuple) world_states

Returns the SPHERES coordinates as evaluated in one simulation with initial conditions ic and in N points

visualize((tuple) world_states)

Requires VPython installed. It opens a graphical display and animate the motion of the three SPHERES as desribed by the world_state tuple (output from the simulate method)


class PyGMO.problem.mga_1dsm_tof
__init__(seq, t0, tof, vinf, multi_objective=False, add_vinf_dep=False, add_vinf_arr=True)

Constructs an mga_1dsm problem (tof-encoding)

  • seq: list of PyKEP planets defining the encounter sequence, including the starting planet (default: earth venus earth)
  • t0: list of two epochs defining the launch window (default: 2000-Jan-01 00:00:00 to 2002-Sep-27 00:00:00)
  • tof: list of intervals defining the times of flight in days (default: [[50,900],[50,900]])
  • vinf: list of two floats defining the minimum and maximum allowed initial hyperbolic velocity at launch in km/sec (default: [0.5, 2.5])
  • multi_objective: when True constructs a multiobjective problem (dv, T)
  • add_vinf_dep: when True the computed Dv includes the initial hyperbolic velocity (at launch)
  • add_vinf_arr: when True the computed Dv includes the final hyperbolic velocity (at arrival)

USAGE: problem.mga_1dsm(seq = [planet_ss(‘earth’),planet_ss(‘venus’),planet_ss(‘earth’)], t0 = [epoch(0),epoch(1000)], tof = [ [200, 700], [200, 700] ], vinf = [0.5, 2.5], multi_objective = False, add_vinf_dep = False, add_vinf_arr = True)

mga_1dsm_tof.plot(x)

Plots the trajectory represented by the decision vector x

set_tof(tof)

Resets the tof-bounds by the provided list of epochs. Needs a list consisting of lower/upper bound tuples.

set_launch_window((tuple) t0)

Resets the launch windows to the lower and upper bounds given by tuple t0. Bounds need to be epochs.

set_vinf((double) vinf_u)

Sets the upper bound for vinf to vinf_u

pretty((tuple) x) → (string) out

Returns a string with informations about tour encoded by x


class PyGMO.problem.mga_1dsm_alpha
__init__(seq, t0, tof, vinf, multi_objective=False, add_vinf_dep=False, add_vinf_arr=True)

Constructs an mga_1dsm problem (alpha-encoding)

  • seq: list of PyKEP planets defining the encounter sequence, including the starting planet (default: earth venus earth)
  • t0: list of two epochs defining the launch window (default: 2000-Jan-01 00:00:00 to 2002-Sep-27 00:00:00)
  • tof: list of two floats defining the minimum and maximum allowed mission length in days (default: [365.25, 1826.35])
  • vinf: list of two floats defining the minimum and maximum allowed initial hyperbolic velocity at launch in km/sec (default: [0.5, 2.5])
  • multi_objective: when True constructs a multiobjective problem (dv, T)
  • add_vinf_dep: when True the computed Dv includes the initial hyperbolic velocity (at launch)
  • add_vinf_arr: when True the computed Dv includes the final hyperbolic velocity (at arrival)

USAGE: problem.mga_1dsm(seq = [planet_ss(‘earth’),planet_ss(‘venus’),planet_ss(‘earth’)], t0 = [epoch(0),epoch(1000)], tof = [ [200, 700], [200, 700] ], vinf = [0.5, 2.5], multi_objective = False, add_vinf_dep = False, add_vinf_arr = True)

mga_1dsm_alpha.plot(x)

Plots the trajectory represented by the decision vector x

set_tof((tuple) tof)

Resets the tof-bounds by the provided tuple of epochs.

set_launch_window((tuple) t0)

Resets the launch windows to the lower and upper bounds given by tuple t0. Bounds need to be epochs.

set_vinf((double) vinf_u)

Sets the upper bound for vinf to vinf_u

pretty((tuple) x) → (string) out

Returns a string with informations about tour encoded by x


class PyGMO.problem.cassini_1
cassini_1.__init__(objectives=1)

Constructs a Cassini 1 Problem (Box-Constrained Continuous Single-Objective)

NOTE: This problem (MGA) belongs to the GTOP database [http://www.esa.int/gsp/ACT/inf/op/globopt.htm]
Its single objective version has a global minimum at 4.9307 [km/s], and it is a deceptive problem with a larger minimum at 5.303 [km/s]

USAGE: problem.cassini_1(objectives = 1)

  • objectives: number of objectives. 1=DV, 2=DV,DT

class PyGMO.problem.cassini_2
cassini_2.__init__()

Constructs a Cassini 2 Problem (Box-Constrained Continuous Single-Objective)

NOTE: This problem (MGA-1DSM) belongs to the GTOP database [http://www.esa.int/gsp/ACT/inf/op/globopt.htm]

It models the same interplanetary trajectory as the cassini_1 problem, but in a more accurate fashion, allowing deep space manouvres

Best known global minimum is at 8.383 [km/s]

USAGE: problem.cassini_2()


class PyGMO.problem.messenger_full
messenger_full.__init__()

Constructs a Mesenger Full Problem (Box-Constrained Continuous Single-Objective)

NOTE: This problem (MGA-1DSM) belongs to the GTOP database [http://www.esa.int/gsp/ACT/inf/op/globopt.htm]

Best known global minimum is at 2.113

USAGE: problem.messenger_full()


class PyGMO.problem.rosetta
rosetta.__init__()

Constructs a Rosetta Problem (Box-Constrained Continuous Single-Objective)

NOTE: This problem (MGA-1DSM) belongs to the GTOP database [http://www.esa.int/gsp/ACT/inf/op/globopt.htm]

Best known global minimum is at 1.343 [km/s]

USAGE: problem.rosetta()


class PyGMO.problem.laplace
laplace.__init__(seq=[3, 2, 3, 3, 5])

Constructs a EJSM-Laplace Problem (Box-Constrained Continuous Single-Objective)

NOTE: This problem (MGA-1DSM) is similar to TandEM, but targets Jupiter and the user
can specify explicitly the planetary fly-by sequence

USAGE: problem.laplace(seq = [3,2,3,3,5])

  • seq: The planetary sequence. This is a list of ints that represent the planets to visit

    1 - Mercury, 2 - Venus, 3 - Earth, 4 - Mars, 5 - Jupiter, 6 - Saturn. It must start from 3 (Earth) and end with 5 (Jupiter)


class PyGMO.problem.tandem
tandem.__init__(prob_id=7, max_tof=-1)

Constructs a TandEM Problem (Box-Constrained Continuous Single-Objective)

NOTE: This problem (MGA-1DSM) belongs to the GTOP database [http://www.esa.int/gsp/ACT/inf/op/globopt.htm]. The objective function is -log(m_final).

USAGE: problem.tandem(prob_id = 7, max_tof = -1)

  • prob_id: Selects the problem variant (one of 1..25). All problems differ from the fly-by sequence
  • max_tof = Activates a constriants on the maximum time of flight allowed (in years)

class PyGMO.problem.gtoc_1
gtoc_1.__init__()

Constructs a GTOC 1 Problem (Box-Constrained Continuous Single-Objective)

NOTE: This problem (MGA) belongs to the GTOP database [http://www.esa.int/gsp/ACT/inf/op/globopt.htm]

Best known global minima is at -1,581,950

USAGE: problem.gtoc_1()


class PyGMO.problem.gtoc_2
gtoc_2.__init__((object)arg1[, (gtoc_2)arg2]) → None

__init__( (object)arg1 [, (int)arg2 [, (int)arg3 [, (int)arg4 [, (int)arg5 [, (int)arg6 [, (_gtoc_2_objective)arg7]]]]]]) -> None


class PyGMO.problem.py_pl2pl
py_pl2pl.__init__(mass=1000, Tmax=0.05, Isp=2500, Vinf_0=3, Vinf_f=1e-12, nseg=10, departure=None, target=None, optimise4mass=False)

Constructs a low-thrust transfer between a departure planet and a target planet (Constrained Continuous Single-Objective)

NOTE: An impulsive transcription is used to transform into an NLP the Optimal Control Problem

USAGE: problem.py_pl2pl(self,mass=1000,Tmax=0.05,Isp=2500,Vinf_0=3,Vinf_f=0,nseg=10,departure = PyKEP.planet_ss(‘earth’), target = PyKEP.planet_ss(‘mars’))

  • mass: spacecraft mass at departure [kg]

  • Tmax: maximum allowed thrust [N]

  • Isp: spacecarft engine specific impulse [Isp]

  • Vinf_0: allowed maximum starting velocity [km/s]

  • Vinf_f: allowed maximum arrival velocity [km/s]

    (if negative it is interpreted as a minimum arrival velocity)

  • nseg: number of segments used for the impulsive transcription

  • departure: departure planet (a PyKEP planet)

  • target: arrival planet (a PyKEP planet)


class PyGMO.problem.sagas
sagas.__init__()

Constructs a SAGAS Problem (Box-Constrained Continuous Single-Objective)

NOTE: This problem (MGA-1DSM) belongs to the GTOP database [http://www.esa.int/gsp/ACT/inf/op/globopt.htm]

USAGE: problem.sagas()