copp2_socp.hpp

Go to the documentation of this file.

#pragma once
 
#include <initializer_list>
#include <optional>
#include <vector>
 
#include "copp/clarabel.hpp"
#include "copp/core.hpp"
#include "copp/objective.hpp"
#include "copp/robot.hpp"
 
namespace copp::solver::copp2_socp
{

    class COPP_API Problem
    {
    public:
        Problem(
            const Robot &robot,
            std::vector<Objective> objectives,
            IndexInterval idx_s_interval,
            Boundary2 a_boundary = {});
 
        Problem(
            const Robot &robot,
            std::initializer_list<Objective> objectives,
            IndexInterval idx_s_interval,
            Boundary2 a_boundary = {});
 
        const Robot &robot() const noexcept { return *robot_; }
        const std::vector<Objective> &objectives() const noexcept { return objectives_; }
        IndexInterval idx_s_interval() const noexcept { return idx_s_interval_; }
        Boundary2 a_boundary() const noexcept { return a_boundary_; }
        std::size_t s_len() const noexcept { return s_len_; }
 
    private:
        const Robot *robot_ = nullptr;
        std::vector<Objective> objectives_;
        IndexInterval idx_s_interval_;
        Boundary2 a_boundary_;
        std::size_t s_len_ = 0;
    };

    struct Result
    {
        std::optional<std::vector<double>> a;
        std::vector<double> x;
        std::vector<double> z;
        std::vector<double> s;
        clarabel::SolverStatus solver_status = clarabel::SolverStatus::Unsolved;
        double obj_val = 0.0;
        double obj_val_dual = 0.0;
        double solve_time = 0.0;
        std::uint32_t iterations = 0;
        double r_prim = 0.0;
        double r_dual = 0.0;
        clarabel::LinearSolverInfo linsolver;
        std::optional<double> objective_value;
        std::vector<double> objective_terms;
 
        bool has_a() const noexcept { return a.has_value(); }
    };

    COPP_API std::vector<double> solve(
        const Problem &problem,
        const clarabel::Options &options = {});
    inline Expected<std::vector<double>> solve(
        const Problem &problem,
        const clarabel::Options &options,
        NoThrowTag)
    {
        return detail::expected_from([&] { return solve(problem, options); });
    }
    inline Expected<std::vector<double>> solve(const Problem &problem, NoThrowTag tag)
    {
        return solve(problem, clarabel::Options{}, tag);
    }

    COPP_API Result solve_expert(
        const Problem &problem,
        const clarabel::Options &options = {});
    inline Expected<Result> solve_expert(
        const Problem &problem,
        const clarabel::Options &options,
        NoThrowTag)
    {
        return detail::expected_from([&] { return solve_expert(problem, options); });
    }
    inline Expected<Result> solve_expert(const Problem &problem, NoThrowTag tag)
    {
        return solve_expert(problem, clarabel::Options{}, tag);
    }
 
} // namespace copp::solver::copp2_socp