Scipy interface

.github/workflows/unopy-test-example.yml

@@ -43,8 +43,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
           architecture: ${{ matrix.architecture }}
 
-      - name: Install pybind11 on Linux
-        if: runner.os == 'Linux'
+      - name: Install pybind11
         run: sudo apt install -y python3-pybind11 pybind11-dev
 
       - name: Download dependencies
@@ -55,4 +54,4 @@ jobs:
 
       - name: Run example
         working-directory: ${{github.workspace}}/interfaces/Python/example
-        run: python example_hs015.py
+        run: python example_hs015.py

.github/workflows/unopy-tests-gemseo.yml

@@ -0,0 +1,59 @@
+name: Test unopy via GEMSEO interface
+
+on:
+  push:
+    branches: [ "main" ]
+    paths-ignore:
+      - '*.md'
+      - 'LICENSE'
+      - '*.cff'
+      - '*.yml'
+      - '*.yaml'
+      - 'docs/**'
+  pull_request:
+    branches: [ "main" ]
+    paths-ignore:
+      - '*.md'
+      - 'LICENSE'
+      - '*.cff'
+      - '*.yml'
+      - '*.yaml'
+      - 'docs/**'
+
+env:
+  BUILD_TYPE: Debug
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        architecture: [x64]
+        python-version: ["3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        # This is the version of the action for setting up Python, not the Python version.
+        uses: actions/setup-python@v5
+        with:
+          # Semantic version range syntax or exact version of a Python version
+          python-version: ${{ matrix.python-version }}
+          architecture: ${{ matrix.architecture }}
+
+      - name: Install pybind11
+        run: sudo apt install -y python3-pybind11 pybind11-dev
+
+      - name: Install pytest, gemseo, and scipy
+        run: pip install pytest gemseo scipy
+
+      - name: Download dependencies
+        run: bash dependencies/scripts/download_dependencies.sh
+
+      - name: Compile and install unopy
+        run: CMAKE_BUILD_PARALLEL_LEVEL=$(nproc) pip install . -v
+
+      - name: Run tests
+        run: python -m pytest -s --import-mode=importlib ${{github.workspace}}/interfaces/Python/gemseo_uno/test_gemseo_uno.py

.github/workflows/unopy-tests-scipy.yml

@@ -0,0 +1,59 @@
+name: Test unopy via Scipy interface
+
+on:
+  push:
+    branches: [ "main" ]
+    paths-ignore:
+      - '*.md'
+      - 'LICENSE'
+      - '*.cff'
+      - '*.yml'
+      - '*.yaml'
+      - 'docs/**'
+  pull_request:
+    branches: [ "main" ]
+    paths-ignore:
+      - '*.md'
+      - 'LICENSE'
+      - '*.cff'
+      - '*.yml'
+      - '*.yaml'
+      - 'docs/**'
+
+env:
+  BUILD_TYPE: Debug
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        architecture: [x64]
+        python-version: ["3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        # This is the version of the action for setting up Python, not the Python version.
+        uses: actions/setup-python@v5
+        with:
+          # Semantic version range syntax or exact version of a Python version
+          python-version: ${{ matrix.python-version }}
+          architecture: ${{ matrix.architecture }}
+
+      - name: Install pybind11
+        run: sudo apt install -y python3-pybind11 pybind11-dev
+
+      - name: Install pytest and scipy
+        run: pip install pytest scipy
+
+      - name: Download dependencies
+        run: bash dependencies/scripts/download_dependencies.sh
+
+      - name: Compile and install unopy
+        run: CMAKE_BUILD_PARALLEL_LEVEL=$(nproc) pip install . -v
+
+      - name: Run tests
+        run: python -m pytest --import-mode=importlib ${{github.workspace}}/interfaces/Python/scipy_interface/test_scipy_interface.py

CMakeLists.txt

@@ -425,6 +425,9 @@ if(SKBUILD)
       target_compile_definitions(unopy PRIVATE PYBIND11_DETAILED_ERROR_MESSAGES)
    endif()
 
+   install(DIRECTORY interfaces/Python/unopy/ DESTINATION unopy)
+   install(DIRECTORY interfaces/Python/scipy_interface/ DESTINATION scipy_interface)
+   install(DIRECTORY interfaces/Python/gemseo_uno/ DESTINATION gemseo_uno)
    install(TARGETS unopy
            LIBRARY DESTINATION unopy    # Linux/macOS: unopy/unopy.so
            RUNTIME DESTINATION unopy    # Windows: unopy/unopy.pyd

interfaces/AMPL/AMPLModel.cpp

@@ -200,7 +200,7 @@ namespace uno {
       fint error_flag = 0;
       this->asl->p.Jacval(this->asl, const_cast<double*>(x.data()), jacobian_values, &error_flag);
       if (0 < error_flag) {
-         throw GradientEvaluationError();
+         throw JacobianEvaluationError();
       }
       ++this->number_model_evaluations.jacobian;
    }

interfaces/C/Uno_C_API.cpp

@@ -152,7 +152,7 @@ class UnoModel: public Model {
          const uno_int return_code = this->user_model.jacobian(this->user_model.number_variables,
             this->user_model.number_jacobian_nonzeros, x.data(), jacobian_values, this->user_model.user_data);
          if (0 < return_code) {
-            throw GradientEvaluationError();
+            throw JacobianEvaluationError();
          }
          ++this->number_model_evaluations.jacobian;
       }
@@ -189,7 +189,7 @@ class UnoModel: public Model {
          const uno_int return_code = this->user_model.jacobian_operator(this->user_model.number_variables,
             this->user_model.number_constraints, x, true, vector, result, this->user_model.user_data);
          if (0 < return_code) {
-            throw GradientEvaluationError();
+            throw JacobianEvaluationError();
          }
       }
       else {
@@ -202,7 +202,7 @@ class UnoModel: public Model {
          const uno_int return_code = this->user_model.jacobian_transposed_operator(this->user_model.number_variables,
             this->user_model.number_constraints, x, true, vector, result, this->user_model.user_data);
          if (0 < return_code) {
-            throw GradientEvaluationError();
+            throw JacobianEvaluationError();
          }
       }
       else {
@@ -1265,4 +1265,4 @@ void uno_destroy_solver(void* solver) {
       }
       delete uno_solver;
    }
-}
+}

interfaces/Python/cpp_classes/PythonModel.cpp

@@ -142,7 +142,7 @@ namespace uno {
             ++this->number_model_evaluations.jacobian;
          }
          catch (const std::exception&) {
-            throw GradientEvaluationError();
+            throw JacobianEvaluationError();
          }
       }
    }
