ConZono.hpp

Go to the documentation of this file.

#ifndef ZONOOPT_CONZONO_HPP_
#define ZONOOPT_CONZONO_HPP_
 
#include "HybZono.hpp"
 
namespace ZonoOpt
{
    using namespace detail;
 
    class ConZono : public HybZono
    {
    public:
        // constructors
 
        ConZono() { sharp = true; }
 
        ConZono(const Eigen::SparseMatrix<zono_float>& G, const Eigen::Vector<zono_float, -1>& c,
                const Eigen::SparseMatrix<zono_float>& A, const Eigen::Vector<zono_float, -1>& b,
                const bool zero_one_form = false);
 
        // virtual destructor
        ~ConZono() override = default;
 
        HybZono* clone() const override;
 
        // set method
        void set(const Eigen::SparseMatrix<zono_float>& G, const Eigen::Vector<zono_float, -1>& c,
                 const Eigen::SparseMatrix<zono_float>& A, const Eigen::Vector<zono_float, -1>& b,
                 bool zero_one_form = false);
 
        virtual std::unique_ptr<ConZono> constraint_reduction() const;
 
        // generator conversion between [-1,1] and [0,1]
        void convert_form() override;
 
        // over-approximate as zonotope
 
        virtual std::unique_ptr<Zono> to_zono_approx() const;
 
        // display methods
        std::string print() const override;
 
        // in-place operators (type-preserving overrides)
        using HybZono::operator+=;  // restore vector and box overloads hidden by declarations below
        using HybZono::operator*=;  // restore scalar overload hidden by declarations below
 
        void operator+=(ConZono& other);
 
        void operator+=(HybZono& other) = delete;
 
        void operator*=(ConZono& other);
 
        void operator*=(HybZono& other) = delete;
 
    protected:
        OptSolution qp_opt(const Eigen::SparseMatrix<zono_float>& P, const Eigen::Vector<zono_float, -1>& q,
                           zono_float c, const Eigen::SparseMatrix<zono_float>& A,
                           const Eigen::Vector<zono_float, -1>& b,
                           const SolverSettings& settings = get_default_solver_settings(),
                           std::shared_ptr<OptSolution>* solution = nullptr,
                           const WarmStartParams& warm_start_params = WarmStartParams()) const;
 
        Eigen::Vector<zono_float, -1> do_optimize_over(
            const Eigen::SparseMatrix<zono_float>& P, const Eigen::Vector<zono_float, -1>& q, const zono_float c,
            const SolverSettings& settings, std::shared_ptr<OptSolution>* solution,
            const WarmStartParams&) const override;
 
        Eigen::Vector<zono_float, -1> do_project_point(const Eigen::Vector<zono_float, -1>& x,
                                                       const SolverSettings& settings,
                                                       std::shared_ptr<OptSolution>* solution,
                                                       const WarmStartParams& warm_start_params) const override;
 
        bool do_is_empty(const SolverSettings& settings, std::shared_ptr<OptSolution>* solution,
                         const WarmStartParams& warm_start_params) const override;
 
        zono_float do_support(const Eigen::Vector<zono_float, -1>& d, const SolverSettings& settings,
                              std::shared_ptr<OptSolution>* solution,
                              const WarmStartParams& warm_start_params) override;
 
        bool do_contains_point(const Eigen::Vector<zono_float, -1>& x, const SolverSettings& settings,
                               std::shared_ptr<OptSolution>* solution,
                               const WarmStartParams& warm_start_params) const override;
 
        Box do_bounding_box(const SolverSettings& settings, std::shared_ptr<OptSolution>*,
                            const WarmStartParams& warm_start_params) override;
 
        std::unique_ptr<HybZono> do_complement(zono_float delta_m, bool, const SolverSettings&,
                                               std::shared_ptr<OptSolution>*, int, int) override;
    };
 
    // forward declarations
 
    std::unique_ptr<ConZono> vrep_2_conzono(const Eigen::Matrix<zono_float, -1, -1>& Vpoly);
} // namespace ZonoOpt
 
 
#endif