pyoframe 1.0.0a0__py3-none-any.whl → 1.0.1__py3-none-any.whl

pyoframe/_arithmetic.py

@@ -9,18 +9,27 @@ import polars as pl
 from pyoframe._constants import (
     COEF_KEY,
     CONST_TERM,
-    KEY_TYPE,
     QUAD_VAR_KEY,
     RESERVED_COL_KEYS,
     VAR_KEY,
     Config,
+    ExtrasStrategy,
     PyoframeError,
-    UnmatchedStrategy,
 )
 
 if TYPE_CHECKING:  # pragma: no cover
     from pyoframe._core import Expression
 
+# Mapping of how a sum of two expressions should propagate the extras strategy
+_extras_propagation_rules = {
+    (ExtrasStrategy.DROP, ExtrasStrategy.DROP): ExtrasStrategy.DROP,
+    (ExtrasStrategy.UNSET, ExtrasStrategy.UNSET): ExtrasStrategy.UNSET,
+    (ExtrasStrategy.KEEP, ExtrasStrategy.KEEP): ExtrasStrategy.KEEP,
+    (ExtrasStrategy.DROP, ExtrasStrategy.KEEP): ExtrasStrategy.UNSET,
+    (ExtrasStrategy.DROP, ExtrasStrategy.UNSET): ExtrasStrategy.DROP,
+    (ExtrasStrategy.KEEP, ExtrasStrategy.UNSET): ExtrasStrategy.KEEP,
+}
+
 
 def multiply(self: Expression, other: Expression) -> Expression:
     """Multiplies two expressions together.
@@ -160,184 +169,82 @@ def _quadratic_multiplication(self: Expression, other: Expression) -> Expression
 
 def add(*expressions: Expression) -> Expression:
     """Add multiple expressions together."""
-    # Mapping of how a sum of two expressions should propagate the unmatched strategy
-    propagation_strategies = {
-        (UnmatchedStrategy.DROP, UnmatchedStrategy.DROP): UnmatchedStrategy.DROP,
-        (
-            UnmatchedStrategy.UNSET,
-            UnmatchedStrategy.UNSET,
-        ): UnmatchedStrategy.UNSET,
-        (UnmatchedStrategy.KEEP, UnmatchedStrategy.KEEP): UnmatchedStrategy.KEEP,
-        (UnmatchedStrategy.DROP, UnmatchedStrategy.KEEP): UnmatchedStrategy.UNSET,
-        (UnmatchedStrategy.DROP, UnmatchedStrategy.UNSET): UnmatchedStrategy.DROP,
-        (UnmatchedStrategy.KEEP, UnmatchedStrategy.UNSET): UnmatchedStrategy.KEEP,
-    }
-
     assert len(expressions) > 1, "Need at least two expressions to add together."
 
-    dims = expressions[0].dimensions
-
-    if dims is None:
-        requires_join = False
-        dims = []
-    elif Config.disable_unmatched_checks:
-        requires_join = any(
-            expr._unmatched_strategy
-            not in (UnmatchedStrategy.KEEP, UnmatchedStrategy.UNSET)
-            for expr in expressions
-        )
+    if Config.disable_extras_checks:
+        no_checks_strats = (ExtrasStrategy.KEEP, ExtrasStrategy.UNSET)
     else:
-        requires_join = any(
-            expr._unmatched_strategy != UnmatchedStrategy.KEEP for expr in expressions
-        )
+        no_checks_strats = (ExtrasStrategy.KEEP,)
 
-    has_dim_conflict = any(
-        sorted(dims) != sorted(expr._dimensions_unsafe) for expr in expressions[1:]
+    no_extras_checks_required = (
+        all(expr._extras_strategy in no_checks_strats for expr in expressions)
+        # if only one dimensioned, then there is no such thing as extra labels,
+        # labels will be set by the only dimensioned expression
+        or sum(not expr.dimensionless for expr in expressions) <= 1
     )
 
-    # If we cannot use .concat compute the sum in a pairwise manner
-    if len(expressions) > 2 and (has_dim_conflict or requires_join):
-        result = expressions[0]
-        for expr in expressions[1:]:
-            result = add(result, expr)
-        return result
-
-    if has_dim_conflict:
-        assert len(expressions) == 2
-
-        left, right = expressions[0], expressions[1]
-        left_dims, right_dims = left._dimensions_unsafe, right._dimensions_unsafe
-
-        missing_left = [dim for dim in right_dims if dim not in left_dims]
-        missing_right = [dim for dim in left_dims if dim not in right_dims]
-        common_dims = [dim for dim in left_dims if dim in right_dims]
-
-        if not (
-            set(missing_left) <= set(left._allowed_new_dims)
-            and set(missing_right) <= set(right._allowed_new_dims)
-        ):
-            _raise_addition_error(
-                left,
-                right,
-                f"their\n\tdimensions are different ({left_dims} != {right_dims})",
-                "If this is intentional, use .over(…) to broadcast. Learn more at\n\thttps://bravos-power.github.io/pyoframe/learn/concepts/special-functions/#adding-expressions-with-differing-dimensions-using-over",
-            )
-
-        left_old = left
-        if missing_left:
-            left = _broadcast(left, right, common_dims, missing_left)
-        if missing_right:
-            right = _broadcast(
-                right, left_old, common_dims, missing_right, swapped=True
-            )
-
-        assert sorted(left._dimensions_unsafe) == sorted(right._dimensions_unsafe)
-        expressions = (left, right)
-
-    dims = expressions[0]._dimensions_unsafe
-    # Check no dims conflict
-    assert all(
-        sorted(dims) == sorted(expr._dimensions_unsafe) for expr in expressions[1:]
+    has_dim_conflict = any(
+        sorted(expressions[0]._dimensions_unsafe) != sorted(expr._dimensions_unsafe)
+        for expr in expressions[1:]
     )
-    if requires_join:
-        assert len(expressions) == 2
-        assert dims != []
-        left, right = expressions[0], expressions[1]
-
-        # Order so that drop always comes before keep, and keep always comes before default
-        if swap := (
-            (left._unmatched_strategy, right._unmatched_strategy)
-            in (
-                (UnmatchedStrategy.UNSET, UnmatchedStrategy.DROP),
-                (UnmatchedStrategy.UNSET, UnmatchedStrategy.KEEP),
-                (UnmatchedStrategy.KEEP, UnmatchedStrategy.DROP),
-            )
-        ):
-            left, right = right, left
-
-        def get_indices(expr):
-            return expr.data.select(dims).unique(maintain_order=Config.maintain_order)
-
-        left_data, right_data = left.data, right.data
 
-        strat = (left._unmatched_strategy, right._unmatched_strategy)
+    # If we cannot use .concat compute the sum in a pairwise manner, so far nobody uses this code
+    if len(expressions) > 2:  # pragma: no cover
+        assert False, "This code has not been tested."
+        if has_dim_conflict or not no_extras_checks_required:
+            result = expressions[0]
+            for expr in expressions[1:]:
+                result = add(result, expr)
+            return result
+        propagate_strat = expressions[0]._extras_strategy
+        dims = expressions[0]._dimensions_unsafe
+        expr_data = [expr.data for expr in expressions]
+    else:
+        left, right = expressions[0], expressions[1]
 
-        propagate_strat = propagation_strategies[strat]  # type: ignore
+        if has_dim_conflict:
+            left_dims, right_dims = left._dimensions_unsafe, right._dimensions_unsafe
 
-        if strat == (UnmatchedStrategy.DROP, UnmatchedStrategy.DROP):
-            left_data = left.data.join(
-                get_indices(right),
-                on=dims,
-                maintain_order="left" if Config.maintain_order else None,
-            )
-            right_data = right.data.join(
-                get_indices(left),
-                on=dims,
-                maintain_order="left" if Config.maintain_order else None,
-            )
-        elif strat == (UnmatchedStrategy.UNSET, UnmatchedStrategy.UNSET):
-            assert not Config.disable_unmatched_checks, (
-                "This code should not be reached when unmatched checks are disabled."
-            )
-            outer_join = get_indices(left).join(
-                get_indices(right),
-                how="full",
-                on=dims,
-                maintain_order="left_right" if Config.maintain_order else None,
-            )
-            if outer_join.get_column(dims[0]).null_count() > 0:
-                unmatched_vals = outer_join.filter(
-                    outer_join.get_column(dims[0]).is_null()
-                )
-                _raise_unmatched_values_error(left, right, unmatched_vals, swap)
-            if outer_join.get_column(dims[0] + "_right").null_count() > 0:
-                unmatched_vals = outer_join.filter(
-                    outer_join.get_column(dims[0] + "_right").is_null()
-                )
-                _raise_unmatched_values_error(left, right, unmatched_vals, swap)
+            missing_left = [dim for dim in right_dims if dim not in left_dims]
+            missing_right = [dim for dim in left_dims if dim not in right_dims]
+            common_dims = [dim for dim in left_dims if dim in right_dims]
 
-        elif strat == (UnmatchedStrategy.DROP, UnmatchedStrategy.KEEP):
-            left_data = get_indices(right).join(
-                left.data,
-                how="left",
-                on=dims,
-                maintain_order="left" if Config.maintain_order else None,
-            )
-        elif strat == (UnmatchedStrategy.DROP, UnmatchedStrategy.UNSET):
-            left_data = get_indices(right).join(
-                left.data,
-                how="left",
-                on=dims,
-                maintain_order="left" if Config.maintain_order else None,
-            )
-            if left_data.get_column(COEF_KEY).null_count() > 0:
-                _raise_unmatched_values_error(
+            if not (
+                set(missing_left) <= set(left._allowed_new_dims)
+                and set(missing_right) <= set(right._allowed_new_dims)
+            ):
+                _raise_addition_error(
                     left,
                     right,
-                    left_data.filter(left_data.get_column(COEF_KEY).is_null()),
-                    swap,
+                    f"their\n\tdimensions are different ({left_dims} != {right_dims})",
+                    "If this is intentional, use .over(…) to broadcast. Learn more at\n\thttps://bravos-power.github.io/pyoframe/latest/learn/concepts/addition/#adding-expressions-with-differing-dimensions-using-over",
                 )
 
-        elif strat == (UnmatchedStrategy.KEEP, UnmatchedStrategy.UNSET):
-            assert not Config.disable_unmatched_checks, (
-                "This code should not be reached when unmatched checks are disabled."
-            )
-            unmatched = right.data.join(get_indices(left), how="anti", on=dims)
-            if len(unmatched) > 0:
-                _raise_unmatched_values_error(left, right, unmatched, swap)
-        else:  # pragma: no cover
-            assert False, "This code should've never been reached!"
+            left_old = left
+            if missing_left:
+                left = _broadcast(left, right, common_dims, missing_left)
+            if missing_right:
+                right = _broadcast(
+                    right, left_old, common_dims, missing_right, swapped=True
+                )
 
-        expr_data = [left_data, right_data]
-    else:
-        propagate_strat = expressions[0]._unmatched_strategy
-        expr_data = [expr.data for expr in expressions]
+            assert sorted(left._dimensions_unsafe) == sorted(right._dimensions_unsafe)
+
+        dims = left._dimensions_unsafe
+
+        if not no_extras_checks_required:
+            expr_data, propagate_strat = _handle_extra_labels(left, right, dims)
+        else:
+            propagate_strat = left._extras_strategy
+            expr_data = (left.data, right.data)
 
     # Add quadratic column if it is needed and doesn't already exist
     if any(QUAD_VAR_KEY in df.columns for df in expr_data):
         expr_data = [
             (
-                df.with_columns(pl.lit(CONST_TERM).alias(QUAD_VAR_KEY).cast(KEY_TYPE))
+                df.with_columns(
+                    pl.lit(CONST_TERM).alias(QUAD_VAR_KEY).cast(Config.id_dtype)
+                )
                 if QUAD_VAR_KEY not in df.columns
                 else df
             )
@@ -358,23 +265,116 @@ def add(*expressions: Expression) -> Expression:
         full_name += f" - {name[1:]}" if name[0] == "-" else f" + {name}"
 
     new_expr = expressions[0]._new(data, name=f"({full_name})")
-    new_expr._unmatched_strategy = propagate_strat
+    new_expr._extras_strategy = propagate_strat
 
     return new_expr
 
 
-def _raise_unmatched_values_error(
-    left: Expression, right: Expression, unmatched_values: pl.DataFrame, swapped: bool
+def _handle_extra_labels(
+    left: Expression, right: Expression, dims: list[str]
+) -> tuple[tuple[pl.DataFrame, pl.DataFrame], ExtrasStrategy]:
+    assert dims != []
+    # Order so that drop always comes before keep, and keep always comes before default
+    if swapped := (
+        (left._extras_strategy, right._extras_strategy)
+        in (
+            (ExtrasStrategy.UNSET, ExtrasStrategy.DROP),
+            (ExtrasStrategy.UNSET, ExtrasStrategy.KEEP),
+            (ExtrasStrategy.KEEP, ExtrasStrategy.DROP),
+        )
+    ):
+        left, right = right, left
+
+    def get_labels(expr):
+        return expr.data.select(dims).unique(maintain_order=Config.maintain_order)
+
+    left_data, right_data = left.data, right.data
+
+    strat = (left._extras_strategy, right._extras_strategy)
+
+    if strat == (ExtrasStrategy.DROP, ExtrasStrategy.DROP):
+        left_data = left.data.join(
+            get_labels(right),
+            on=dims,
+            maintain_order="left" if Config.maintain_order else None,
+        )
+        right_data = right.data.join(
+            get_labels(left),
+            on=dims,
+            maintain_order="left" if Config.maintain_order else None,
+        )
+    elif strat == (ExtrasStrategy.UNSET, ExtrasStrategy.UNSET):
+        assert not Config.disable_extras_checks, (
+            "This code should not be reached when checks for extra values are disabled."
+        )
+        left_labels, right_labels = get_labels(left), get_labels(right)
+        left_extras = left_labels.join(right_labels, how="anti", on=dims)
+        right_extras = right_labels.join(left_labels, how="anti", on=dims)
+        if len(left_extras) > 0:
+            _raise_extras_error(
+                left, right, left_extras, swapped, extras_on_right=False
+            )
+        if len(right_extras) > 0:
+            _raise_extras_error(left, right, right_extras, swapped)
+
+    elif strat == (ExtrasStrategy.DROP, ExtrasStrategy.KEEP):
+        left_data = get_labels(right).join(
+            left.data,
+            on=dims,
+            maintain_order="left" if Config.maintain_order else None,
+        )
+    elif strat == (ExtrasStrategy.DROP, ExtrasStrategy.UNSET):
+        right_labels = get_labels(right)
+        left_data = right_labels.join(
+            left.data,
+            how="left",
+            on=dims,
+            maintain_order="left" if Config.maintain_order else None,
+        )
+        if left_data.get_column(COEF_KEY).null_count() > 0:
+            _raise_extras_error(
+                left,
+                right,
+                right_labels.join(get_labels(left), how="anti", on=dims),
+                swapped,
+            )
+
+    elif strat == (ExtrasStrategy.KEEP, ExtrasStrategy.UNSET):
+        assert not Config.disable_extras_checks, (
+            "This code should not be reached when checks for extra values are disabled."
+        )
+        extras = right.data.join(get_labels(left), how="anti", on=dims)
+        if len(extras) > 0:
+            _raise_extras_error(left, right, extras.select(dims), swapped)
+    else:  # pragma: no cover
+        assert False, "This code should've never been reached!"
+
+    if swapped:
+        left_data, right_data = right_data, left_data
+
+    return (left_data, right_data), _extras_propagation_rules[strat]
+
+
+def _raise_extras_error(
+    left: Expression,
+    right: Expression,
+    extra_labels: pl.DataFrame,
+    swapped: bool,
+    extras_on_right: bool = True,
 ):
     if swapped:
         left, right = right, left
+        extras_on_right = not extras_on_right
 
-    _raise_addition_error(
-        left,
-        right,
-        "of unmatched values",
-        f"Unmatched values:\n{unmatched_values}\nIf this is intentional, use .drop_unmatched() or .keep_unmatched().",
-    )
+    expression_num = 2 if extras_on_right else 1
+
+    with Config.print_polars_config:
+        _raise_addition_error(
+            left,
+            right,
+            f"expression {expression_num} has extra labels",
+            f"Extra labels in expression {expression_num}:\n{extra_labels}\nUse .drop_extras() or .keep_extras() to indicate how the extra labels should be handled. Learn more at\n\thttps://bravos-power.github.io/pyoframe/latest/learn/concepts/addition",
+        )
 
 
 def _raise_addition_error(
@@ -412,7 +412,7 @@ def _broadcast(
         return res
 
     # If drop, we just do an inner join to get into the shape of the other
-    if self._unmatched_strategy == UnmatchedStrategy.DROP:
+    if self._extras_strategy == ExtrasStrategy.DROP:
         res = self._new(
             self.data.join(
                 target_data,
@@ -430,12 +430,14 @@ def _broadcast(
         how="left",
         maintain_order="left" if Config.maintain_order else None,
     )
-    right_has_missing = result.get_column(missing_dims[0]).null_count() > 0
-    if right_has_missing:
-        _raise_unmatched_values_error(
+    if result.get_column(missing_dims[0]).null_count() > 0:
+        target_labels = target.data.select(target._dimensions_unsafe).unique(
+            maintain_order=Config.maintain_order
+        )
+        _raise_extras_error(
             self,
             target,
-            result.filter(result.get_column(missing_dims[0]).is_null()),
+            target_labels.join(self.data, how="anti", on=common_dims),
             swapped,
         )
     res = self._new(result, self.name)
@@ -522,7 +524,7 @@ def _simplify_expr_df(df: pl.DataFrame) -> pl.DataFrame:
             if df.is_empty():
                 df = pl.DataFrame(
                     {VAR_KEY: [CONST_TERM], COEF_KEY: [0]},
-                    schema={VAR_KEY: KEY_TYPE, COEF_KEY: pl.Float64},
+                    schema={VAR_KEY: Config.id_dtype, COEF_KEY: pl.Float64},
                 )
 
     if QUAD_VAR_KEY in df.columns and (df.get_column(QUAD_VAR_KEY) == CONST_TERM).all():

pyoframe/_constants.py

@@ -17,41 +17,54 @@ CONSTRAINT_KEY = "__constraint_id"
 SOLUTION_KEY = "solution"
 DUAL_KEY = "dual"
 
-# TODO: move as configuration since this could be too small... also add a test to make sure errors occur on overflow.
-KEY_TYPE = pl.UInt32
-
 
 @dataclass
 class _Solver:
     name: SUPPORTED_SOLVER_TYPES
     supports_integer_variables: bool = True
-    supports_quadratics: bool = True
+    supports_quadratic_constraints: bool = True
+    supports_non_convex: bool = True
     supports_duals: bool = True
     supports_objective_sense: bool = True
     supports_write: bool = True
-    block_auto_names: bool = False
+    accelerate_with_repeat_names: bool = False
     """
