eiquadprog

https://github.com/stack-of-tasks/eiquadprog
Admin
eiquadprog is a C++ library providing implementations of the Goldfarb and Idnani algorithm for...
Tokens:6,387
Snippets:33
Trust Score:9.7
License:GPL-3.0
Update:6 months ago
Show doc for...
Tokens:
Raw
### Add Definitions for Boost Tests

Source: https://github.com/stack-of-tasks/eiquadprog/blob/devel/tests/CMakeLists.txt

Adds definitions for dynamic linking and main function for Boost unit tests. Ensure Boost is installed and configured.

```cmake
add_definitions(-DBOOST_TEST_DYN_LINK -DBOOST_TEST_MAIN)
```

--------------------------------

### CMake Integration: find_package

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Integrate eiquadprog into a CMake project using `find_package`. This assumes eiquadprog is already installed on the system.

```cmake
# CMakeLists.txt - Option 1: Using find_package (if installed)
cmake_minimum_required(VERSION 3.14)
project(my_qp_project)

find_package(eiquadprog REQUIRED)
find_package(Eigen3 REQUIRED)

add_executable(my_solver main.cpp)
target_link_libraries(my_solver
    PRIVATE
    eiquadprog::eiquadprog
    Eigen3::Eigen
)
```

--------------------------------

### Solve a Quadratic Programming Problem with RtEiquadprog

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Demonstrates setting up and solving a fixed-size quadratic programming problem using template parameters for dimensions.

```cpp
#include <Eigen/Core>
#include <iostream>
#include "eiquadprog/eiquadprog-rt.hpp"

using namespace eiquadprog::solvers;

int main() {
    // Template parameters: <num_vars, num_eq_constraints, num_ineq_constraints>
    RtEiquadprog<2, 1, 2> qp;

    // Configure solver
    qp.setMaxIter(500);

    // Problem: min ||x||^2
    //     s.t. x[0] + x[1] = 1
    //          x[0] >= 0, x[1] >= 0

    // Use fixed-size Eigen types matching template parameters
    RtMatrixX<2, 2>::d Hess;  // Equivalent to Eigen::Matrix<double, 2, 2>
    Hess.setIdentity();

    RtVectorX<2>::d g0;  // Equivalent to Eigen::Matrix<double, 2, 1>
    g0.setZero();

    // Equality constraint: x[0] + x[1] = 1
    RtMatrixX<1, 2>::d Aeq;  // (num_eq x num_vars)
    Aeq << 1.0, 1.0;

    RtVectorX<1>::d beq;
    beq << -1.0;

    // Inequality constraints: x[0] >= 0, x[1] >= 0
    RtMatrixX<2, 2>::d Aineq;  // (num_ineq x num_vars)
    Aineq.setIdentity();

    RtVectorX<2>::d bineq;
    bineq.setZero();

    RtVectorX<2>::d x;

    // Solve
    RtEiquadprog_status status = qp.solve_quadprog(
        Hess, g0, Aeq, beq, Aineq, bineq, x);

    if (status == RT_EIQUADPROG_OPTIMAL) {
        std::cout << "Solution: x = [" << x.transpose() << "]" << std::endl;
        std::cout << "Cost: " << qp.getObjValue() << std::endl;
        std::cout << "Iterations: " << qp.getIteratios() << std::endl;

        // Access Lagrange multipliers
        const auto& lambda = qp.getLagrangeMultipliers();
        std::cout << "Lagrange multipliers: ["
                  << lambda.head(qp.getActiveSetSize()).transpose() << "]" << std::endl;
    } else {
        std::cout << "Solver failed with status: " << status << std::endl;
    }

    // Expected output:
    // Solution: x = [0.5 0.5]
    // Cost: 0.25
    // Iterations: 1

    return 0;
}
```

--------------------------------

### CMake Integration: FetchContent

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Integrate eiquadprog into a CMake project using `FetchContent`. This downloads and builds eiquadprog as part of your project.

```cmake
# CMakeLists.txt - Option 2: Using FetchContent
cmake_minimum_required(VERSION 3.14)
project(my_qp_project)

include(FetchContent)

FetchContent_Declare(
    eiquadprog
    GIT_REPOSITORY https://github.com/stack-of-tasks/eiquadprog.git
    GIT_TAG master
)
FetchContent_MakeAvailable(eiquadprog)

find_package(Eigen3 REQUIRED)

add_executable(my_solver main.cpp)
target_link_libraries(my_solver
    PRIVATE
    eiquadprog
    Eigen3::Eigen
)
```

