feat: allow multiplication by constant to introduce new dimensions

Fixes #411

Author: coroa

doc/release_notes.rst

@@ -5,6 +5,7 @@ Upcoming Version
 ----------------
 
 * The internal handling of `Solution` objects was improved for more consistency. Solution objects created from solver calls now preserve the exact index names from the input file.
+* Multiplication of a linear expression by a constant value may now introduce new dimensions.
 
 Version 0.4.4
 --------------

linopy/expressions.py

@@ -448,9 +448,9 @@ def __repr__(self) -> str:
             expr = print_single_expression(
                 self.coeffs, self.vars, self.const, self.model
             )
-            lines.append(f"{header_string}\n{'-'*len(header_string)}\n{expr}")
+            lines.append(f"{header_string}\n{'-' * len(header_string)}\n{expr}")
         else:
-            lines.append(f"{header_string}\n{'-'*len(header_string)}\n<empty>")
+            lines.append(f"{header_string}\n{'-' * len(header_string)}\n<empty>")
 
         return "\n".join(lines)
 
@@ -555,7 +555,7 @@ def _multiply_by_linear_expression(
     def _multiply_by_constant(self, other: int | float | DataArray) -> LinearExpression:
         multiplier = as_dataarray(other, coords=self.coords, dims=self.coord_dims)
         coeffs = self.coeffs * multiplier
-        assert set(coeffs.shape) == set(self.coeffs.shape)
+        assert all(coeffs.sizes[d] == s for d, s in self.coeffs.sizes.items())
         const = self.const * multiplier
         return self.assign(coeffs=coeffs, const=const)
 
@@ -1875,7 +1875,7 @@ def __add__(
             return ScalarLinearExpression(coeffs, vars, self.model)
         elif not isinstance(other, ScalarLinearExpression):
             raise TypeError(
-                "unsupported operand type(s) for +: " f"{type(self)} and {type(other)}"
+                f"unsupported operand type(s) for +: {type(self)} and {type(other)}"
             )
 
         coeffs = self.coeffs + other.coeffs
@@ -1901,7 +1901,7 @@ def __sub__(
             other = other.to_scalar_linexpr(1)
         elif not isinstance(other, ScalarLinearExpression):
             raise TypeError(
-                "unsupported operand type(s) for -: " f"{type(self)} and {type(other)}"
+                f"unsupported operand type(s) for -: {type(self)} and {type(other)}"
             )
 
         return ScalarLinearExpression(
@@ -1918,7 +1918,7 @@ def __neg__(self) -> ScalarLinearExpression:
     def __mul__(self, other: float | int) -> ScalarLinearExpression:
         if not isinstance(other, (int, float, np.number)):
             raise TypeError(
-                "unsupported operand type(s) for *: " f"{type(self)} and {type(other)}"
+                f"unsupported operand type(s) for *: {type(self)} and {type(other)}"
             )
 
         return ScalarLinearExpression(
@@ -1931,7 +1931,7 @@ def __rmul__(self, other: int) -> ScalarLinearExpression:
     def __div__(self, other: float | int) -> ScalarLinearExpression:
         if not isinstance(other, (int, float, np.number)):
             raise TypeError(
-                "unsupported operand type(s) for /: " f"{type(self)} and {type(other)}"
+                f"unsupported operand type(s) for /: {type(self)} and {type(other)}"
             )
         return self.__mul__(1 / other)
 
@@ -1941,23 +1941,23 @@ def __truediv__(self, other: float | int) -> ScalarLinearExpression:
     def __le__(self, other: int | float) -> AnonymousScalarConstraint:
         if not isinstance(other, (int, float, np.number)):
             raise TypeError(
-                "unsupported operand type(s) for <=: " f"{type(self)} and {type(other)}"
+                f"unsupported operand type(s) for <=: {type(self)} and {type(other)}"
             )
 
         return constraints.AnonymousScalarConstraint(self, LESS_EQUAL, other)
 
     def __ge__(self, other: int | float) -> AnonymousScalarConstraint:
         if not isinstance(other, (int, float, np.number)):
             raise TypeError(
-                "unsupported operand type(s) for >=: " f"{type(self)} and {type(other)}"
+                f"unsupported operand type(s) for >=: {type(self)} and {type(other)}"
             )
 
         return constraints.AnonymousScalarConstraint(self, GREATER_EQUAL, other)
 
     def __eq__(self, other: int | float) -> AnonymousScalarConstraint:  # type: ignore
         if not isinstance(other, (int, float, np.number)):
             raise TypeError(
-                "unsupported operand type(s) for ==: " f"{type(self)} and {type(other)}"
+                f"unsupported operand type(s) for ==: {type(self)} and {type(other)}"
             )
 
         return constraints.AnonymousScalarConstraint(self, EQUAL, other)