pyoframe 0.0.11__py3-none-any.whl → 0.1.0__py3-none-any.whl

pyoframe/core.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import warnings
 from abc import ABC, abstractmethod
 from typing import (
     TYPE_CHECKING,
+    Any,
+    Dict,
     Iterable,
     List,
     Mapping,
@@ -13,20 +16,25 @@ from typing import (
     overload,
 )
 
+import numpy as np
 import pandas as pd
 import polars as pl
-from packaging import version
+import pyoptinterface as poi
 
-from pyoframe._arithmetic import _add_expressions, _get_dimensions
+from pyoframe._arithmetic import (
+    _add_expressions,
+    _get_dimensions,
+    _multiply_expressions,
+)
 from pyoframe.constants import (
     COEF_KEY,
     CONST_TERM,
     CONSTRAINT_KEY,
     DUAL_KEY,
+    KEY_TYPE,
     POLARS_VERSION,
-    RC_COL,
+    QUAD_VAR_KEY,
     RESERVED_COL_KEYS,
-    SLACK_COL,
     SOLUTION_KEY,
     VAR_KEY,
     Config,
@@ -43,6 +51,7 @@ from pyoframe.model_element import (
     SupportPolarsMethodMixin,
 )
 from pyoframe.util import (
+    Container,
     FuncArgs,
     cast_coef_to_string,
     concat_dimensions,
@@ -55,8 +64,6 @@ from pyoframe.util import (
 if TYPE_CHECKING:  # pragma: no cover
     from pyoframe.model import Model
 
-VAR_TYPE = pl.UInt32
-
 
 def _forward_to_expression(func_name: str):
     def wrapper(self: "SupportsMath", *args, **kwargs) -> "Expression":
@@ -98,6 +105,25 @@ class SupportsMath(ABC, SupportsToExpr):
     sum = _forward_to_expression("sum")
     map = _forward_to_expression("map")
 
+    def __pow__(self, power: int):
+        """
+        Support squaring expressions:
+        >>> m = pf.Model()
+        >>> m.v = pf.Variable()
+        >>> m.v ** 2
+        <Expression size=1 dimensions={} terms=1 degree=2>
+        v * v
+        >>> m.v ** 3
+        Traceback (most recent call last):
+        ...
+        ValueError: Raising an expressions to **3 is not supported. Expressions can only be squared (**2).
+        """
+        if power == 2:
+            return self * self
+        raise ValueError(
+            f"Raising an expressions to **{power} is not supported. Expressions can only be squared (**2)."
+        )
+
     def __neg__(self):
         res = self.to_expr() * -1
         # Negating a constant term should keep the unmatched strategy
@@ -107,14 +133,14 @@ class SupportsMath(ABC, SupportsToExpr):
     def __sub__(self, other):
         """
         >>> import polars as pl
-        >>> from pyoframe import Variable
+        >>> m = pf.Model()
         >>> df = pl.DataFrame({"dim1": [1,2,3], "value": [1,2,3]})
-        >>> var = Variable(df["dim1"])
-        >>> var - df
+        >>> m.v = pf.Variable(df["dim1"])
+        >>> m.v - df
         <Expression size=3 dimensions={'dim1': 3} terms=6>
-        [1]: x1 -1
-        [2]: x2 -2
-        [3]: x3 -3
+        [1]: v[1] -1
+        [2]: v[2] -2
+        [3]: v[3] -3
         """
         if not isinstance(other, (int, float)):
             other = other.to_expr()
@@ -126,33 +152,69 @@ class SupportsMath(ABC, SupportsToExpr):
     def __radd__(self, other):
         return self.to_expr() + other
 
+    def __truediv__(self, other):
+        """
+
+        Examples:
+            Support division.
+            >>> m = pf.Model()
+            >>> m.v = Variable({"dim1": [1,2,3]})
+            >>> m.v / 2
+            <Expression size=3 dimensions={'dim1': 3} terms=3>
+            [1]: 0.5 v[1]
+            [2]: 0.5 v[2]
+            [3]: 0.5 v[3]
+        """
+        return self.to_expr() * (1 / other)
+
+    def __rsub__(self, other):
+        """
+        Support right subtraction.
+
+        Examples:
+            >>> m = pf.Model()
+            >>> m.v = Variable({"dim1": [1,2,3]})
+            >>> 1 - m.v
+            <Expression size=3 dimensions={'dim1': 3} terms=6>
+            [1]: 1  - v[1]
+            [2]: 1  - v[2]
+            [3]: 1  - v[3]
+        """
+        return other + (-self.to_expr())
+
     def __le__(self, other):
         """Equality constraint.
-        Examples
-        >>> from pyoframe import Variable
-        >>> Variable() <= 1
-        <Constraint sense='<=' size=1 dimensions={} terms=2>
-        x1 <= 1
+
+        Examples:
+            >>> m = pf.Model()
+            >>> m.v = pf.Variable()
+            >>> m.v <= 1
+            <Constraint sense='<=' size=1 dimensions={} terms=2>
+            v <= 1
         """
         return Constraint(self - other, ConstraintSense.LE)
 
     def __ge__(self, other):
         """Equality constraint.
-        Examples
-        >>> from pyoframe import Variable
-        >>> Variable() >= 1
-        <Constraint sense='>=' size=1 dimensions={} terms=2>
-        x1 >= 1
+
+        Examples:
+            >>> m = pf.Model()
+            >>> m.v = pf.Variable()
+            >>> m.v >= 1
+            <Constraint sense='>=' size=1 dimensions={} terms=2>
+            v >= 1
         """
         return Constraint(self - other, ConstraintSense.GE)
 
-    def __eq__(self, value: object):
+    def __eq__(self, value: object):  # type: ignore
         """Equality constraint.
-        Examples
-        >>> from pyoframe import Variable
-        >>> Variable() == 1
-        <Constraint sense='=' size=1 dimensions={} terms=2>
-        x1 = 1
+
+        Examples:
+            >>> m = pf.Model()
+            >>> m.v = pf.Variable()
+            >>> m.v == 1
+            <Constraint sense='=' size=1 dimensions={} terms=2>
+            v = 1
         """
         return Constraint(self - value, ConstraintSense.EQ)
 
@@ -169,6 +231,15 @@ SetTypes = Union[
 
 
 class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
+    """
+    A set which can then be used to index variables.
+
+    Examples:
+        >>> pf.Set(x=range(2), y=range(3))
+        <Set size=6 dimensions={'x': 2, 'y': 3}>
+        [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]
+    """
+
     def __init__(self, *data: SetTypes | Iterable[SetTypes], **named_data):
         data_list = list(data)
         for name, set in named_data.items():
@@ -190,28 +261,29 @@ class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         *over: SetTypes | Iterable[SetTypes],
     ) -> pl.DataFrame:
         """
-        >>> import pandas as pd
-        >>> dim1 = pd.Index([1, 2, 3], name="dim1")
-        >>> dim2 = pd.Index(["a", "b"], name="dim1")
-        >>> Set._parse_acceptable_sets([dim1, dim2])
-        Traceback (most recent call last):
-        ...
-        AssertionError: All coordinates must have unique column names.
-        >>> dim2.name = "dim2"
-        >>> Set._parse_acceptable_sets([dim1, dim2])
-        shape: (6, 2)
-        ┌──────┬──────┐
-        │ dim1 ┆ dim2 │
-        │ ---  ┆ ---  │
-        │ i64  ┆ str  │
-        ╞══════╪══════╡
-        │ 1    ┆ a    │
-        │ 1    ┆ b    │
-        │ 2    ┆ a    │
-        │ 2    ┆ b    │
-        │ 3    ┆ a    │
-        │ 3    ┆ b    │
-        └──────┴──────┘
+        Examples:
+            >>> import pandas as pd
+            >>> dim1 = pd.Index([1, 2, 3], name="dim1")
+            >>> dim2 = pd.Index(["a", "b"], name="dim1")
+            >>> Set._parse_acceptable_sets([dim1, dim2])
+            Traceback (most recent call last):
+            ...
+            AssertionError: All coordinates must have unique column names.
+            >>> dim2.name = "dim2"
+            >>> Set._parse_acceptable_sets([dim1, dim2])
+            shape: (6, 2)
+            ┌──────┬──────┐
+            │ dim1 ┆ dim2 │
+            │ ---  ┆ ---  │
+            │ i64  ┆ str  │
+            ╞══════╪══════╡
+            │ 1    ┆ a    │
+            │ 1    ┆ b    │
+            │ 2    ┆ a    │
+            │ 2    ┆ b    │
+            │ 3    ┆ a    │
+            │ 3    ┆ b    │
+            └──────┴──────┘
         """
         assert len(over) > 0, "At least one set must be provided."
         over_iter: Iterable[SetTypes] = parse_inputs_as_iterable(*over)
@@ -248,7 +320,7 @@ class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
                 return self._new(
                     pl.concat([self.data, other.data]).unique(maintain_order=True)
                 )
-            except pl.ShapeError as e:
+            except pl.exceptions.ShapeError as e:
                 if "unable to vstack, column names don't match" in str(e):
                     raise PyoframeError(
                         f"Failed to add sets '{self.friendly_name}' and '{other.friendly_name}' because dimensions do not match ({self.dimensions} != {other.dimensions}) "
@@ -295,6 +367,10 @@ class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             df = set.to_frame()
         elif isinstance(set, Set):
             df = set.data
+        elif isinstance(set, range):
+            raise ValueError(
+                "Cannot convert a range to a set without a dimension name. Try Set(dim_name=range(...))"
+            )
         else:
             raise ValueError(f"Cannot convert type {type(set)} to a polars DataFrame")
 
@@ -313,24 +389,26 @@ class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
 
 class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
-    """A linear expression."""
+    """A linear or quadratic expression."""
 
     def __init__(self, data: pl.DataFrame):
         """
-        >>> import pandas as pd
-        >>> from pyoframe import Variable, Model
-        >>> df = pd.DataFrame({"item" : [1, 1, 1, 2, 2], "time": ["mon", "tue", "wed", "mon", "tue"], "cost": [1, 2, 3, 4, 5]}).set_index(["item", "time"])
-        >>> m = Model("min")
-        >>> m.Time = Variable(df.index)
-        >>> m.Size = Variable(df.index)
-        >>> expr = df["cost"] * m.Time + df["cost"] * m.Size
-        >>> expr
-        <Expression size=5 dimensions={'item': 2, 'time': 3} terms=10>
-        [1,mon]: Time[1,mon] + Size[1,mon]
-        [1,tue]: 2 Time[1,tue] +2 Size[1,tue]
-        [1,wed]: 3 Time[1,wed] +3 Size[1,wed]
-        [2,mon]: 4 Time[2,mon] +4 Size[2,mon]
-        [2,tue]: 5 Time[2,tue] +5 Size[2,tue]
+        A linear expression.
+
+        Examples:
+            >>> import pandas as pd
+            >>> df = pd.DataFrame({"item" : [1, 1, 1, 2, 2], "time": ["mon", "tue", "wed", "mon", "tue"], "cost": [1, 2, 3, 4, 5]}).set_index(["item", "time"])
+            >>> m = pf.Model()
+            >>> m.Time = pf.Variable(df.index)
+            >>> m.Size = pf.Variable(df.index)
+            >>> expr = df["cost"] * m.Time + df["cost"] * m.Size
+            >>> expr
+            <Expression size=5 dimensions={'item': 2, 'time': 3} terms=10>
+            [1,mon]: Time[1,mon] + Size[1,mon]
+            [1,tue]: 2 Time[1,tue] +2 Size[1,tue]
+            [1,wed]: 3 Time[1,wed] +3 Size[1,wed]
+            [2,mon]: 4 Time[2,mon] +4 Size[2,mon]
+            [2,tue]: 5 Time[2,tue] +5 Size[2,tue]
         """
         # Sanity checks, VAR_KEY and COEF_KEY must be present
         assert VAR_KEY in data.columns, "Missing variable column."
@@ -362,14 +440,32 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
     #         )
     #     )
 
+    @classmethod
+    def constant(cls, constant: int | float) -> "Expression":
+        """
+        Examples:
+            >>> pf.Expression.constant(5)
+            <Expression size=1 dimensions={} terms=1>
+            5
+        """
+        return cls(
+            pl.DataFrame(
+                {
+                    COEF_KEY: [constant],
+                    VAR_KEY: [CONST_TERM],
+                },
+                schema={COEF_KEY: pl.Float64, VAR_KEY: KEY_TYPE},
+            )
+        )
+
     def sum(self, over: Union[str, Iterable[str]]):
         """
         Examples:
             >>> import pandas as pd
-            >>> from pyoframe import Variable
+            >>> m = pf.Model()
             >>> df = pd.DataFrame({"item" : [1, 1, 1, 2, 2], "time": ["mon", "tue", "wed", "mon", "tue"], "cost": [1, 2, 3, 4, 5]}).set_index(["item", "time"])
-            >>> quantity = Variable(df.reset_index()[["item"]].drop_duplicates())
-            >>> expr = (quantity * df["cost"]).sum("time")
+            >>> m.quantity = Variable(df.reset_index()[["item"]].drop_duplicates())
+            >>> expr = (m.quantity * df["cost"]).sum("time")
             >>> expr.data
             shape: (2, 3)
             ┌──────┬─────────┬───────────────┐
@@ -393,11 +489,18 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
         return self._new(
             self.data.drop(over)
-            .group_by(remaining_dims + [VAR_KEY], maintain_order=True)
+            .group_by(remaining_dims + self._variable_columns, maintain_order=True)
             .sum()
         )
 
-    def map(self, mapping_set: SetTypes, drop_shared_dims: bool = True):
+    @property
+    def _variable_columns(self) -> List[str]:
+        if self.is_quadratic:
+            return [VAR_KEY, QUAD_VAR_KEY]
+        else:
+            return [VAR_KEY]
+
+    def map(self, mapping_set: SetTypes, drop_shared_dims: bool = True) -> Expression:
         """
         Replaces the dimensions that are shared with mapping_set with the other dimensions found in mapping_set.
 
@@ -405,33 +508,29 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         is indexed by city to data indexed by country (see example).
 
         Parameters:
-            mapping_set : SetTypes
+            mapping_set:
                 The set to map the expression to. This can be a DataFrame, Index, or another Set.
-            drop_shared_dims : bool, default True
+            drop_shared_dims:
                 If True, the dimensions shared between the expression and the mapping set are dropped from the resulting expression and
                     repeated rows are summed.
                 If False, the shared dimensions are kept in the resulting expression.
 
         Returns:
-            Expression
-                A new Expression containing the result of the mapping operation.
+            A new Expression containing the result of the mapping operation.
 
         Examples:
-
-        >>> import polars as pl
-        >>> from pyoframe import Variable, Model
-        >>> pop_data = pl.DataFrame({"city": ["Toronto", "Vancouver", "Boston"], "year": [2024, 2024, 2024], "population": [10, 2, 8]}).to_expr()
-        >>> cities_and_countries = pl.DataFrame({"city": ["Toronto", "Vancouver", "Boston"], "country": ["Canada", "Canada", "USA"]})
-        >>> pop_data.map(cities_and_countries)
-        <Expression size=2 dimensions={'year': 1, 'country': 2} terms=2>
-        [2024,Canada]: 12
-        [2024,USA]: 8
-
-        >>> pop_data.map(cities_and_countries, drop_shared_dims=False)
-        <Expression size=3 dimensions={'city': 3, 'year': 1, 'country': 2} terms=3>
-        [Toronto,2024,Canada]: 10
-        [Vancouver,2024,Canada]: 2
-        [Boston,2024,USA]: 8
+            >>> import polars as pl
+            >>> pop_data = pl.DataFrame({"city": ["Toronto", "Vancouver", "Boston"], "year": [2024, 2024, 2024], "population": [10, 2, 8]}).to_expr()
+            >>> cities_and_countries = pl.DataFrame({"city": ["Toronto", "Vancouver", "Boston"], "country": ["Canada", "Canada", "USA"]})
+            >>> pop_data.map(cities_and_countries)
+            <Expression size=2 dimensions={'year': 1, 'country': 2} terms=2>
+            [2024,Canada]: 12
+            [2024,USA]: 8
+            >>> pop_data.map(cities_and_countries, drop_shared_dims=False)
+            <Expression size=3 dimensions={'city': 3, 'year': 1, 'country': 2} terms=3>
+            [Toronto,2024,Canada]: 10
+            [Vancouver,2024,Canada]: 2
+            [Boston,2024,USA]: 8
         """
         mapping_set = Set(mapping_set)
 
@@ -458,7 +557,7 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
         return mapped_expression
 
-    def rolling_sum(self, over: str, window_size: int):
+    def rolling_sum(self, over: str, window_size: int) -> Expression:
         """
         Calculates the rolling sum of the Expression over a specified window size for a given dimension.
 
@@ -467,25 +566,23 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
 
         Parameters:
-            over : str
+            over :
                 The name of the dimension (column) over which the rolling sum is calculated.
                 This dimension must exist within the Expression's dimensions.
-            window_size : int
+            window_size :
                 The size of the moving window in terms of number of records.
                 The rolling sum is calculated over this many consecutive elements.
 
         Returns:
-            Expression
-                A new Expression instance containing the result of the rolling sum operation.
+            A new Expression instance containing the result of the rolling sum operation.
                 This new Expression retains all dimensions (columns) of the original data,
                 with the rolling sum applied over the specified dimension.
 
         Examples:
             >>> import polars as pl
-            >>> from pyoframe import Variable, Model
             >>> cost = pl.DataFrame({"item" : [1, 1, 1, 2, 2], "time": [1, 2, 3, 1, 2], "cost": [1, 2, 3, 4, 5]})
-            >>> m = Model("min")
-            >>> m.quantity = Variable(cost[["item", "time"]])
+            >>> m = pf.Model()
+            >>> m.quantity = pf.Variable(cost[["item", "time"]])
             >>> (m.quantity * cost).rolling_sum(over="time", window_size=2)
             <Expression size=5 dimensions={'item': 2, 'time': 3} terms=8>
             [1,1]: quantity[1,1]
@@ -507,7 +604,9 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
                 [
                     df.with_columns(pl.col(over).max())
                     for _, df in self.data.rolling(
-                        index_column=over, period=f"{window_size}i", by=remaining_dims
+                        index_column=over,
+                        period=f"{window_size}i",
+                        group_by=remaining_dims,
                     )
                 ]
             )
@@ -515,20 +614,20 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
     def within(self, set: "SetTypes") -> Expression:
         """
-        Examples
-        >>> import pandas as pd
-        >>> general_expr = pd.DataFrame({"dim1": [1, 2, 3], "value": [1, 2, 3]}).to_expr()
-        >>> filter_expr = pd.DataFrame({"dim1": [1, 3], "value": [5, 6]}).to_expr()
-        >>> general_expr.within(filter_expr).data
-        shape: (2, 3)
-        ┌──────┬─────────┬───────────────┐
-        │ dim1 ┆ __coeff ┆ __variable_id │
-        │ ---  ┆ ---     ┆ ---           │
-        │ i64  ┆ f64     ┆ u32           │
-        ╞══════╪═════════╪═══════════════╡
-        │ 1    ┆ 1.0     ┆ 0             │
-        │ 3    ┆ 3.0     ┆ 0             │
-        └──────┴─────────┴───────────────┘
+        Examples:
+            >>> import pandas as pd
+            >>> general_expr = pd.DataFrame({"dim1": [1, 2, 3], "value": [1, 2, 3]}).to_expr()
+            >>> filter_expr = pd.DataFrame({"dim1": [1, 3], "value": [5, 6]}).to_expr()
+            >>> general_expr.within(filter_expr).data
+            shape: (2, 3)
+            ┌──────┬─────────┬───────────────┐
+            │ dim1 ┆ __coeff ┆ __variable_id │
+            │ ---  ┆ ---     ┆ ---           │
+            │ i64  ┆ f64     ┆ u32           │
+            ╞══════╪═════════╪═══════════════╡
+            │ 1    ┆ 1.0     ┆ 0             │
+            │ 3    ┆ 3.0     ┆ 0             │
+            └──────┴─────────┴───────────────┘
         """
         df: pl.DataFrame = Set(set).data
         set_dims = _get_dimensions(df)
@@ -543,24 +642,69 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         by_dims = df.select(dims_in_common).unique(maintain_order=True)
         return self._new(self.data.join(by_dims, on=dims_in_common))
 
+    @property
+    def is_quadratic(self) -> bool:
+        """
+        Returns True if the expression is quadratic, False otherwise.
+
+        Computes in O(1) since expressions are quadratic if and
+        only if self.data contain the QUAD_VAR_KEY column.
+
+        Examples:
+            >>> import pandas as pd
+            >>> m = pf.Model()
+            >>> m.v = Variable()
+            >>> expr = pd.DataFrame({"dim1": [1, 2, 3], "value": [1, 2, 3]}) * m.v
+            >>> expr *= m.v
+            >>> expr.is_quadratic
+            True
+        """
+        return QUAD_VAR_KEY in self.data.columns
+
+    def degree(self) -> int:
+        """
+        Returns the degree of the expression (0=constant, 1=linear, 2=quadratic).
+
+        Examples:
+            >>> import pandas as pd
+            >>> m = pf.Model()
+            >>> m.v1 = pf.Variable()
+            >>> m.v2 = pf.Variable()
+            >>> expr = pd.DataFrame({"dim1": [1, 2, 3], "value": [1, 2, 3]}).to_expr()
+            >>> expr.degree()
+            0
+            >>> expr *= m.v1
+            >>> expr.degree()
+            1
+            >>> expr += (m.v2 ** 2).add_dim("dim1")
+            >>> expr.degree()
+            2
+        """
+        if self.is_quadratic:
+            return 2
+        elif (self.data.get_column(VAR_KEY) != CONST_TERM).any():
+            return 1
+        else:
+            return 0
+
     def __add__(self, other):
         """
         Examples:
             >>> import pandas as pd
-            >>> from pyoframe import Variable
+            >>> m = pf.Model()
             >>> add = pd.DataFrame({"dim1": [1,2,3], "add": [10, 20, 30]}).to_expr()
-            >>> var = Variable(add)
-            >>> var + add
+            >>> m.v = Variable(add)
+            >>> m.v + add
             <Expression size=3 dimensions={'dim1': 3} terms=6>
-            [1]: x1 +10
-            [2]: x2 +20
-            [3]: x3 +30
-            >>> var + add + 2
+            [1]: v[1] +10
+            [2]: v[2] +20
+            [3]: v[3] +30
+            >>> m.v + add + 2
             <Expression size=3 dimensions={'dim1': 3} terms=6>
-            [1]: x1 +12
-            [2]: x2 +22
-            [3]: x3 +32
-            >>> var + pd.DataFrame({"dim1": [1,2], "add": [10, 20]})
+            [1]: v[1] +12
+            [2]: v[2] +22
+            [3]: v[3] +32
+            >>> m.v + pd.DataFrame({"dim1": [1,2], "add": [10, 20]})
             Traceback (most recent call last):
             ...
             pyoframe.constants.PyoframeError: Failed to add expressions:
@@ -575,9 +719,10 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             ╞══════╪════════════╡
             │ 3    ┆ null       │
             └──────┴────────────┘
-            >>> 5 + 2 * Variable()
+            >>> m.v2 = Variable()
+            >>> 5 + 2 * m.v2
             <Expression size=1 dimensions={} terms=2>
-            2 x4 +5
+            2 v2 +5
         """
         if isinstance(other, str):
             raise ValueError(
@@ -597,31 +742,7 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
         other = other.to_expr()
         self._learn_from_other(other)
-
-        if (other.data.get_column(VAR_KEY) != CONST_TERM).any():
-            self, other = other, self
-
-        if (other.data.get_column(VAR_KEY) != CONST_TERM).any():
-            raise ValueError(
-                "Multiplication of two expressions with variables is non-linear and not supported."
-            )
-        multiplier = other.data.drop(VAR_KEY)
-
-        dims = self.dimensions_unsafe
-        other_dims = other.dimensions_unsafe
-        dims_in_common = [dim for dim in dims if dim in other_dims]
-
-        data = (
-            self.data.join(
-                multiplier,
-                on=dims_in_common if len(dims_in_common) > 0 else None,
-                how="inner" if dims_in_common else "cross",
-            )
-            .with_columns(pl.col(COEF_KEY) * pl.col(COEF_KEY + "_right"))
-            .drop(COEF_KEY + "_right")
-        )
-
-        return self._new(data)
+        return _multiply_expressions(self, other)
 
     def to_expr(self) -> Expression:
         return self
@@ -638,28 +759,66 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         return e
 
     def _add_const(self, const: int | float) -> Expression:
+        """
+        Examples:
+            >>> m = pf.Model()
+            >>> m.x1 = Variable()
+            >>> m.x2 = Variable()
+            >>> m.x1 + 5
+            <Expression size=1 dimensions={} terms=2>
+            x1 +5
+            >>> m.x1 ** 2 + 5
+            <Expression size=1 dimensions={} terms=2 degree=2>
+            x1 * x1 +5
+            >>> m.x1 ** 2 + m.x2 + 5
+            <Expression size=1 dimensions={} terms=3 degree=2>
+            x1 * x1 + x2 +5
+
+            It also works with dimensions
+
+            >>> m = pf.Model()
+            >>> m.v = Variable({"dim1": [1, 2, 3]})
+            >>> m.v * m.v + 5
+            <Expression size=3 dimensions={'dim1': 3} terms=6 degree=2>
+            [1]: 5  + v[1] * v[1]
+            [2]: 5  + v[2] * v[2]
+            [3]: 5  + v[3] * v[3]
+        """
         dim = self.dimensions
         data = self.data
         # Fill in missing constant terms
         if not dim:
             if CONST_TERM not in data[VAR_KEY]:
+                const_df = pl.DataFrame(
+                    {COEF_KEY: [0.0], VAR_KEY: [CONST_TERM]},
+                    schema={COEF_KEY: pl.Float64, VAR_KEY: KEY_TYPE},
+                )
+                if self.is_quadratic:
+                    const_df = const_df.with_columns(
+                        pl.lit(CONST_TERM).alias(QUAD_VAR_KEY).cast(KEY_TYPE)
+                    )
                 data = pl.concat(
-                    [
-                        data,
-                        pl.DataFrame(
-                            {COEF_KEY: [0.0], VAR_KEY: [CONST_TERM]},
-                            schema={COEF_KEY: pl.Float64, VAR_KEY: VAR_TYPE},
-                        ),
-                    ],
+                    [data, const_df],
                     how="vertical_relaxed",
                 )
         else:
             keys = (
                 data.select(dim)
                 .unique(maintain_order=True)
-                .with_columns(pl.lit(CONST_TERM).alias(VAR_KEY).cast(VAR_TYPE))
+                .with_columns(pl.lit(CONST_TERM).alias(VAR_KEY).cast(KEY_TYPE))
             )
-            data = data.join(keys, on=dim + [VAR_KEY], how="outer_coalesce")
+            if self.is_quadratic:
+                keys = keys.with_columns(
+                    pl.lit(CONST_TERM).alias(QUAD_VAR_KEY).cast(KEY_TYPE)
+                )
+            if POLARS_VERSION.major >= 1:
+                data = data.join(
+                    keys, on=dim + self._variable_columns, how="full", coalesce=True
+                )
+            else:
+                data = data.join(
+                    keys, on=dim + self._variable_columns, how="outer_coalesce"
+                )
             data = data.with_columns(pl.col(COEF_KEY).fill_null(0.0))
 
         data = data.with_columns(
@@ -674,17 +833,20 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
     def constant_terms(self):
         dims = self.dimensions
         constant_terms = self.data.filter(pl.col(VAR_KEY) == CONST_TERM).drop(VAR_KEY)
+        if self.is_quadratic:
+            constant_terms = constant_terms.drop(QUAD_VAR_KEY)
         if dims is not None:
-            return constant_terms.join(
-                self.data.select(dims).unique(maintain_order=True),
-                on=dims,
-                how="outer_coalesce",
-            ).with_columns(pl.col(COEF_KEY).fill_null(0.0))
+            dims_df = self.data.select(dims).unique(maintain_order=True)
+            if POLARS_VERSION.major >= 1:
+                df = constant_terms.join(dims_df, on=dims, how="full", coalesce=True)
+            else:
+                df = constant_terms.join(dims_df, on=dims, how="outer_coalesce")
+            return df.with_columns(pl.col(COEF_KEY).fill_null(0.0))
         else:
             if len(constant_terms) == 0:
                 return pl.DataFrame(
                     {COEF_KEY: [0.0], VAR_KEY: [CONST_TERM]},
-                    schema={COEF_KEY: pl.Float64, VAR_KEY: VAR_TYPE},
+                    schema={COEF_KEY: pl.Float64, VAR_KEY: KEY_TYPE},
                 )
             return constant_terms
 
@@ -692,23 +854,20 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
     def variable_terms(self):
         return self.data.filter(pl.col(VAR_KEY) != CONST_TERM)
 
-    @property
     @unwrap_single_values
-    def value(self) -> pl.DataFrame:
+    def evaluate(self) -> pl.DataFrame:
         """
         The value of the expression. Only available after the model has been solved.
 
         Examples:
-            >>> import pyoframe as pf
-            >>> m = pf.Model("max")
+            >>> m = pf.Model()
             >>> m.X = pf.Variable({"dim1": [1, 2, 3]}, ub=10)
             >>> m.expr_1 = 2 * m.X + 1
             >>> m.expr_2 = pf.sum(m.expr_1)
-            >>> m.objective = m.expr_2 - 3
-            >>> result = m.solve(log_to_console=False) # doctest: +ELLIPSIS
-            <BLANKLINE>
-            ...
-            >>> m.expr_1.value
+            >>> m.maximize = m.expr_2 - 3
+            >>> m.attr.Silent = True
+            >>> m.optimize()
+            >>> m.expr_1.evaluate()
             shape: (3, 2)
             ┌──────┬──────────┐
             │ dim1 ┆ solution │
@@ -719,66 +878,76 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             │ 2    ┆ 21.0     │
             │ 3    ┆ 21.0     │
             └──────┴──────────┘
-            >>> m.expr_2.value
+            >>> m.expr_2.evaluate()
             63.0
         """
         assert (
             self._model is not None
         ), "Expression must be added to the model to use .value"
-        if self._model.result is None or self._model.result.solution is None:
-            raise ValueError(
-                "Can't obtain value of expression since the model has not been solved."
-            )
 
-        df = (
-            self.data.join(self._model.result.solution.primal, on=VAR_KEY, how="left")
-            .with_columns(
+        df = self.data
+        sm = self._model.poi
+        attr = poi.VariableAttribute.Value
+        for var_col in self._variable_columns:
+            df = df.with_columns(
                 (
-                    pl.when(pl.col(VAR_KEY) == CONST_TERM)
-                    .then(1)
-                    .otherwise(pl.col(SOLUTION_KEY))
-                    * pl.col(COEF_KEY)
-                ).alias(SOLUTION_KEY)
-            )
-            .drop(VAR_KEY)
-            .drop(COEF_KEY)
-        )
+                    pl.col(COEF_KEY)
+                    * pl.col(var_col).map_elements(
+                        lambda v_id: (
+                            sm.get_variable_attribute(poi.VariableIndex(v_id), attr)
+                            if v_id != CONST_TERM
+                            else 1
+                        ),
+                        return_dtype=pl.Float64,
+                    )
+                ).alias(COEF_KEY)
+            ).drop(var_col)
+
+        df = df.rename({COEF_KEY: SOLUTION_KEY})
 
         dims = self.dimensions
         if dims is not None:
             df = df.group_by(dims, maintain_order=True)
         return df.sum()
 
-    def to_str_table(
-        self,
-        max_line_len=None,
-        max_rows=None,
-        include_const_term=True,
-        include_const_variable=False,
-        var_map=None,
-        float_precision=None,
-    ):
+    def to_poi(self) -> poi.ScalarAffineFunction:
+        if self.dimensions is not None:
+            raise ValueError(
+                "Only non-dimensioned expressions can be converted to PyOptInterface."
+            )  # pragma: no cover
+
+        return poi.ScalarAffineFunction(
+            coefficients=self.data.get_column(COEF_KEY).to_numpy(),
+            variables=self.data.get_column(VAR_KEY).to_numpy(),
+        )
+
+    def to_str_table(self, include_const_term=True):
         data = self.data if include_const_term else self.variable_terms
-        data = cast_coef_to_string(data, float_precision=float_precision)
+        data = cast_coef_to_string(data)
 
-        if var_map is not None:
-            data = var_map.apply(data, to_col="str_var")
-        elif self._model is not None and self._model.var_map is not None:
-            var_map = self._model.var_map
-            data = var_map.apply(data, to_col="str_var")
-        else:
-            data = data.with_columns(
-                pl.concat_str(pl.lit("x"), VAR_KEY).alias("str_var")
-            )
-        if include_const_variable:
-            data = data.drop(VAR_KEY).rename({"str_var": VAR_KEY})
-        else:
+        for var_col in self._variable_columns:
+            temp_var_column = f"{var_col}_temp"
+            if self._model is not None and self._model.var_map is not None:
+                data = self._model.var_map.apply(
+                    data, to_col=temp_var_column, id_col=var_col
+                )
+            else:
+                data = data.with_columns(
+                    pl.concat_str(pl.lit("x"), var_col).alias(temp_var_column)
+                )
             data = data.with_columns(
-                pl.when(pl.col(VAR_KEY) == CONST_TERM)
+                pl.when(pl.col(var_col) == CONST_TERM)
                 .then(pl.lit(""))
-                .otherwise("str_var")
+                .otherwise(temp_var_column)
+                .alias(var_col)
+            ).drop(temp_var_column)
+        if self.is_quadratic:
+            data = data.with_columns(
+                pl.when(pl.col(QUAD_VAR_KEY) == "")
+                .then(pl.col(VAR_KEY))
+                .otherwise(pl.concat_str(VAR_KEY, pl.lit(" * "), pl.col(QUAD_VAR_KEY)))
                 .alias(VAR_KEY)
-            ).drop("str_var")
+            ).drop(QUAD_VAR_KEY)
 
         dimensions = self.dimensions
 
@@ -791,7 +960,6 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             )
         ).drop(COEF_KEY, VAR_KEY)
 
-        # Combine terms into one string
         if dimensions is not None:
             data = data.group_by(dimensions, maintain_order=True).agg(
                 pl.col("expr").str.concat(delimiter=" ")
@@ -803,15 +971,15 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         data = data.with_columns(pl.col("expr").str.strip_chars(characters=" +"))
 
         # TODO add vertical ... if too many rows, in the middle of the table
-        if max_rows:
-            data = data.head(max_rows)
+        if Config.print_max_lines:
+            data = data.head(Config.print_max_lines)
 
-        if max_line_len:
+        if Config.print_max_line_length:
             data = data.with_columns(
-                pl.when(pl.col("expr").str.len_chars() > max_line_len)
+                pl.when(pl.col("expr").str.len_chars() > Config.print_max_line_length)
                 .then(
                     pl.concat_str(
-                        pl.col("expr").str.slice(0, max_line_len),
+                        pl.col("expr").str.slice(0, Config.print_max_line_length),
                         pl.lit("..."),
                     )
                 )
@@ -820,54 +988,45 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         return data
 
     def to_str_create_prefix(self, data):
-        if self.name is not None or self.dimensions:
-            data = concat_dimensions(data, prefix=self.name, ignore_columns=["expr"])
-            data = data.with_columns(
+        if self.name is None and self.dimensions is None:
+            return data
+
+        return (
+            concat_dimensions(data, prefix=self.name, ignore_columns=["expr"])
+            .with_columns(
                 pl.concat_str("concated_dim", pl.lit(": "), "expr").alias("expr")
-            ).drop("concated_dim")
-        return data
+            )
+            .drop("concated_dim")
+        )
 
     def to_str(
         self,
-        max_line_len=None,
-        max_rows=None,
         include_const_term=True,
-        include_const_variable=False,
-        var_map=None,
-        include_prefix=True,
         include_header=False,
         include_data=True,
-        float_precision=None,
     ):
         result = ""
         if include_header:
             result += get_obj_repr(
-                self, size=len(self), dimensions=self.shape, terms=len(self.data)
+                self,
+                size=len(self),
+                dimensions=self.shape,
+                terms=len(self.data),
+                degree=2 if self.degree() == 2 else None,
             )
         if include_header and include_data:
             result += "\n"
         if include_data:
             str_table = self.to_str_table(
-                max_line_len=max_line_len,
-                max_rows=max_rows,
                 include_const_term=include_const_term,
-                include_const_variable=include_const_variable,
-                var_map=var_map,
-                float_precision=float_precision,
             )
-            if include_prefix:
-                str_table = self.to_str_create_prefix(str_table)
+            str_table = self.to_str_create_prefix(str_table)
             result += str_table.select(pl.col("expr").str.concat(delimiter="\n")).item()
 
         return result
 
     def __repr__(self) -> str:
-        return self.to_str(
-            max_line_len=80,
-            max_rows=15,
-            include_header=True,
-            float_precision=Config.print_float_precision,
-        )
+        return self.to_str(include_header=True)
 
     def __str__(self) -> str:
         return self.to_str()
@@ -918,80 +1077,157 @@ class Constraint(ModelElementWithId):
         """Initialize a constraint.
 
         Parameters:
-            lhs: Expression
+            lhs:
                 The left hand side of the constraint.
-            sense: Sense
+            sense:
                 The sense of the constraint.
         """
         self.lhs = lhs
         self._model = lhs._model
         self.sense = sense
         self.to_relax: Optional[FuncArgs] = None
+        self.attr = Container(self._set_attribute, self._get_attribute)
 
         dims = self.lhs.dimensions
         data = pl.DataFrame() if dims is None else self.lhs.data.select(dims).unique()
 
         super().__init__(data)
 
+    def _set_attribute(self, name, value):
+        self._assert_has_ids()
+        col_name = name
+        try:
+            name = poi.ConstraintAttribute[name]
+            setter = self._model.poi.set_constraint_attribute
+        except KeyError:
+            setter = self._model.poi.set_constraint_raw_attribute
+
+        if self.dimensions is None:
+            for key in self.data.get_column(CONSTRAINT_KEY):
+                setter(poi.ConstraintIndex(poi.ConstraintType.Linear, key), name, value)
+        else:
+            for key, value in (
+                self.data.join(value, on=self.dimensions, how="inner")
+                .select(pl.col(CONSTRAINT_KEY), pl.col(col_name))
+                .iter_rows()
+            ):
+                setter(poi.ConstraintIndex(poi.ConstraintType.Linear, key), name, value)
+
+    @unwrap_single_values
+    def _get_attribute(self, name):
+        self._assert_has_ids()
+        col_name = name
+        try:
+            name = poi.ConstraintAttribute[name]
+            getter = self._model.poi.get_constraint_attribute
+        except KeyError:
+            getter = self._model.poi.get_constraint_raw_attribute
+
+        with (
+            warnings.catch_warnings()
+        ):  # map_elements without return_dtype= gives a warning
+            warnings.filterwarnings(
+                action="ignore", category=pl.exceptions.MapWithoutReturnDtypeWarning
+            )
+            return self.data.with_columns(
+                pl.col(CONSTRAINT_KEY)
+                .map_elements(
+                    lambda v_id: getter(
+                        poi.ConstraintIndex(poi.ConstraintType.Linear, v_id), name
+                    )
+                )
+                .alias(col_name)
+            ).select(self.dimensions_unsafe + [col_name])
+
     def on_add_to_model(self, model: "Model", name: str):
         super().on_add_to_model(model, name)
         if self.to_relax is not None:
             self.relax(*self.to_relax.args, **self.to_relax.kwargs)
+        self._assign_ids()
 
-    @property
-    @unwrap_single_values
-    def slack(self):
-        """
-        The slack of the constraint.
-        Will raise an error if the model has not already been solved.
-        The first call to this property will load the slack values from the solver (lazy loading).
-        """
-        if SLACK_COL not in self.data.columns:
-            assert (
-                self._model is not None
-            ), "Constraint must be added to a model to get the slack."
-            if self._model.solver is None:
-                raise ValueError("The model has not been solved yet.")
-            self._model.solver.load_slack()
-        return self.data.select(self.dimensions_unsafe + [SLACK_COL])
+    def _assign_ids(self):
+        assert self._model is not None
+
+        is_quadratic = self.lhs.is_quadratic
+        use_var_names = self._model.use_var_names
+        kwargs: Dict[str, Any] = dict(sense=self.sense.to_poi(), rhs=0)
 
-    @slack.setter
-    def slack(self, value):
-        self._extend_dataframe_by_id(value)
+        key_cols = [COEF_KEY] + self.lhs._variable_columns
+        key_cols_polars = [pl.col(c) for c in key_cols]
+
+        add_constraint = (
+            self._model.poi.add_quadratic_constraint
+            if is_quadratic
+            else self._model.poi.add_linear_constraint
+        )
+        ScalarFunction = (
+            poi.ScalarQuadraticFunction if is_quadratic else poi.ScalarAffineFunction
+        )
+
+        if self.dimensions is None:
+            if self._model.use_var_names:
+                kwargs["name"] = self.name
+            df = self.data.with_columns(
+                pl.lit(
+                    add_constraint(
+                        ScalarFunction(
+                            *[self.lhs.data.get_column(c).to_numpy() for c in key_cols]
+                        ),
+                        **kwargs,
+                    ).index
+                )
+                .alias(CONSTRAINT_KEY)
+                .cast(KEY_TYPE)
+            )
+        else:
+            df = self.lhs.data.group_by(self.dimensions, maintain_order=True).agg(
+                *key_cols_polars
+            )
+            if use_var_names:
+                df = (
+                    concat_dimensions(df, prefix=self.name)
+                    .with_columns(
+                        pl.struct(*key_cols_polars, pl.col("concated_dim"))
+                        .map_elements(
+                            lambda x: add_constraint(
+                                ScalarFunction(*[np.array(x[c]) for c in key_cols]),
+                                name=x["concated_dim"],
+                                **kwargs,
+                            ).index,
+                            return_dtype=KEY_TYPE,
+                        )
+                        .alias(CONSTRAINT_KEY)
+                    )
+                    .drop("concated_dim")
+                )
+            else:
+                df = df.with_columns(
+                    pl.struct(*key_cols_polars)
+                    .map_elements(
+                        lambda x: add_constraint(
+                            ScalarFunction(*[np.array(x[c]) for c in key_cols]),
+                            **kwargs,
+                        ).index,
+                        return_dtype=KEY_TYPE,
+                    )
+                    .alias(CONSTRAINT_KEY)
+                )
+            df = df.drop(key_cols)
+
+        self._data = df
 
     @property
     @unwrap_single_values
     def dual(self) -> Union[pl.DataFrame, float]:
-        if DUAL_KEY not in self.data.columns:
-            raise ValueError(f"No dual values founds for constraint '{self.name}'")
-        return self.data.select(self.dimensions_unsafe + [DUAL_KEY])
-
-    @dual.setter
-    def dual(self, value):
-        self._extend_dataframe_by_id(value)
+        dual = self.attr.Dual
+        if isinstance(dual, pl.DataFrame):
+            dual = dual.rename({"Dual": DUAL_KEY})
+        return dual
 
     @classmethod
     def get_id_column_name(cls):
         return CONSTRAINT_KEY
 
-    def to_str_create_prefix(self, data, const_map=None):
-        if const_map is None:
-            return self.lhs.to_str_create_prefix(data)
-
-        data_map = const_map.apply(self.ids, to_col=None)
-
-        if self.dimensions is None:
-            assert data.height == 1
-            prefix = data_map.select(pl.col(CONSTRAINT_KEY)).item()
-            return data.select(
-                pl.concat_str(pl.lit(f"{prefix}: "), "expr").alias("expr")
-            )
-
-        data = data.join(data_map, on=self.dimensions)
-        return data.with_columns(
-            pl.concat_str(CONSTRAINT_KEY, pl.lit(": "), "expr").alias("expr")
-        ).drop(CONSTRAINT_KEY)
-
     def filter(self, *args, **kwargs) -> pl.DataFrame:
         return self.lhs.data.filter(*args, **kwargs)
 
@@ -1002,25 +1238,64 @@ class Constraint(ModelElementWithId):
         Relaxes the constraint by adding a variable to the constraint that can be non-zero at a cost.
 
         Parameters:
-            cost: SupportsToExpr
+            cost:
                 The cost of relaxing the constraint. Costs should be positives as they will automatically
                 become negative for maximization problems.
-            max: SupportsToExpr, default None
+            max:
                 The maximum value of the relaxation variable.
 
         Returns:
             The same constraint
 
         Examples:
-            >>> import pyoframe as pf
-            >>> m = pf.Model("max")
+            >>> m = pf.Model()
+            >>> m.hours_sleep = pf.Variable(lb=0)
+            >>> m.hours_day = pf.Variable(lb=0)
+            >>> m.hours_in_day = m.hours_sleep + m.hours_day == 24
+            >>> m.maximize = m.hours_day
+            >>> m.must_sleep = (m.hours_sleep >= 8).relax(cost=2, max=3)
+            >>> m.optimize()
+            >>> m.hours_day.solution
+            16.0
+            >>> m.maximize += 2 * m.hours_day
+            >>> m.optimize()
+            >>> m.hours_day.solution
+            19.0
+
+            Note: .relax() can only be called after the sense of the model has been defined.
+
+            >>> m = pf.Model()
+            >>> m.hours_sleep = pf.Variable(lb=0)
+            >>> m.hours_day = pf.Variable(lb=0)
+            >>> m.hours_in_day = m.hours_sleep + m.hours_day == 24
+            >>> m.must_sleep = (m.hours_sleep >= 8).relax(cost=2, max=3)
+            Traceback (most recent call last):
+            ...
+            ValueError: Cannot relax a constraint before the objective sense has been set. Try setting the objective first or using Model(sense=...).
+
+            One way to solve this is by setting the sense directly on the model. See how this works fine:
+
+            >>> m = pf.Model(sense="max")
+            >>> m.hours_sleep = pf.Variable(lb=0)
+            >>> m.hours_day = pf.Variable(lb=0)
+            >>> m.hours_in_day = m.hours_sleep + m.hours_day == 24
+            >>> m.must_sleep = (m.hours_sleep >= 8).relax(cost=2, max=3)
+
+            And now an example with dimensions:
+
             >>> homework_due_tomorrow = pl.DataFrame({"project": ["A", "B", "C"], "cost_per_hour_underdelivered": [10, 20, 30], "hours_to_finish": [9, 9, 9], "max_underdelivered": [1, 9, 9]})
             >>> m.hours_spent = pf.Variable(homework_due_tomorrow[["project"]], lb=0)
-            >>> m.must_finish_project = m.hours_spent >= homework_due_tomorrow[["project", "hours_to_finish"]]
+            >>> m.must_finish_project = (m.hours_spent >= homework_due_tomorrow[["project", "hours_to_finish"]]).relax(homework_due_tomorrow[["project", "cost_per_hour_underdelivered"]], max=homework_due_tomorrow[["project", "max_underdelivered"]])
             >>> m.only_one_day = sum("project", m.hours_spent) <= 24
-            >>> _ = m.must_finish_project.relax(homework_due_tomorrow[["project", "cost_per_hour_underdelivered"]], max=homework_due_tomorrow[["project", "max_underdelivered"]])
-            >>> _ = m.solve(log_to_console=False) # doctest: +ELLIPSIS
-            \rWriting ...
+            >>> # Relaxing a constraint after it has already been assigned will give an error
+            >>> m.only_one_day.relax(1)
+            Traceback (most recent call last):
+            ...
+            ValueError: .relax() must be called before the Constraint is added to the model
+            >>> m.attr.Silent = True
+            >>> m.optimize()
+            >>> m.maximize.value
+            -50.0
             >>> m.hours_spent.solution
             shape: (3, 2)
             ┌─────────┬──────────┐
@@ -1032,30 +1307,12 @@ class Constraint(ModelElementWithId):
             │ B       ┆ 7.0      │
             │ C       ┆ 9.0      │
             └─────────┴──────────┘
-
-
-            >>> # It can also be done all in one go!
-            >>> m = pf.Model("max")
-            >>> homework_due_tomorrow = pl.DataFrame({"project": ["A", "B", "C"], "cost_per_hour_underdelivered": [10, 20, 30], "hours_to_finish": [9, 9, 9], "max_underdelivered": [1, 9, 9]})
-            >>> m.hours_spent = pf.Variable(homework_due_tomorrow[["project"]], lb=0)
-            >>> m.must_finish_project = (m.hours_spent >= homework_due_tomorrow[["project", "hours_to_finish"]]).relax(5)
-            >>> m.only_one_day = (sum("project", m.hours_spent) <= 24).relax(1)
-            >>> _ = m.solve(log_to_console=False) # doctest: +ELLIPSIS
-            \rWriting ...
-            >>> m.objective.value
-            -3.0
-            >>> m.hours_spent.solution
-            shape: (3, 2)
-            ┌─────────┬──────────┐
-            │ project ┆ solution │
-            │ ---     ┆ ---      │
-            │ str     ┆ f64      │
-            ╞═════════╪══════════╡
-            │ A       ┆ 9.0      │
-            │ B       ┆ 9.0      │
-            │ C       ┆ 9.0      │
-            └─────────┴──────────┘
         """
+        if self._has_ids:
+            raise ValueError(
+                ".relax() must be called before the Constraint is added to the model"
+            )
+
         m = self._model
         if m is None or self.name is None:
             self.to_relax = FuncArgs(args=[cost, max])
@@ -1066,6 +1323,7 @@ class Constraint(ModelElementWithId):
             m, var_name
         ), "Conflicting names, relaxation variable already exists on the model."
         var = Variable(self, lb=0, ub=max)
+        setattr(m, var_name, var)
 
         if self.sense == ConstraintSense.LE:
             self.lhs -= var
@@ -1077,11 +1335,14 @@ class Constraint(ModelElementWithId):
                 "Relaxation for equalities has not yet been implemented. Submit a pull request!"
             )
 
-        setattr(m, var_name, var)
         penalty = var * cost
         if self.dimensions:
             penalty = sum(self.dimensions, penalty)
-        if m.sense == ObjSense.MAX:
+        if m.sense is None:
+            raise ValueError(
+                "Cannot relax a constraint before the objective sense has been set. Try setting the objective first or using Model(sense=...)."
+            )
+        elif m.sense == ObjSense.MAX:
             penalty *= -1
         if m.objective is None:
             m.objective = penalty
@@ -1090,24 +1351,12 @@ class Constraint(ModelElementWithId):
 
         return self
 
-    def to_str(
-        self,
-        max_line_len=None,
-        max_rows=None,
-        var_map=None,
-        float_precision=None,
-        const_map=None,
-    ) -> str:
+    def to_str(self) -> str:
         dims = self.dimensions
-        str_table = self.lhs.to_str_table(
-            max_line_len=max_line_len,
-            max_rows=max_rows,
-            include_const_term=False,
-            var_map=var_map,
-        )
-        str_table = self.to_str_create_prefix(str_table, const_map=const_map)
+        str_table = self.lhs.to_str_table(include_const_term=False)
+        str_table = self.lhs.to_str_create_prefix(str_table)
         rhs = self.lhs.constant_terms.with_columns(pl.col(COEF_KEY) * -1)
-        rhs = cast_coef_to_string(rhs, drop_ones=False, float_precision=float_precision)
+        rhs = cast_coef_to_string(rhs, drop_ones=False)
         # Remove leading +
         rhs = rhs.with_columns(pl.col(COEF_KEY).str.strip_chars(characters=" +"))
         rhs = rhs.rename({COEF_KEY: "rhs"})
@@ -1132,7 +1381,7 @@ class Constraint(ModelElementWithId):
                 terms=len(self.lhs.data),
             )
             + "\n"
-            + self.to_str(max_line_len=80, max_rows=15)
+            + self.to_str()
         )
 
 
@@ -1141,39 +1390,53 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
     Represents one or many decision variable in an optimization model.
 
     Parameters:
-        *indexing_sets: SetTypes (typically a DataFrame or Set)
+        *indexing_sets:
             If no indexing_sets are provided, a single variable with no dimensions is created.
             Otherwise, a variable is created for each element in the Cartesian product of the indexing_sets (see Set for details on behaviour).
-        lb: float
+        lb:
             The lower bound for all variables.
-        ub: float
+        ub:
             The upper bound for all variables.
-        vtype: VType | VTypeValue
+        vtype:
             The type of the variable. Can be either a VType enum or a string. Default is VType.CONTINUOUS.
-        equals: SupportsToExpr
+        equals:
             When specified, a variable is created and a constraint is added to make the variable equal to the provided expression.
 
     Examples:
         >>> import pandas as pd
-        >>> from pyoframe import Variable
+        >>> m = pf.Model()
         >>> df = pd.DataFrame({"dim1": [1, 1, 2, 2, 3, 3], "dim2": ["a", "b", "a", "b", "a", "b"]})
-        >>> Variable(df)
-        <Variable lb=-inf ub=inf size=6 dimensions={'dim1': 3, 'dim2': 2}>
-        [1,a]: x1
-        [1,b]: x2
-        [2,a]: x3
-        [2,b]: x4
-        [3,a]: x5
-        [3,b]: x6
-        >>> Variable(df[["dim1"]])
+        >>> v = Variable(df)
+        >>> v
+        <Variable size=6 dimensions={'dim1': 3, 'dim2': 2} added_to_model=False>
+
+        Variables cannot be used until they're added to the model.
+
+        >>> m.constraint = v <= 3
+        Traceback (most recent call last):
+        ...
+        ValueError: Cannot use 'Variable' before it has beed added to a model.
+        >>> m.v = v
+        >>> m.constraint = m.v <= 3
+
+        >>> m.v
+        <Variable name=v size=6 dimensions={'dim1': 3, 'dim2': 2}>
+        [1,a]: v[1,a]
+        [1,b]: v[1,b]
+        [2,a]: v[2,a]
+        [2,b]: v[2,b]
+        [3,a]: v[3,a]
+        [3,b]: v[3,b]
+        >>> m.v2 = Variable(df[["dim1"]])
         Traceback (most recent call last):
         ...
         ValueError: Duplicate rows found in input data.
-        >>> Variable(df[["dim1"]].drop_duplicates())
-        <Variable lb=-inf ub=inf size=3 dimensions={'dim1': 3}>
-        [1]: x7
-        [2]: x8
-        [3]: x9
+        >>> m.v3 = Variable(df[["dim1"]].drop_duplicates())
+        >>> m.v3
+        <Variable name=v3 size=3 dimensions={'dim1': 3}>
+        [1]: v3[1]
+        [2]: v3[2]
+        [3]: v3[3]
     """
 
     # TODO: Breaking change, remove support for Iterable[AcceptableSets]
@@ -1185,10 +1448,6 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         vtype: VType | VTypeValue = VType.CONTINUOUS,
         equals: Optional[SupportsMath] = None,
     ):
-        if lb is None:
-            lb = float("-inf")
-        if ub is None:
-            ub = float("inf")
         if equals is not None:
             assert (
                 len(indexing_sets) == 0
@@ -1199,28 +1458,106 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         super().__init__(data)
 
         self.vtype: VType = VType(vtype)
+        self.attr = Container(self._set_attribute, self._get_attribute)
         self._equals = equals
 
-        # Tightening the bounds is not strictly necessary, but it adds clarity
-        if self.vtype == VType.BINARY:
-            lb, ub = 0, 1
+        if lb is not None and not isinstance(lb, (float, int)):
+            self._lb_expr, self.lb = lb, None
+        else:
+            self._lb_expr, self.lb = None, lb
+        if ub is not None and not isinstance(ub, (float, int)):
+            self._ub_expr, self.ub = ub, None
+        else:
+            self._ub_expr, self.ub = None, ub
+
+    def _set_attribute(self, name, value):
+        self._assert_has_ids()
+        col_name = name
+        try:
+            name = poi.VariableAttribute[name]
+            setter = self._model.poi.set_variable_attribute
+        except KeyError:
+            setter = self._model.poi.set_variable_raw_attribute
 
-        if isinstance(lb, (float, int)):
-            self.lb, self.lb_constraint = lb, None
+        if self.dimensions is None:
+            for key in self.data.get_column(VAR_KEY):
+                setter(poi.VariableIndex(key), name, value)
         else:
-            self.lb, self.lb_constraint = float("-inf"), lb <= self
+            for key, v in (
+                self.data.join(value, on=self.dimensions, how="inner")
+                .select(pl.col(VAR_KEY), pl.col(col_name))
+                .iter_rows()
+            ):
+                setter(poi.VariableIndex(key), name, v)
 
-        if isinstance(ub, (float, int)):
-            self.ub, self.ub_constraint = ub, None
+    @unwrap_single_values
+    def _get_attribute(self, name):
+        self._assert_has_ids()
+        col_name = name
+        try:
+            name = poi.VariableAttribute[name]
+            getter = self._model.poi.get_variable_attribute
+        except KeyError:
+            getter = self._model.poi.get_variable_raw_attribute
+
+        with (
+            warnings.catch_warnings()
+        ):  # map_elements without return_dtype= gives a warning
+            warnings.filterwarnings(
+                action="ignore", category=pl.exceptions.MapWithoutReturnDtypeWarning
+            )
+            return self.data.with_columns(
+                pl.col(VAR_KEY)
+                .map_elements(lambda v_id: getter(poi.VariableIndex(v_id), name))
+                .alias(col_name)
+            ).select(self.dimensions_unsafe + [col_name])
+
+    def _assign_ids(self):
+        kwargs = dict(domain=self.vtype.to_poi())
+        if self.lb is not None:
+            kwargs["lb"] = self.lb
+        if self.ub is not None:
+            kwargs["ub"] = self.ub
+
+        if self.dimensions is not None and self._model.use_var_names:
+            df = (
+                concat_dimensions(self.data, prefix=self.name)
+                .with_columns(
+                    pl.col("concated_dim")
+                    .map_elements(
+                        lambda name: self._model.poi.add_variable(
+                            name=name, **kwargs
+                        ).index,
+                        return_dtype=KEY_TYPE,
+                    )
+                    .alias(VAR_KEY)
+                )
+                .drop("concated_dim")
+            )
         else:
-            self.ub, self.ub_constraint = float("inf"), self <= ub
+            if self._model.use_var_names:
+                kwargs["name"] = self.name
+
+            df = self.data.with_columns(
+                pl.lit(0).alias(VAR_KEY).cast(KEY_TYPE)
+            ).with_columns(
+                pl.col(VAR_KEY).map_elements(
+                    lambda _: self._model.poi.add_variable(**kwargs).index,
+                    return_dtype=KEY_TYPE,
+                )
+            )
 
-    def on_add_to_model(self, model: "Model", name: str):
+        self._data = df
+
+    def on_add_to_model(self, model, name):
         super().on_add_to_model(model, name)
-        if self.lb_constraint is not None:
-            setattr(model, f"{name}_lb", self.lb_constraint)
-        if self.ub_constraint is not None:
-            setattr(model, f"{name}_ub", self.ub_constraint)
+        self._assign_ids()
+        if self._lb_expr is not None:
+            setattr(model, f"{name}_lb", self._lb_expr <= self)
+
+        if self._ub_expr is not None:
+            setattr(model, f"{name}_ub", self <= self._ub_expr)
+
         if self._equals is not None:
             setattr(model, f"{name}_equals", self == self._equals)
 
@@ -1231,52 +1568,41 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
     @property
     @unwrap_single_values
     def solution(self):
-        if SOLUTION_KEY not in self.data.columns:
-            raise ValueError(f"No solution solution found for Variable '{self.name}'.")
-
-        return self.data.select(self.dimensions_unsafe + [SOLUTION_KEY])
-
-    @property
-    @unwrap_single_values
-    def RC(self):
-        """
-        The reduced cost of the variable.
-        Will raise an error if the model has not already been solved.
-        The first call to this property will load the reduced costs from the solver (lazy loading).
-        """
-        if RC_COL not in self.data.columns:
-            assert (
-                self._model is not None
-            ), "Variable must be added to a model to get the reduced cost."
-            if self._model.solver is None:
-                raise ValueError("The model has not been solved yet.")
-            self._model.solver.load_rc()
-        return self.data.select(self.dimensions_unsafe + [RC_COL])
-
-    @RC.setter
-    def RC(self, value):
-        self._extend_dataframe_by_id(value)
-
-    @solution.setter
-    def solution(self, value):
-        self._extend_dataframe_by_id(value)
+        solution = self.attr.Value
+        if isinstance(solution, pl.DataFrame):
+            solution = solution.rename({"Value": SOLUTION_KEY})
+        return solution
 
     def __repr__(self):
-        return (
-            get_obj_repr(
-                self, ("name", "lb", "ub"), size=self.data.height, dimensions=self.shape
+        if self._has_ids:
+            return (
+                get_obj_repr(
+                    self,
+                    ("name", "lb", "ub"),
+                    size=self.data.height,
+                    dimensions=self.shape,
+                )
+                + "\n"
+                + self.to_expr().to_str()
+            )
+        else:
+            return get_obj_repr(
+                self,
+                ("name", "lb", "ub"),
+                size=self.data.height,
+                dimensions=self.shape,
+                added_to_model=False,
             )
-            + "\n"
-            + self.to_expr().to_str(max_line_len=80, max_rows=10)
-        )
 
     def to_expr(self) -> Expression:
+        self._assert_has_ids()
         if POLARS_VERSION.major < 1:
             return self._new(self.data.drop(SOLUTION_KEY))
         else:
             return self._new(self.data.drop(SOLUTION_KEY, strict=False))
 
     def _new(self, data: pl.DataFrame):
+        self._assert_has_ids()
         e = Expression(data.with_columns(pl.lit(1.0).alias(COEF_KEY)))
         e._model = self._model
         # We propogate the unmatched strategy intentionally. Without this a .keep_unmatched() on a variable would always be lost.
@@ -1296,12 +1622,11 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
 
         Examples:
             >>> import pandas as pd
-            >>> from pyoframe import Variable, Model
             >>> time_dim = pd.DataFrame({"time": ["00:00", "06:00", "12:00", "18:00"]})
             >>> space_dim = pd.DataFrame({"city": ["Toronto", "Berlin"]})
-            >>> m = Model("min")
-            >>> m.bat_charge = Variable(time_dim, space_dim)
-            >>> m.bat_flow = Variable(time_dim, space_dim)
+            >>> m = pf.Model()
+            >>> m.bat_charge = pf.Variable(time_dim, space_dim)
+            >>> m.bat_flow = pf.Variable(time_dim, space_dim)
             >>> # Fails because the dimensions are not the same
             >>> m.bat_charge + m.bat_flow == m.bat_charge.next("time")
             Traceback (most recent call last):