--------------------------------

### Handle Infeasible Problem with Basic Solver

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Use the basic `solve_quadprog` function. Infeasible problems result in an infinite cost value.

```cpp
#include <Eigen/Core>
#include <iostream>
#include <cmath>
#include "eiquadprog/eiquadprog.hpp"
#include "eiquadprog/eiquadprog-fast.hpp"

using namespace eiquadprog::solvers;

void test_infeasible_basic() {
    // Infeasible problem: x[0] >= 1 AND x[0] <= -1
    Eigen::MatrixXd G(2, 2);
    G.setIdentity();

    Eigen::VectorXd g0(2);
    g0.setZero();

    Eigen::MatrixXd CE(2, 0);
    Eigen::VectorXd ce0(0);

    // Conflicting constraints
    Eigen::MatrixXd CI(2, 2);
    CI.setZero();
    CI(0, 0) = 1.0;   // x[0] >= 1
    CI(0, 1) = -1.0;  // x[0] <= -1 (i.e., -x[0] >= 1)

    Eigen::VectorXd ci0(2);
    ci0(0) = -1.0;
    ci0(1) = -1.0;

    Eigen::VectorXd x(2);
    Eigen::VectorXi activeSet(2);
    size_t activeSetSize;

    double cost = eiquadprog::solvers::solve_quadprog(
        G, g0, CE, ce0, CI, ci0, x, activeSet, activeSetSize);

    if (std::isinf(cost)) {
        std::cout << "Basic solver: Problem is infeasible (cost = inf)" << std::endl;
    }
}
```

--------------------------------

### Main function demonstrating solver tests

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

This main function calls the test functions for infeasible and redundant equality problems for both basic and fast solvers.

```cpp
int main() {
    test_infeasible_basic();
    test_infeasible_fast();
    test_redundant_equalities();

    // Expected output:
    // Basic solver: Problem is infeasible (cost = inf)
    // Fast solver: Problem failed with status 1
    // Fast solver: Detected redundant/conflicting equalities

    return 0;
}
```

--------------------------------

### Solve QP with Pre-computed Cholesky Decomposition

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Use this overload when solving multiple QP problems with the same Hessian matrix. Pre-computing the Cholesky decomposition avoids redundant calculations. Requires including Eigen/Cholesky and eiquadprog/eiquadprog.hpp.

```cpp
#include <Eigen/Core>
#include <Eigen/Cholesky>
#include <iostream>
#include "eiquadprog/eiquadprog.hpp"

int main() {
    // Pre-compute Cholesky decomposition for repeated solves
    Eigen::MatrixXd G(2, 2);
    G.setZero();
    G(0, 0) = 2.0;
    G(1, 1) = 2.0;

    // Compute Cholesky decomposition once
    Eigen::LLT<Eigen::MatrixXd, Eigen::Lower> chol(G);
    double c1 = G.trace();  // Store trace for numerical stability checks

    // Solve multiple problems with different linear terms
    for (int i = 0; i < 3; ++i) {
        Eigen::VectorXd g0(2);
        g0(0) = -static_cast<double>(i);
        g0(1) = -static_cast<double>(i);

        Eigen::MatrixXd CE(2, 0);
        Eigen::VectorXd ce0(0);
        Eigen::MatrixXd CI(2, 0);
        Eigen::VectorXd ci0(0);

        Eigen::VectorXd x(2);
        Eigen::VectorXi activeSet(0);
        size_t activeSetSize;

        double cost = eiquadprog::solvers::solve_quadprog(
            chol, c1, g0, CE, ce0, CI, ci0, x, activeSet, activeSetSize);

        std::cout << "Problem " << i << ": x = [" << x.transpose()
                  << "], cost = " << cost << std::endl;
    }

    // Expected output:
    // Problem 0: x = [0 0], cost = 0
    // Problem 1: x = [0.5 0.5], cost = -0.5
    // Problem 2: x = [1 1], cost = -2

    return 0;
}
```

--------------------------------

### EiquadprogFast Class for High-Performance QP Solving

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Use the EiquadprogFast class for real-time applications requiring consistent timing. It pre-allocates internal memory to avoid dynamic allocations during solving. Note that constraint matrices (Aeq, Aineq) are transposed compared to the standard solve_quadprog function.

