decogo.problem.approx_data

This module stores approximation data generated during the solution process.

Classes

`ApproxData`(block_model)	A wrapper class for storing approximation data, i.e. inner points, linearization cuts, valid compact cuts and cells.
`CompactCuts`(block_model)	A class that stores valid compact linear cuts got after solving the subproblems.
`InnerPoints`(block_model)	This class stores inner points and corresponding columns
`LinearizationCuts`(block_model)	This class computes and stores the linearization cuts which are used for OA solver

class decogo.problem.approx_data.ApproxData(block_model)[source]

A wrapper class for storing approximation data, i.e. inner points, linearization cuts, valid compact cuts and cells.

Parameters

block_model (BlockModel) – Block model
inner_points (InnerPoints) – Stores the inner points
linearization_cuts (LinearizationCuts) – Stores linearization cuts (for OA algorithm)
compact_cuts (CompactCuts) – Stores valid compact cuts

__init__(block_model)[source]: Constructor method

add_linearization_cuts(y, eps, x=None, block_id=None)[source]: Adds linearization cuts by calling :meth:LinearizationCuts.add_linearization_cuts

add_inner_point(block_id, point, min_inner_point_distance=None)[source]: Adds inner point by calling InnerPoints.add_point()

get_min_inner_point(block_id, direction)[source]: Gets inner point with respect to the minimum value computed with some direction in original space by calling InnerPoints.get_min_inner_point()

get_min_column(block_id, direction)[source]: Gets column with respect to the minimum value computed with some direction in image space by calling InnerPoints.get_min_column()

get_inner_points_size(block_id)[source]: Gets inner points size by calling InnerPoints.get_size()

add_compact_cut(block_id, lhs, relation, rhs)[source]: Add valid compact cut by calling CompactCuts.add()

get_compact_cuts_size()[source]: Gets compact cut size by calling CompactCuts.get_length()

class decogo.problem.approx_data.InnerPoints(block_model)[source]

This class stores inner points and corresponding columns

Parameters: block_model (BlockModel) – Block model

__init__(block_model)[source]: Constructor method

__getitem__(item)[source]

Index operator

Parameters: item (tuple) – Given index as tuple (block_id, index)
Returns: tuple (point, column), i.e point and corresponding column
Return type: tuple

is_new_point(block_id, column, min_inner_point_distance=None)[source]

Computes minimum distance (based on the infinity norm) of column to all columns in one block

Parameters

block_id (int) – Block identifier
column (ndarray) – Given possibly new column
min_inner_point_distance (float or None) – Threshold for identifying if the column is new

Returns

Result if the column is new

Return type

bool

add_point(block_id, point, min_inner_point_distance=None)[source]

Adds the new point and column. If min_inner_point_distance is None, the column is always added (based on the reduced cost computation)

Parameters

block_id (int) – Block identifier
point (ndarray) – Given new point
min_inner_point_distance (float or None) – Threshold for identifying if the column is new

Returns

Tuple which containes the flag if the column is new, point and corresponding column

Return type

tuple

get_min_inner_point(block_id, dir_orig_space)[source]

Get the inner point based on the minimum value regarding the direction in original space, i.e. \(y = {\mathrm{argmin\ }} d^Tx, x \in S\), where \(S\) is the set of inner points

Parameters

block_id (int) – Block identifier
dir_orig_space (ndarray) – Given direction

Returns

Point and corresponding minimum value

Return type

tuple

get_min_column(block_id, dir_im_space)[source]

Get the column based on the minimum value regarding the direction in image space, i.e. \(y = {\mathrm{argmin\ }} d^Tx, x \in S\), where \(S\) is the set of inner points

Parameters

block_id (int) – Block identifier
dir_im_space (ndarray) – Given direction

Returns

Column and corresponding minimum value

Return type

tuple

get_size(block_id)[source]

Gets the size of inner points of the given block

Parameters: block_id (int) – Block identifier
Returns: Size of the inner points
Return type: int

get_estimated_nadir_point(block_id)[source]

Gets maximum value for each component of the existing columns

Parameters: block_id (int) – Block identifier
Returns: Vector with maximum components
Return type: ndarray

get_estimated_ideal_point(block_id)[source]

Gets minimum value for each component of the existing columns

Parameters: block_id (int) – Block identifier
Returns: Vector with minimum components
Return type: ndarray

check_block(kt)[source]

get_num_blocks()[source]

class decogo.problem.approx_data.LinearizationCuts(block_model)[source]

This class computes and stores the linearization cuts which are used for OA solver

Parameters: block_model (BlockModel) – Block model

__init__(block_model)[source]: Constructor method

add_linearization_cuts(y, eps, x=None, block_id=None)[source]

This method decides for which cases to compute linearization cuts. The cuts are computed with formula \(g(y) + \nabla g(y)^T(x-y) \leq 0\), where \(y\) is a linearization point.

Depending on the input values the cuts are added in the following cases:

if x is None, then the cuts are added to active constraint at point y.
if x is not None, then the cuts are added only for constraint which are violated at point x and are active at point y
if block_id is None, then linearization cuts are added to the all blocks

Parameters

y (BlockVector or ndarray) – Linearization point
eps (float) – Accuracy for checking if the constraint is active
x (BlockVector or ndarray or None) – point of OA solution
block_id (int or None) – Block identifier

Returns

Number of new added cuts

Return type

int

compute_and_add_linearization_cut(block_id, j, y)[source]

Method which computes the linearization cut for nonlinear constraint of the k-th block regarding a reference point y

Parameters

block_id (int) – Block identifier
j (int) – Nonlinear constraint index
y (ndarray) – Reference point

Returns

positive integer, which correspond to the number of added cuts, if all gradient values are ok (and the cut was possible to compute), i.e. no \(\infty\) numbers, 0 - otherwise

Return type

int

num_cuts(block_id)[source]

Get number of cuts

Parameters: block_id (int) – Block identifier
Returns: Number of the cuts
Return type: int

__getitem__(item)[source]

Index operator

Parameters: item (tuple) – Given index
Returns: The cuts associated with the index
Return type: LinearConstraint

class decogo.problem.approx_data.CompactCuts(block_model)[source]

A class that stores valid compact linear cuts got after solving the subproblems. They are defined with \(a^Tw \leq b\), where \(a, w \in \mathbb{R}^{m+1}, m\) is the number of global linear constraints

Parameters: block_model (BlockModel) – Block model

__init__(block_model)[source]: Constructor method

add(block_id, lhs, relation, rhs)[source]

Add new compact linear cut

Parameters

block_id (int) – Block identifier
lhs (ndarray) – Left hand side of the constraint
relation (str) – Relation of the constraint
rhs (float) – Right hand side of the constraint

__getitem__(key)[source]

Index operator

Parameters: key (tuple) – Given index as tuple: (block_id, index)
Returns: Cut associated with index
Return type: tuple

__setitem__(key, value)[source]

Index operator

Parameters

item (tuple) – Given index as tuple: (block_id, index)
value (tuple) – Left hand side, relation, right hand side

Returns

Cut associated with index

Return type

tuple

get_length()[source]

Get number of the cuts for each block

Returns: List of the cuts number blockwise
Return type: list