Merge branch 'master' into feature/auto-masking1

Author: FabianHofmann

doc/release_notes.rst

@@ -4,9 +4,15 @@ Release Notes
 Upcoming Version
 ----------------
 
+* Fix docs (pick highs solver)
 * Add the `sphinx-copybutton` to the documentation
 * Add ``auto_mask`` parameter to ``Model`` class that automatically masks variables and constraints where bounds, coefficients, or RHS values contain NaN. This eliminates the need to manually create mask arrays when working with sparse or incomplete data.
 
+Upcoming Version
+----------------
+
+* Fix multiplication of constant-only ``LinearExpression`` with other expressions
+
 Version 0.6.1
 --------------
 

examples/create-a-model-with-coordinates.ipynb

@@ -150,7 +150,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "m.solve()"
+    "m.solve(solver_name=\"highs\")"
    ]
   },
   {

examples/create-a-model.ipynb

@@ -215,7 +215,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "m.solve()"
+    "m.solve(solver_name=\"highs\")"
    ]
   },
   {

examples/manipulating-models.ipynb

@@ -48,9 +48,9 @@
     "con2 = m.add_constraints(5 * x + 2 * y >= 3 * factor, name=\"con2\")\n",
     "\n",
     "m.add_objective(x + 2 * y)\n",
-    "m.solve()\n",
+    "m.solve(solver_name=\"highs\")\n",
     "\n",
-    "m.solve()\n",
+    "m.solve(solver_name=\"highs\")\n",
     "sol = m.solution.to_dataframe()\n",
     "sol.plot(grid=True, ylabel=\"Optimal Value\")"
    ]
@@ -95,7 +95,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "m.solve()\n",
+    "m.solve(solver_name=\"highs\")\n",
     "sol = m.solution.to_dataframe()\n",
     "sol.plot(grid=True, ylabel=\"Optimal Value\")"
    ]
@@ -137,7 +137,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "m.solve()\n",
+    "m.solve(solver_name=\"highs\")\n",
     "sol = m.solution.to_dataframe()\n",
     "sol.plot(grid=True, ylabel=\"Optimal Value\")"
    ]
@@ -190,7 +190,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "m.solve()\n",
+    "m.solve(solver_name=\"highs\")\n",
     "sol = m.solution.to_dataframe()\n",
     "sol.plot(grid=True, ylabel=\"Optimal Value\")"
    ]
@@ -242,7 +242,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "m.solve()\n",
+    "m.solve(solver_name=\"highs\")\n",
     "sol = m.solution.to_dataframe()\n",
     "sol.plot(grid=True, ylabel=\"Optimal Value\")"
    ]
@@ -276,7 +276,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "m.solve()\n",
+    "m.solve(solver_name=\"highs\")\n",
     "sol = m.solution.to_dataframe()\n",
     "sol.plot(grid=True, ylabel=\"Optimal Value\")"
    ]

examples/solve-on-oetc.ipynb

@@ -169,7 +169,7 @@
     "start_time = time.time()\n",
     "\n",
     "try:\n",
-    "    status, termination_condition = m.solve(remote=oetc_handler)\n",
+    "    status, termination_condition = m.solve(remote=oetc_handler, solver_name=\"highs\")\n",
     "\n",
     "    end_time = time.time()\n",
     "    total_time = end_time - start_time\n",

examples/transport-tutorial.ipynb

@@ -407,7 +407,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In the `solve()` function, you can specify a `solver_name`. The default solver, however, will be the first from the list we printed above."
+    "In the `solve()` function, you can specify a `solver_name`. The default solver, however, will be the first from the list we printed above. In this example, we will specify a solver explicitly to avoid licensing issues."
    ]
   },
   {
@@ -417,7 +417,7 @@
    "outputs": [],
    "source": [
     "# Solve the model\n",
-    "m.solve()"
+    "m.solve(solver_name=\"highs\")"
    ]
   },
   {

linopy/expressions.py

@@ -13,7 +13,7 @@
 from collections.abc import Callable, Hashable, Iterator, Mapping, Sequence
 from dataclasses import dataclass, field
 from itertools import product, zip_longest
-from typing import TYPE_CHECKING, Any, TypeVar, overload
+from typing import TYPE_CHECKING, Any, TypeVar, cast, overload
 from warnings import warn
 
 import numpy as np
@@ -507,12 +507,18 @@ def __neg__(self: GenericExpression) -> GenericExpression:
 
     def _multiply_by_linear_expression(
         self, other: LinearExpression | ScalarLinearExpression
-    ) -> QuadraticExpression:
+    ) -> LinearExpression | QuadraticExpression:
         if isinstance(other, ScalarLinearExpression):
             other = other.to_linexpr()
 
         if other.nterm > 1:
             raise TypeError("Multiplication of multiple terms is not supported.")