```cpp
#include <Eigen/Core>
#include <iostream>
#include "eiquadprog/eiquadprog-fast.hpp"

using namespace eiquadprog::solvers;

int main() {
    // Create solver and pre-allocate memory
    // Parameters: (num_variables, num_equality_constraints, num_inequality_constraints)
    EiquadprogFast qp;
    qp.reset(2, 1, 1);  // 2 vars, 1 eq, 1 ineq

    // Configure solver
    qp.setMaxIter(1000);  // Set maximum iterations

    // Problem: min ||x - (1,1)||^2
    //     s.t. x[0] + x[1] = 5
    //          x[1] >= 3

    // NOTE: For EiquadprogFast, constraint matrices are transposed!
    // Aeq is (num_eq x num_vars) instead of (num_vars x num_eq)

    Eigen::MatrixXd Hess(2, 2);
    Hess.setIdentity();

    Eigen::VectorXd g0(2);
    g0 << -1.0, -1.0;

    // Equality: Aeq * x + beq = 0
    Eigen::MatrixXd Aeq(1, 2);  // (num_eq x num_vars)
    Aeq << 1.0, 1.0;

    Eigen::VectorXd beq(1);
    beq << -5.0;

    // Inequality: Aineq * x + bineq >= 0
    Eigen::MatrixXd Aineq(1, 2);  // (num_ineq x num_vars)
    Aineq << 0.0, 1.0;

    Eigen::VectorXd bineq(1);
    bineq << -3.0;

    Eigen::VectorXd x(2);

    // Solve
    EiquadprogFast_status status = qp.solve_quadprog(
        Hess, g0, Aeq, beq, Aineq, bineq, x);

    // Check status
    switch (status) {
        case EIQUADPROG_FAST_OPTIMAL:
            std::cout << "Optimal solution found!" << std::endl;
            break;
        case EIQUADPROG_FAST_INFEASIBLE:
            std::cout << "Problem is infeasible!" << std::endl;
            return 1;
        case EIQUADPROG_FAST_UNBOUNDED:
            std::cout << "Problem is unbounded!" << std::endl;
            return 1;
        case EIQUADPROG_FAST_MAX_ITER_REACHED:
            std::cout << "Maximum iterations reached!" << std::endl;
            return 1;
        case EIQUADPROG_FAST_REDUNDANT_EQUALITIES:
            std::cout << "Redundant equality constraints!" << std::endl;
            return 1;
    }

    std::cout << "Solution: x = [" << x.transpose() << "]" << std::endl;
    std::cout << "Objective value: " << qp.getObjValue() << std::endl;
    std::cout << "Active set size: " << qp.getActiveSetSize() << std::endl;
    std::cout << "Iterations: " << qp.getIteratios() << std::endl;
    std::cout << "Lagrange multipliers: ["
              << qp.getLagrangeMultipliers().head(qp.getActiveSetSize()).transpose()
              << "]" << std::endl;

    // Expected output:
    // Optimal solution found!
    // Solution: x = [2 3]
    // Objective value: 1.5
    // Active set size: 2
    // Iterations: 2

    return 0;
}
```

--------------------------------

### Create Test Shared Library

Source: https://github.com/stack-of-tasks/eiquadprog/blob/devel/tests/CMakeLists.txt

Creates a shared library named 'testab' from 'TestA.cpp' and 'TestB.cpp'. On Windows, it sets the property to export all symbols. It also links the project's library and applies a compiler option to suppress sign conversion warnings for GNU/Clang compilers.

```cmake
add_library(testab SHARED TestA.cpp TestB.cpp)
# testab is just a test shared library, so on Windows we export the symbols with
# WINDOWS_EXPORT_ALL_SYMBOLS
set_target_properties(testab PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)

target_link_libraries(testab ${PROJECT_NAME})
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    # We have a lot of implicit size_t to Eigen::Index conversions
    target_compile_options(testab PRIVATE "-Wno-sign-conversion")
endif()
```

--------------------------------

### Solve QP Problem with Lagrange Multipliers

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

This overloaded version of `solve_quadprog` returns Lagrange multipliers (dual variables) along with the primal solution. This is useful for sensitivity analysis. Ensure correct dimensions for input matrices and vectors.