-    When True, Pyoframe blocks automatic variable and constraint name
-    generation to improve performance by setting all the variable names to 'V'
-    and all the constraint names to 'C'. This should only be True for solvers
-    that support conflicting variable and constraint names. Benchmarking
-    should be performed to verify that this improves performance before turning
-    this on for other solvers.
+    If True, Pyoframe sets all the variable and constraint names to 'V'
+    and 'C', respectively, which, for some solvers, was found to improve
+    performance. This setting should only be enabled for a given solver after
+    testing that a) it actually improves performance, and b) the solver can
+    handle conflicting variable and constraint names.
+    So far, only Gurobi has been tested.
+    Note, that when enabled, Model.write() is not supported
+    (unless solver_uses_variable_names=True) because the outputted files would
+    be meaningless as all variables/constraints would have identical names.
     """
 
+    def __post_init__(self):
+        if self.supports_non_convex:
+            assert self.supports_quadratic_constraints, (
+                "Non-convex solvers typically support quadratic constraints. Are you sure this is correct?"
+            )
+
     def __repr__(self):
         return self.name
 
 
 SUPPORTED_SOLVERS = [
-    _Solver("gurobi", block_auto_names=True),
-    _Solver("highs", supports_quadratics=False, supports_duals=False),
+    _Solver("gurobi", accelerate_with_repeat_names=True),
+    _Solver(
+        "highs",
+        supports_quadratic_constraints=False,
+        supports_non_convex=False,
+        supports_duals=False,
+    ),
     _Solver(
         "ipopt",
         supports_integer_variables=False,
         supports_objective_sense=False,
         supports_write=False,
     ),
+    _Solver("copt", supports_non_convex=False),
 ]
 
 
@@ -71,7 +84,7 @@ RESERVED_COL_KEYS = (
 @dataclass
 class ConfigDefaults:
     default_solver: SUPPORTED_SOLVER_TYPES | _Solver | Literal["raise", "auto"] = "auto"
-    disable_unmatched_checks: bool = False
+    disable_extras_checks: bool = False
     enable_is_duplicated_expression_safety_check: bool = False
     integer_tolerance: float = 1e-8
     float_to_str_precision: int | None = 5
@@ -85,6 +98,7 @@ class ConfigDefaults:
     )
     print_max_terms: int = 5
     maintain_order: bool = True
+    id_dtype = pl.UInt32
 
 
 class _Config:
@@ -114,16 +128,16 @@ class _Config:
         self._settings.default_solver = value
 
     @property
-    def disable_unmatched_checks(self) -> bool:
-        """When `True`, improves performance by skipping unmatched checks (not recommended).
+    def disable_extras_checks(self) -> bool:
+        """When `True`, improves performance by skipping checks for extra values (not recommended).
 
-        When `True`, unmatched checks are disabled which effectively means that all expressions
-        are treated as if they contained [`.keep_unmatched()`][pyoframe.Expression.keep_unmatched]
-        (unless [`.drop_unmatched()`][pyoframe.Expression.drop_unmatched] was applied).
+        When `True`, checks for extra values are disabled which effectively means that all expressions
+        are treated as if they contained [`.keep_extras()`][pyoframe.Expression.keep_extras]
+        (unless [`.drop_extras()`][pyoframe.Expression.drop_extras] was applied).
 
         !!! warning
-            This might improve performance, but it will suppress the "unmatched" errors that alert developers to unexpected
-            behaviors (see [here](../learn/concepts/special-functions.md#drop_unmatched-and-keep_unmatched)).
+            This might improve performance, but it will suppress the errors that alert you of unexpected
+            behaviors ([learn more](../../learn/concepts/addition.md)).
             Only consider enabling after you have thoroughly tested your code.
 
         Examples:
@@ -141,26 +155,24 @@ class _Config:
             ...     }
             ... ).to_expr()
 
-            Normally, an error warns users that the two expressions have conflicting indices:
+            Normally, an error warns users that the two expressions have conflicting labels:
             >>> population + population_influx
             Traceback (most recent call last):
             ...
-            pyoframe._constants.PyoframeError: Cannot add the two expressions below because of unmatched values.
+            pyoframe._constants.PyoframeError: Cannot add the two expressions below because expression 1 has extra labels.
             Expression 1:   pop
             Expression 2:   influx
-            Unmatched values:
-            shape: (1, 2)
-            ┌──────────┬────────────┐
-            │ city     ┆ city_right │
-            │ ---      ┆ ---        │
-            │ str      ┆ str        │
-            ╞══════════╪════════════╡
-            │ Montreal ┆ null       │
-            └──────────┴────────────┘
-            If this is intentional, use .drop_unmatched() or .keep_unmatched().
-
-            But if `Config.disable_unmatched_checks = True`, the error is suppressed and the sum is considered to be `population.keep_unmatched() + population_influx.keep_unmatched()`:
-            >>> pf.Config.disable_unmatched_checks = True
+            Extra labels in expression 1:
+            ┌──────────┐
+            │ city     │
+            ╞══════════╡
+            │ Montreal │
+            └──────────┘
+            Use .drop_extras() or .keep_extras() to indicate how the extra labels should be handled. Learn more at
+                https://bravos-power.github.io/pyoframe/latest/learn/concepts/addition
+
+            But if `Config.disable_extras_checks = True`, the error is suppressed and the sum is considered to be `population.keep_extras() + population_influx.keep_extras()`:
+            >>> pf.Config.disable_extras_checks = True
             >>> population + population_influx
             <Expression height=3 terms=3 type=constant>
             ┌───────────┬────────────┐
@@ -172,11 +184,11 @@ class _Config:
             │ Montreal  ┆ 1704694    │
             └───────────┴────────────┘
         """
