corneto.backend package

Module contents

class corneto.backend.Backend(default_solver=None, sparse_class=<class 'scipy.sparse._csr.csr_array'>)

Bases: ABC

Parameters:

• default_solver (str | None)

• sparse_class (Callable)

is_available()

Return type:

bool

version()

Return type:

str

static get_symbols(expressions)

Return type:

Set[CSymbol]

Parameters:

expressions (Iterable[CExpression])

abstract available_solvers()

Return type:

List[str]

abstract Constant(value, name=None)

Return type:

CSymbol

Parameters:

• value (Any)

• name (str | None)

abstract Variable(name=None, shape=None, lb=None, ub=None, vartype=VarType.CONTINUOUS)

Create a variable for optimization.

This method defines an optimization variable with optional bounds, type, and additional graph-related properties.

Parameters:

• name (Optional[str]) – The name of the variable. Defaults to None.

• shape (Optional[Tuple[int, ...]]) – The shape of the variable as a tuple. Defaults to None.

• lb (Optional[Union[float, np.ndarray]]) – The lower bound of the variable. Can be a scalar or an array. Defaults to None.

• ub (Optional[Union[float, np.ndarray]]) – The upper bound of the variable. Can be a scalar or an array. Defaults to None.

• vartype (VarType) – The type of the variable (e.g., continuous, integer). Defaults to VarType.CONTINUOUS.

Returns:

The created variable symbol, to be used in further expressions or constraints.

Return type:

CSymbol

abstract Parameter(name=None, shape=None, value=None)

Return type:

CSymbol

Parameters:

• name (str | None)

• shape (Tuple[int, ...] | None)

• value (Any)

Problem(constraints=None, objectives=None, expressions=None, weights=None, direction=Direction.MIN)

Return type:

ProblemDef

Parameters:

• constraints (CExpression | List[CExpression] | None)

• objectives (CExpression | List[CExpression] | None)

• expressions (Dict[str, CExpression] | None)

• weights (float | List[float] | None)

• direction (Direction)

abstract build(p)

Return type:

Any

Parameters:

p (ProblemDef)

solve(p, solver=None, max_seconds=None, warm_start=False, verbosity=0, **options)

Parameters:

• p (ProblemDef)

• solver (str | Solver | None)

• max_seconds (int | None)

• warm_start (bool)

• verbosity (int)

Flow(g, lb=0, ub=10, n_flows=1, values=False, shared_bounds=False, varname='_flow', create_nonzero_indicators=False, alias_flow='flow', alias_flow_ipos='positive_flow', alias_flow_ineg='negative_flow', alias_nonzero_flow='with_flow', indicator_tolerance=0.0001)

Return type:

ProblemDef

Parameters:

• g (BaseGraph)

• lb (float | List | ndarray | None)

• ub (float | List | ndarray | None)

• n_flows (int)

• values (bool)

• shared_bounds (bool)

• varname (str)

• create_nonzero_indicators (bool)

• alias_flow (str)

• alias_flow_ipos (str)

• alias_flow_ineg (str)

• alias_nonzero_flow (str)

• indicator_tolerance (float)

Acyclic(g, P, indicator_positive_var_name=None, indicator_negative_var_name=None, acyclic_var_name='_dag_layer', max_parents=None, vertex_lb_dist=None, vertex_ub_dist=None)

Create Acyclicity Constraint.

This function creates acyclicity constraints, ensuring that the selected edges form an acyclic graph, meaning there are no cycles on the given property. Acyclicity can be applied, for example, over flow constraints or signal properties.

Parameters:

• g (BaseGraph) – The graph that defines the problem.

• P (ProblemDef) – The problem definition.

• indicator_positive_var_name (str) – The name of the indicator variable, i.e., which edges are selected. Default is EXPR_NAME_FLOW_IPOS.

• indicator_negative_var_name (str, optional) – The name of the indicator variable for negative flows. Default is None. If a negative flow appears, the source and target nodes of the edge are reversed. For example, A->B with positive flow implies order(B) > order(A), with negative flow it implies order(A) > order(B).

• acyclic_var_name (str, optional) – The name of the acyclic variable. Default is VAR_DAG.

• max_parents (Optional[Union[int, Dict[Any, int]]], optional) – The maximum number of parents per node. If an integer is provided, the maximum number of parents is the same for all nodes. If a dictionary is provided, the maximum number of parents can be different for each node. Default is None.

• Returns

• -------

• ProblemDef – The problem definition with acyclic constraints.

• Raises

• ------

• NotImplementedError – If hyperedges are used.

• vertex_lb_dist (List[Dict[Any, int]] | None)

• vertex_ub_dist (List[Dict[Any, int]] | None)

Return type:

ProblemDef

AcyclicFlow(g, lb=0, ub=10, values=False, max_parents=None, vertex_lb_dist=None, varname='_flow', alias_flow='flow', alias_flow_ipos='positive_flow', alias_flow_ineg='negative_flow', alias_nonzero_flow='with_flow', indicator_tolerance=0.0001)

Return type:

ProblemDef

Parameters:

• g (BaseGraph)

• lb (float | ndarray)

• ub (float | ndarray)

• values (bool)

• max_parents (int | Dict[Any, int] | None)

• vertex_lb_dist (ndarray | None)

• varname (str)

• alias_flow (str)

• alias_flow_ipos (str)

• alias_flow_ineg (str)

• alias_nonzero_flow (str)

• indicator_tolerance (float)

Indicator(V, indexes=None, suffix='_i', name=None)

Return type:

ProblemDef

Parameters:

• V (CSymbol)

• indexes (Tuple | List | ndarray | None)

• suffix (str)

• name (str | None)

NonZeroIndicator(V, indexes=None, suffix_pos='_ipos', suffix_neg='_ineg', tolerance=0.001)

Return type:

ProblemDef

Parameters:

• V (CSymbol)

• indexes (Tuple | List | ndarray | None)

• suffix_pos (str)

• suffix_neg (str)

• tolerance (float)

Indicators(V, tolerance=0.001, positive=True, negative=True, suffix_pos='_ipos', suffix_neg='_ineg')

Return type:

ProblemDef

Parameters:

V (CSymbol)

Xor(x, y, varname='_xor')

Parameters:

• x (CExpression)

• y (CExpression)

linear_or(x, axis=None, varname='or', ignore_type=False)

Return type:

ProblemDef

Parameters:

• x (CExpression)

• axis (int | None)

linear_and(x, axis=None, varname='and')

Return type:

ProblemDef

Parameters:

• x (CExpression)

• axis (int | None)

linear_xor(x, axis=None, varname='xor', ignore_type=False)

Return type:

ProblemDef

Parameters:

• x (CExpression)

• axis (int | None)

vstack(arg_list)

Return type:

CExpression

Parameters:

arg_list (Iterable[CExpression])

hstack(arg_list)

Return type:

CExpression

Parameters:

arg_list (Iterable[CExpression])

zero_function()

Return type:

CExpression

class corneto.backend.VarType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: str, Enum

INTEGER = 'integer'

CONTINUOUS = 'continuous'

BINARY = 'binary'

class corneto.backend.CvxpyBackend(default_solver=None, sparse_class=<class 'scipy.sparse._csr.csr_array'>)

Bases: Backend

Parameters:

• default_solver (str | None)

• sparse_class (Callable)

available_solvers()

Return type:

List[str]

Constant(value, name=None)

Return type:

CSymbol

Parameters:

• value (Any)

• name (str | None)

Variable(name=None, shape=None, lb=None, ub=None, vartype=VarType.CONTINUOUS)

Create a variable for optimization.

This method defines an optimization variable with optional bounds, type, and additional graph-related properties.

Parameters:

• name (Optional[str]) – The name of the variable. Defaults to None.

• shape (Optional[Tuple[int, ...]]) – The shape of the variable as a tuple. Defaults to None.

• lb (Optional[Union[float, np.ndarray]]) – The lower bound of the variable. Can be a scalar or an array. Defaults to None.

• ub (Optional[Union[float, np.ndarray]]) – The upper bound of the variable. Can be a scalar or an array. Defaults to None.

• vartype (VarType) – The type of the variable (e.g., continuous, integer). Defaults to VarType.CONTINUOUS.

Returns:

The created variable symbol, to be used in further expressions or constraints.

Return type:

CSymbol

Parameter(name=None, shape=None, value=None)

Return type:

CSymbol

Parameters:

• name (str | None)

• shape (Tuple[int, ...] | None)

• value (Any)

build(p)

Return type:

Any

Parameters:

p (ProblemDef)

class corneto.backend.PicosBackend(default_solver=None)

Bases: Backend

Parameters:

default_solver (str | None)

available_solvers()

Return type:

List[str]

build(p)

Return type:

Any

Parameters:

p (ProblemDef)

Constant(value, name=None)

Return type:

CSymbol

Parameters:

• value (Any)

• name (str | None)

Variable(name=None, shape=None, lb=None, ub=None, vartype=VarType.CONTINUOUS, variable=True)

Create a variable for optimization.

This method defines an optimization variable with optional bounds, type, and additional graph-related properties.

Parameters:

• name (Optional[str]) – The name of the variable. Defaults to None.

• shape (Optional[Tuple[int, ...]]) – The shape of the variable as a tuple. Defaults to None.

• lb (Optional[Union[float, np.ndarray]]) – The lower bound of the variable. Can be a scalar or an array. Defaults to None.

• ub (Optional[Union[float, np.ndarray]]) – The upper bound of the variable. Can be a scalar or an array. Defaults to None.

• vartype (VarType) – The type of the variable (e.g., continuous, integer). Defaults to VarType.CONTINUOUS.

• variable (bool)

Returns:

The created variable symbol, to be used in further expressions or constraints.

Return type:

CSymbol

Parameter(name=None, shape=None, value=None)

Return type:

CSymbol

Parameters:

• name (str | None)

• shape (Tuple[int, ...] | None)

• value (Any)