```cpp
#include <Eigen/Core>
#include <iostream>
#include "eiquadprog/eiquadprog.hpp"

int main() {
    // Problem: min ||x||^2
    //     s.t. x[0] >= 1, x[1] >= 1

    Eigen::MatrixXd G(2, 2);
    G.setZero();
    G(0, 0) = 1.0;
    G(1, 1) = 1.0;

    Eigen::VectorXd g0(2);
    g0.setZero();

    // No equality constraints
    Eigen::MatrixXd CE(2, 0);
    Eigen::VectorXd ce0(0);

    // Inequality constraints: x[i] >= 1
    Eigen::MatrixXd CI(2, 2);
    CI.setZero();
    CI(0, 0) = 1.0;  // x[0] >= 1
    CI(1, 1) = 1.0;  // x[1] >= 1

    Eigen::VectorXd ci0(2);
    ci0(0) = -1.0;
    ci0(1) = -1.0;

    // Output variables including Lagrange multipliers
    Eigen::VectorXd x(2);
    Eigen::VectorXd y(2);  // Lagrange multipliers (size = p + m)
    Eigen::VectorXi activeSet(2);
    size_t activeSetSize;

    double cost = eiquadprog::solvers::solve_quadprog(
        G, g0, CE, ce0, CI, ci0, x, y, activeSet, activeSetSize);

    std::cout << "Solution: x = [" << x.transpose() << "]" << std::endl;
    std::cout << "Lagrange multipliers: y = [" << y.head(activeSetSize).transpose() << "]" << std::endl;
    std::cout << "Cost: " << cost << std::endl;

    // Expected output:
    // Solution: x = [1 1]
    // Lagrange multipliers: y = [1 1]
    // Cost: 1.0

    return 0;
}

```

--------------------------------

### Handle Infeasible Problem with EiquadprogFast

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Use the `EiquadprogFast` class. Infeasible problems return a status code other than `EIQUADPROG_FAST_OPTIMAL`.

```cpp
#include <Eigen/Core>
#include <iostream>
#include <cmath>
#include "eiquadprog/eiquadprog.hpp"
#include "eiquadprog/eiquadprog-fast.hpp"

using namespace eiquadprog::solvers;

void test_infeasible_fast() {
    // Same infeasible problem with EiquadprogFast
    EiquadprogFast qp;
    qp.reset(2, 0, 2);

    Eigen::MatrixXd Hess(2, 2);
    Hess.setIdentity();

    Eigen::VectorXd g0(2);
    g0.setZero();

    Eigen::MatrixXd Aeq(0, 2);
    Eigen::VectorXd beq(0);

    Eigen::MatrixXd Aineq(2, 2);
    Aineq.setZero();
    Aineq(0, 0) = 1.0;   // x[0] >= 1
    Aineq(1, 0) = -1.0;  // -x[0] >= 1

    Eigen::VectorXd bineq(2);
    bineq(0) = -1.0;
    bineq(1) = -1.0;

    Eigen::VectorXd x(2);

    EiquadprogFast_status status = qp.solve_quadprog(
        Hess, g0, Aeq, beq, Aineq, bineq, x);

    if (status != EIQUADPROG_FAST_OPTIMAL) {
        std::cout << "Fast solver: Problem failed with status " << status << std::endl;
    }
}
```

--------------------------------

### Solve QP Problem with Dynamic Matrices

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Use this function for solving quadratic programming problems with dynamic matrix sizes. Ensure all necessary Eigen headers are included. The function returns the optimal cost and populates the solution vector.

