DecisionVariable#

class DecisionVariable#

Decision variable in an optimization problem.

This class represents a variable that will be optimized in a mathematical programming problem. It supports binary, integer, continuous, semi-integer, semi-continuous, and finite-domain variables, and can be used in arithmetic expressions to build objective functions and constraints. Construction requires a Kind and raises ValueError when the requested bound cannot be normalized for the selected variable kind. Use finite_domain() for an explicitly enumerated domain instead of an interval bound.

Note that this object overloads == for creating a constraint, not for equality comparison.

Examples#

>>> x = DecisionVariable.integer(1)
>>> x == 1  # Returns Constraint, not bool
Constraint(...)

For object equality comparison, use the equals_to() method or compare IDs:

>>> y = DecisionVariable.integer(2)
>>> x.id == y.id
False

__add__(rhs: ScalarLike | LinearLike | Parameter) → Linear#
__add__(rhs: Quadratic) → Quadratic
__add__(rhs: Polynomial) → Polynomial
__add__(rhs: Function) → Function

__copy__() → DecisionVariable#

__deepcopy__(_memo: Any) → DecisionVariable#

__eq__(other: builtins.int | builtins.float | numpy.integer | numpy.floating | DecisionVariable | AttachedDecisionVariable | Parameter | Linear | Quadratic | Polynomial | Function) → Constraint#: Create an equality constraint: self == other → Constraint with EqualToZero

__ge__(other: builtins.int | builtins.float | numpy.integer | numpy.floating | DecisionVariable | AttachedDecisionVariable | Parameter | Linear | Quadratic | Polynomial | Function) → Constraint#: Create a greater-than-or-equal constraint: self >= other → Constraint

__le__(other: builtins.int | builtins.float | numpy.integer | numpy.floating | DecisionVariable | AttachedDecisionVariable | Parameter | Linear | Quadratic | Polynomial | Function) → Constraint#: Create a less-than-or-equal constraint: self <= other → Constraint

__mul__(rhs: ScalarLike) → Linear#
__mul__(rhs: LinearLike | Parameter) → Quadratic
__mul__(rhs: Quadratic | Polynomial) → Polynomial
__mul__(rhs: Function) → Function

__neg__() → Linear#: Negation operator: -x → Linear(-1 * x)

__new__(id: int, kind: Kind, bound: Bound, name: Optional[str] = None, subscripts: Sequence[int] = [], parameters: Mapping[str, str] = {}, description: Optional[str] = None) → DecisionVariable#

__radd__(lhs: ScalarLike | LinearLike | Parameter) → Linear#
__radd__(lhs: Quadratic) → Quadratic
__radd__(lhs: Polynomial) → Polynomial
__radd__(lhs: Function) → Function

__repr__() → str#

__rmul__(lhs: ScalarLike) → Linear#
__rmul__(lhs: LinearLike | Parameter) → Quadratic
__rmul__(lhs: Quadratic | Polynomial) → Polynomial
__rmul__(lhs: Function) → Function

__rsub__(lhs: ScalarLike | LinearLike | Parameter) → Linear#
__rsub__(lhs: Quadratic) → Quadratic
__rsub__(lhs: Polynomial) → Polynomial
__rsub__(lhs: Function) → Function

__sub__(rhs: ScalarLike | LinearLike | Parameter) → Linear#
__sub__(rhs: Quadratic) → Quadratic
__sub__(rhs: Polynomial) → Polynomial
__sub__(rhs: Function) → Function

binary(id: int, name: Optional[str] = None, subscripts: Sequence[int] = [], parameters: Mapping[str, str] = {}, description: Optional[str] = None) → DecisionVariable#

continuous(id: int, lower: float = float('-inf'), upper: float = float('inf'), name: Optional[str] = None, subscripts: Sequence[int] = [], parameters: Mapping[str, str] = {}, description: Optional[str] = None) → DecisionVariable#

equals_to(other: DecisionVariable) → bool#

Compare two DecisionVariable objects for equality.

This is different from __eq__ which creates a Constraint. Use this method when you want to check if two variables represent the same variable.

finite_domain(id: int, values: Sequence[float], name: Optional[str] = None, subscripts: Sequence[int] = [], parameters: Mapping[str, str] = {}, description: Optional[str] = None) → DecisionVariable#

Create a decision variable whose feasible values are explicitly enumerated.

>>> from ommx import DecisionVariable, Instance, Kind
>>> dose = DecisionVariable.finite_domain(0, [1.0, 0.1, 0.5, 0.3], name="dose")
>>> assert dose.kind == Kind.FiniteDomain
>>> dose.values
[0.1, 0.3, 0.5, 1.0]
>>> assert (dose.bound.lower, dose.bound.upper) == (0.1, 1.0)

values is the exact feasible set. It must be non-empty and contain unique, finite numbers; OMMX stores the values in ascending order. Values between the minimum and maximum that are not listed remain infeasible. This domain does not approximate a continuous interval.

The bound property and the lower and upper columns in decision_variables_df() are derived from the minimum and maximum of values. They do not independently define the domain. The DataFrame’s values column contains the exact set for finite-domain variables and a missing value for interval-domain kinds.

For incremental construction with automatically assigned IDs, use new_finite_domain():

>>> instance = Instance.minimize()
>>> dose = instance.new_finite_domain([0.1, 0.3, 0.5, 1.0], "dose")
>>> instance.objective = dose
>>> assert instance.evaluate({dose.id: 0.3}).feasible
>>> assert not instance.evaluate({dose.id: 0.4}).feasible

integer(id: int, lower: float = float('-inf'), upper: float = float('inf'), name: Optional[str] = None, subscripts: Sequence[int] = [], parameters: Mapping[str, str] = {}, description: Optional[str] = None) → DecisionVariable#

semi_continuous(id: int, lower: float = float('-inf'), upper: float = float('inf'), name: Optional[str] = None, subscripts: Sequence[int] = [], parameters: Mapping[str, str] = {}, description: Optional[str] = None) → DecisionVariable#

semi_integer(id: int, lower: float = float('-inf'), upper: float = float('inf'), name: Optional[str] = None, subscripts: Sequence[int] = [], parameters: Mapping[str, str] = {}, description: Optional[str] = None) → DecisionVariable#

BINARY: Kind#: Compatibility alias for Kind.Binary.

CONTINUOUS: Kind#: Compatibility alias for Kind.Continuous.

FINITE_DOMAIN: Kind#: Compatibility alias for Kind.FiniteDomain.

INTEGER: Kind#: Compatibility alias for Kind.Integer.

SEMI_CONTINUOUS: Kind#: Compatibility alias for Kind.SemiContinuous.

SEMI_INTEGER: Kind#: Compatibility alias for Kind.SemiInteger.

property bound: Bound#: Read-only property.

property description: str#: Read-only property.

property id: int#: Read-only property.

property kind: Kind#: Read-only property.

property name: str#: Read-only property.

property parameters: dict[str, str]#: Read-only property.

property subscripts: list[int]#: Read-only property.

property values: Optional[list[float]]#

Read-only property.

Explicit feasible values for a finite-domain variable.

Returns None for interval-domain variable kinds.