jade::basic_qpas< TValue > Class Template Reference

A template for a class that implements the Quadratic Programming for Active Set algorithm. More...

#include <jade.qpas.hpp>

Collaboration diagram for jade::basic_qpas< TValue >:

Public Types
typedef TValue	value_type
	The value type. More...
typedef basic_matrix< value_type >	matrix_type
	The matrix type. More...

Static Public Member Functions
static void	loop_over_active_set (const matrix_type &b_vec, const matrix_type &coefficients_mat, const matrix_type &hessian_mat, const matrix_type &derivative_vec, const std::vector< size_t > &fixed_active_set, std::vector< size_t > &active_set, matrix_type &delta_vec)
	Loops over the active set and computes a delta vector and a new active set. More...

Detailed Description

template<typename TValue>
class jade::basic_qpas< TValue >

A template for a class that implements the Quadratic Programming for Active Set algorithm.

Definition at line 19 of file jade.qpas.hpp.

Member Typedef Documentation

matrix_type

template<typename TValue >

typedef basic_matrix<value_type> jade::basic_qpas< TValue >::matrix_type

The matrix type.

Definition at line 26 of file jade.qpas.hpp.

value_type

template<typename TValue >

typedef TValue jade::basic_qpas< TValue >::value_type

The value type.

Definition at line 23 of file jade.qpas.hpp.

Member Function Documentation

loop_over_active_set()

template<typename TValue >

static void jade::basic_qpas< TValue >::loop_over_active_set ( const matrix_type &  b_vec, const matrix_type &  coefficients_mat, const matrix_type &  hessian_mat, const matrix_type &  derivative_vec, const std::vector< size_t > &  fixed_active_set, std::vector< size_t > &  active_set, matrix_type &  delta_vec  )

inlinestatic

Loops over the active set and computes a delta vector and a new active set.

Parameters

b_vec	The B vector.
coefficients_mat	The coefficients matrix.
hessian_mat	The Hessian matrix.
derivative_vec	The derivative vector.
fixed_active_set	The fixed active set.
active_set	The active set.
delta_vec	The delta vector.

Definition at line 40 of file jade.qpas.hpp.

        {
            assert(!fixed_active_set.empty() || !active_set.empty());
 
            const auto K = hessian_mat.get_height();
            assert(K > 0);
 
            const auto inequality_constraint_count =
                    b_vec.get_length() - fixed_active_set.size();
 
            assert(b_vec.is_vector());
            assert(coefficients_mat.get_height() == b_vec.get_length());
            assert(fixed_active_set.size() <= K);
            assert(delta_vec.is_vector());
            assert(delta_vec.get_height() == K);
 
            std::set<unsigned long> visited_sets;
 
            const auto insert_key = [&visited_sets, &active_set]() -> bool
            {
                auto key = 0UL;
                for (const auto i : active_set)
                    key |= 1UL << i;
                if (visited_sets.find(key) != visited_sets.end())
                    return false;
                visited_sets.insert(key);
                return true;
            };
 
            while (insert_key())
            {
                std::vector<size_t> merged_active_set;
                merged_active_set.insert(
                            merged_active_set.end(),
                            active_set.begin(),
                            active_set.end());
                merged_active_set.insert(
                            merged_active_set.end(),
                            fixed_active_set.begin(),
                            fixed_active_set.end());
 
                matrix_type lagrangian_vec (
                    merged_active_set.size(),
                    merged_active_set.empty() ? 0 : 1);
 
                matrix_type try_delta_vec (K, 1);
 
                _kkt(b_vec,
                    coefficients_mat,
                    hessian_mat,
                    derivative_vec,
                    merged_active_set,
                    try_delta_vec,
                    lagrangian_vec);
 
                std::vector<size_t> violated_indices;
 
                if (active_set.size() < K - fixed_active_set.size())
                {
                    for (size_t i = 0; i < inequality_constraint_count; i++)
                    {
                        if (merged_active_set.end() != std::find(
                                merged_active_set.begin(),
                                merged_active_set.end(),
                                i))
                            continue;
 
                        const auto lhs = coefficients_mat
                                .multiply_row(i, try_delta_vec);
 
                        if (lhs > b_vec[i])
                            violated_indices.push_back(i);
                    }
                }
 
                if (violated_indices.empty())
                {
                    delta_vec = try_delta_vec;
 
                    auto lagrangian_index = index_not_found;
                    for (size_t i = 0; i < active_set.size(); i++)
                    {
                        const auto lms_i = lagrangian_vec[i];
                        if (lms_i < value_type(0))
                            continue;
                        if (lagrangian_index == index_not_found ||
                            lms_i > lagrangian_vec[lagrangian_index])
                            lagrangian_index = i;
                    }
 
                    if (lagrangian_index == index_not_found)
                        return;
 
                    active_set.erase(
                        active_set.begin() +
                        int(lagrangian_index));
                }
                else
                {
                    const auto k_violated = _backtrack(
                            b_vec,
                            coefficients_mat,
                            delta_vec,
                            try_delta_vec,
                            violated_indices,
                            delta_vec);
 
                    if (k_violated == index_not_found)
                        continue;
 
                    assert(std::none_of(
                               active_set.begin(),
                               active_set.end(),
                               [k_violated](const size_t index) -> bool
                    {
                        return index == k_violated;
                    }));
 
                    assert(k_violated != index_not_found);
                    assert(k_violated < b_vec.get_length());
                    active_set.push_back(k_violated);
                }
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• jade.qpas.hpp