```cpp
#include <Eigen/Core>
#include <iostream>
#include "eiquadprog/eiquadprog.hpp"

int main() {
    // Problem: min ||x - (1,1)||^2
    //     s.t. x[0] + x[1] = 5
    //          x[1] >= 3

    // Hessian matrix G (identity for least-squares)
    Eigen::MatrixXd G(2, 2);
    G.setZero();
    G(0, 0) = 1.0;
    G(1, 1) = 1.0;

    // Linear term g0 = -2 * target (for ||x - target||^2)
    Eigen::VectorXd g0(2);
    g0(0) = -1.0;  // target x[0] = 1
    g0(1) = -1.0;  // target x[1] = 1

    // Equality constraint: CE' * x + ce0 = 0
    // x[0] + x[1] = 5 -> ce0 = -5
    Eigen::MatrixXd CE(2, 1);  // n x p (n=2 vars, p=1 eq constraint)
    CE(0, 0) = 1.0;
    CE(1, 0) = 1.0;

    Eigen::VectorXd ce0(1);
    ce0(0) = -5.0;

    // Inequality constraint: CI' * x + ci0 >= 0
    // x[1] >= 3 -> ci0 = -3
    Eigen::MatrixXd CI(2, 1);  // n x m (n=2 vars, m=1 ineq constraint)
    CI.setZero();
    CI(1, 0) = 1.0;

    Eigen::VectorXd ci0(1);
    ci0(0) = -3.0;

    // Output variables
    Eigen::VectorXd x(2);
    Eigen::VectorXi activeSet(2);  // size = num_eq + num_ineq
    size_t activeSetSize;

    // Solve the QP problem
    double cost = eiquadprog::solvers::solve_quadprog(
        G, g0, CE, ce0, CI, ci0, x, activeSet, activeSetSize);

    std::cout << "Optimal solution: x = [" << x.transpose() << "]" << std::endl;
    std::cout << "Optimal cost: " << cost << std::endl;
    std::cout << "Active set size: " << activeSetSize << std::endl;

    // Expected output:
    // Optimal solution: x = [2 3]
    // Optimal cost: 1.5
    // Active set size: 2

    // Check for infeasibility (returns infinity)
    if (std::isinf(cost)) {
        std::cerr << "Problem is infeasible!" << std::endl;
        return 1;
    }

    return 0;
}

```

--------------------------------

### Define and Link Unit Tests

Source: https://github.com/stack-of-tasks/eiquadprog/blob/devel/tests/CMakeLists.txt

Iterates through a list of test names, creates a unit test target for each, links the project's library and Boost unit test framework, and applies a compiler option to suppress sign conversion warnings for GNU/Clang compilers.

```cmake
set(TESTS
    eiquadprog-basic
    eiquadprog-fast
    eiquadprog-rt
    eiquadprog-both
    test-integration
)

foreach(test ${TESTS})
    add_unit_test(${test} ${test}.cpp)
    target_link_libraries(${test} ${PROJECT_NAME} Boost::unit_test_framework)
    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
        # We have a lot of implicit size_t to Eigen::Index conversions
        target_compile_options(${test} PRIVATE "-Wno-sign-conversion")
    endif()
endforeach(test ${TESTS})
```

--------------------------------

### Link Test Integration Target

Source: https://github.com/stack-of-tasks/eiquadprog/blob/devel/tests/CMakeLists.txt

Links the 'testab' shared library to the 'test-integration' target. This allows 'test-integration' to use functionality provided by 'testab'.

```cmake
target_link_libraries(test-integration testab)
```

--------------------------------

### Detect Redundant Equalities with EiquadprogFast

Source: https://context7.com/stack-of-tasks/eiquadprog/llms.txt

Use `EiquadprogFast` to detect redundant or conflicting equality constraints. The solver returns `EIQUADPROG_FAST_REDUNDANT_EQUALITIES` in such cases.

```cpp
#include <Eigen/Core>
#include <iostream>
#include <cmath>
#include "eiquadprog/eiquadprog.hpp"
#include "eiquadprog/eiquadprog-fast.hpp"

using namespace eiquadprog::solvers;

void test_redundant_equalities() {
    // Redundant equalities: x[0] = 1 AND x[0] = -1
    EiquadprogFast qp;
    qp.reset(2, 2, 0);

    Eigen::MatrixXd Hess(2, 2);
    Hess.setIdentity();

    Eigen::VectorXd g0(2);
    g0.setZero();

    Eigen::MatrixXd Aeq(2, 2);
    Aeq.setZero();
    Aeq(0, 0) = 1.0;  // x[0] = 1
    Aeq(1, 0) = 1.0;  // x[0] = -1

    Eigen::VectorXd beq(2);
    beq(0) = -1.0;
    beq(1) = 1.0;

    Eigen::MatrixXd Aineq(0, 2);
    Eigen::VectorXd bineq(0);

    Eigen::VectorXd x(2);

    EiquadprogFast_status status = qp.solve_quadprog(
        Hess, g0, Aeq, beq, Aineq, bineq, x);

    if (status == EIQUADPROG_FAST_REDUNDANT_EQUALITIES) {
        std::cout << "Fast solver: Detected redundant/conflicting equalities" << std::endl;
    }
}
```
Tokens:
Raw