@@ -192,7 +192,7 @@ namespace uno {
             (*this->user_model.jacobian_operator)(x_py, true, vector_py, result_py);
          }
          catch (const std::exception&) {
-            throw GradientEvaluationError();
+            throw JacobianEvaluationError();
          }
       }
       else {
@@ -211,7 +211,7 @@ namespace uno {
             (*this->user_model.jacobian_transposed_operator)(x_py, true, vector_py, result_py);
          }
          catch (const std::exception&) {
-            throw GradientEvaluationError();
+            throw JacobianEvaluationError();
          }
       }
       else {

interfaces/Python/example/example_hs015.py

@@ -2,6 +2,7 @@
 # Licensed under the MIT license. See LICENSE file in the project directory for details.
 
 import unopy
+
 Inf = float("inf")
 
 # hs015.mod

interfaces/Python/gemseo_uno/gemseo_uno.py

@@ -0,0 +1,147 @@
+# Copyright 2021 IRT Saint Exupéry, https://www.irt-saintexupery.com
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 3 as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+# Contributors:
+#    INITIAL AUTHORS - initial API and implementation and/or initial
+#                           documentation
+#        :author: François Gallard
+#    OTHER AUTHORS   - MACROSCOPIC CHANGES
+"""The library of Uno constrained gradient-based optimization algorithms."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from typing import ClassVar
+from typing import TYPE_CHECKING
+
+from gemseo.algos.design_space_utils import get_value_and_bounds
+from gemseo.algos.opt.base_optimization_library import (
+    OptimizationAlgorithmDescription,
+    BaseOptimizationLibrary,
+)
+from numpy import isfinite
+from numpy import real
+
+from gemseo_uno.settings.base_uno_settings import UNO_Settings
+from scipy_interface.scipy_uno import minimize
+
+if TYPE_CHECKING:
+    from gemseo.algos.optimization_problem import OptimizationProblem
+
+
+@dataclass
+class UnoAlgorithmDescription(OptimizationAlgorithmDescription):
+    """The description of the Uno constrained grdient based optimization library."""
+
+    library_name: str = "Uno"
+    """The library name."""
+
+    handle_equality_constraints: bool = True
+    """Whether the optimization algorithm handles equality constraints."""
+
+    handle_inequality_constraints: bool = True
+    """Whether the optimization algorithm handles inequality constraints."""
+
+    positive_constraints: bool = True
+    """Whether the optimization algorithm requires positive constraints."""
+
+    require_gradient: bool = True
+    """Whether the optimization algorithm requires the gradient."""
+
+    Settings: type[UNO_Settings] = UNO_Settings
+    """The option validation model for Uno optimization library."""
+
+    website: str = "https://unosolver.readthedocs.io/en/latest/"
+    """The website of the wrapped library or algorithm."""
+
+
+class UnoOpt(BaseOptimizationLibrary[UNO_Settings]):
+    """The library of Uno optimization algorithms."""
+
+    ALGORITHM_INFOS: ClassVar[dict[str, UnoAlgorithmDescription]] = {
+        "UNO_Filter_SQP": UnoAlgorithmDescription(
+            algorithm_name="UNO_Filter_SQP",
+            description=(
+                "Sequential Quadratic Programming (SQP) "
+                "implemented in the Uno library"
+            ),
+            internal_algorithm_name="filtersqp",
+            Settings=UNO_Settings,
+        ),
+        "UNO_Filter_SLP": UnoAlgorithmDescription(
+            algorithm_name="UNO_Filter_SLP",
+            description=(
+                "Sequential Linear Programming (SLP) " "implemented in the Uno library"
+            ),
+            internal_algorithm_name="filterslp",
+            Settings=UNO_Settings,
+        ),
+        "UNO_Funnel_SQP": UnoAlgorithmDescription(
+            algorithm_name="UNO_Funnel_SQP",
+            description=(
+                "Funnel Sequential Quadratic Programming (SQP)"
+                "implemented in the Uno library"
+            ),
+            internal_algorithm_name="funnelsqp",
+            Settings=UNO_Settings,
+        ),
+        "UNO_IPOPT": UnoAlgorithmDescription(
+            algorithm_name="UNO_IPOPT",
+            description=(
+                "Interior Point Optimization (IPOPT)" "implemented in the Uno library"
+            ),
+            internal_algorithm_name="ipopt",
+            Settings=UNO_Settings,
+        ),
+    }
+
+    def _run(self, problem: OptimizationProblem) -> tuple[str, Any]:
+        # Get the normalized bounds:
+        x_0, l_b, u_b = get_value_and_bounds(
+            problem.design_space, self._settings.normalize_design_space
+        )
+        # Replace infinite values with None:
+        l_b = [val if isfinite(val) else None for val in l_b]
+        u_b = [val if isfinite(val) else None for val in u_b]
+        bounds = list(zip(l_b, u_b, strict=False))
+
+        # Get constraint in SciPy format
+        scipy_constraints = [
+            {
+                "type": constraint.f_type,
+                "fun": constraint.evaluate,
+                "jac": constraint.jac,
+            }
+            for constraint in self._get_right_sign_constraints(problem)
+        ]
+
+        # Filter settings to get only the uno ones
+        settings_ = self._filter_settings(self._settings.model_dump(), UNO_Settings)
+
+        # Deactivate stopping criteria which are handled by GEMSEO
+        tolerance = 0.0
+
+        opt_result = minimize(
+            fun=lambda x: real(problem.objective.evaluate(x)),
+            jac=problem.objective.jac,
+            x0=x_0,
+            method=self.ALGORITHM_INFOS[self._algo_name].internal_algorithm_name,
+            bounds=bounds,
+            constraints=scipy_constraints,
+            options=settings_,
+            tol=tolerance,
+        )
+
+        return opt_result.message, opt_result.status