-        return self._settings.disable_unmatched_checks
+        return self._settings.disable_extras_checks
 
-    @disable_unmatched_checks.setter
-    def disable_unmatched_checks(self, value: bool):
-        self._settings.disable_unmatched_checks = value
+    @disable_extras_checks.setter
+    def disable_extras_checks(self, value: bool):
+        self._settings.disable_extras_checks = value
 
     @property
     def enable_is_duplicated_expression_safety_check(self) -> bool:
@@ -308,17 +320,52 @@ class _Config:
     def maintain_order(self, value: bool):
         self._settings.maintain_order = value
 
+    @property
+    def id_dtype(self):
+        """The Polars data type to use for variable and constraint IDs.
+
+        Defaults to `pl.UInt32` which should be ideal for most users.
+
+        Users with more than 4 billion variables or constraints can change this to `pl.UInt64`.
+
+        Users concerned with memory usage and with fewer than 65k variables or constraints can change this to `pl.UInt16`.
+
+        !!! warning
+            Changing this setting after creating a model will lead to errors.
+            You should only change this setting before creating any models.
+
+        Examples:
+            An error is automatically raised if the number of variables or constraints exceeds the chosen data type:
+            >>> pf.Config.id_dtype = pl.UInt8
+            >>> m = pf.Model()
+            >>> big_set = pf.Set(x=range(2**8 + 1))
+            >>> m.X = pf.Variable()
+            >>> m.constraint = m.X.over("x") <= big_set
+            Traceback (most recent call last):
+            ...
+            TypeError: Number of constraints exceeds the current data type (UInt8). Consider increasing the data type by changing Config.id_dtype.
+            >>> m.X_large = pf.Variable(big_set)
+            Traceback (most recent call last):
+            ...
+            TypeError: Number of variables exceeds the current data type (UInt8). Consider increasing the data type by changing Config.id_dtype.
+        """
+        return self._settings.id_dtype
+
+    @id_dtype.setter
+    def id_dtype(self, value):
+        self._settings.id_dtype = value
+
     def reset_defaults(self):
         """Resets all configuration options to their default values.
 
         Examples:
-            >>> pf.Config.disable_unmatched_checks
+            >>> pf.Config.disable_extras_checks
             False
-            >>> pf.Config.disable_unmatched_checks = True
-            >>> pf.Config.disable_unmatched_checks
+            >>> pf.Config.disable_extras_checks = True
+            >>> pf.Config.disable_extras_checks
             True
             >>> pf.Config.reset_defaults()
-            >>> pf.Config.disable_unmatched_checks
+            >>> pf.Config.disable_extras_checks
             False
         """
         self._settings = ConfigDefaults()
@@ -389,8 +436,8 @@ class VType(Enum):
             raise ValueError(f"Invalid variable type: {self}")  # pragma: no cover
 
 
-class UnmatchedStrategy(Enum):
-    """An enum to specify how to handle unmatched values in expressions."""
+class ExtrasStrategy(Enum):
+    """An enum to specify how to handle extra values in expressions."""
 
     UNSET = "not_set"
     DROP = "drop"
@@ -404,7 +451,7 @@ VTypeValue = Literal["continuous", "binary", "integer"]
 for enum, type in [(ObjSense, ObjSenseValue), (VType, VTypeValue)]:
     assert set(typing.get_args(type)) == {vtype.value for vtype in enum}
 
-SUPPORTED_SOLVER_TYPES = Literal["gurobi", "highs", "ipopt"]
+SUPPORTED_SOLVER_TYPES = Literal["gurobi", "highs", "ipopt", "copt"]
 assert set(typing.get_args(SUPPORTED_SOLVER_TYPES)) == {
     s.name for s in SUPPORTED_SOLVERS
 }