+
+        if other.is_constant:
+            return cast(LinearExpression, self._multiply_by_constant(other.const))
+        if self.is_constant:
+            return cast(LinearExpression, other._multiply_by_constant(self.const))
+
         # multiplication: (v1 + c1) * (v2 + c2) = v1 * v2 + c1 * v2 + c2 * v1 + c1 * c2
         # with v being the variables and c the constants
         # merge on factor dimension only returns v1 * v2 + c1 * c2

linopy/variables.py

@@ -14,6 +14,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    cast,
     overload,
 )
 from warnings import warn
@@ -420,7 +421,9 @@ def __pow__(self, other: int) -> QuadraticExpression:
             return NotImplemented
         if other == 2:
             expr = self.to_linexpr()
-            return expr._multiply_by_linear_expression(expr)
+            return cast(
+                "QuadraticExpression", expr._multiply_by_linear_expression(expr)
+            )
         raise ValueError("Can only raise to the power of 2")
 
     @overload

test/test_linear_expression.py

@@ -1313,3 +1313,89 @@ def test_simplify_partial_cancellation(x: Variable, y: Variable) -> None:
     assert all(simplified.coeffs.values == 3.0), (
         f"Expected coefficient 3.0, got {simplified.coeffs.values}"
     )
+
+
+def test_constant_only_expression_mul_dataarray(m: Model) -> None:
+    const_arr = xr.DataArray([2, 3], dims=["dim_0"])
+    const_expr = LinearExpression(const_arr, m)
+    assert const_expr.is_constant
+    assert const_expr.nterm == 0
+
+    data_arr = xr.DataArray([10, 20], dims=["dim_0"])
+    expected_const = const_arr * data_arr
+
+    result = const_expr * data_arr
+    assert isinstance(result, LinearExpression)
+    assert result.is_constant
+    assert (result.const == expected_const).all()
+
+    result_rev = data_arr * const_expr
+    assert isinstance(result_rev, LinearExpression)
+    assert result_rev.is_constant
+    assert (result_rev.const == expected_const).all()
+
+
+def test_constant_only_expression_mul_linexpr_with_vars(m: Model, x: Variable) -> None:
+    const_arr = xr.DataArray([2, 3], dims=["dim_0"])
+    const_expr = LinearExpression(const_arr, m)
+    assert const_expr.is_constant
+    assert const_expr.nterm == 0
+
+    expr_with_vars = 1 * x + 5
+    expected_coeffs = const_arr
+    expected_const = const_arr * 5
+
+    result = const_expr * expr_with_vars
+    assert isinstance(result, LinearExpression)
+    assert (result.coeffs == expected_coeffs).all()
+    assert (result.const == expected_const).all()
+
+    result_rev = expr_with_vars * const_expr
+    assert isinstance(result_rev, LinearExpression)
+    assert (result_rev.coeffs == expected_coeffs).all()
+    assert (result_rev.const == expected_const).all()
+
+
+def test_constant_only_expression_mul_constant_only(m: Model) -> None:
+    const_arr = xr.DataArray([2, 3], dims=["dim_0"])
+    const_arr2 = xr.DataArray([4, 5], dims=["dim_0"])
+    const_expr = LinearExpression(const_arr, m)
+    const_expr2 = LinearExpression(const_arr2, m)
+    assert const_expr.is_constant
+    assert const_expr2.is_constant
+
+    expected_const = const_arr * const_arr2
+
+    result = const_expr * const_expr2
+    assert isinstance(result, LinearExpression)
+    assert result.is_constant
+    assert (result.const == expected_const).all()
+
+    result_rev = const_expr2 * const_expr
+    assert isinstance(result_rev, LinearExpression)
+    assert result_rev.is_constant
+    assert (result_rev.const == expected_const).all()
+
+
+def test_constant_only_expression_mul_linexpr_with_vars_and_const(
+    m: Model, x: Variable
+) -> None:
+    const_arr = xr.DataArray([2, 3], dims=["dim_0"])
+    const_expr = LinearExpression(const_arr, m)
+    assert const_expr.is_constant
+
+    expr_with_vars_and_const = 4 * x + 10
+    expected_coeffs = const_arr * 4
+    expected_const = const_arr * 10
+
+    result = const_expr * expr_with_vars_and_const
+    assert isinstance(result, LinearExpression)
+    assert not result.is_constant
+    assert (result.coeffs == expected_coeffs).all()
+    assert (result.const == expected_const).all()
+
+    result_rev = expr_with_vars_and_const * const_expr
+    assert isinstance(result_rev, LinearExpression)
+    assert not result_rev.is_constant
+    assert (result_rev.coeffs == expected_coeffs).all()
+    assert (result_rev.const == expected_const).all()