HybZono.hpp

Go to the documentation of this file.

#ifndef ZONOOPT_HYBZONO_HPP_
#define ZONOOPT_HYBZONO_HPP_
 
#include "SparseMatrixUtilities.hpp"
#include "MI_Solver.hpp"
#include "MI_DataStructures.hpp"
#include "Inequality.hpp"
#include "Intervals.hpp"
 
#include <stdexcept>
#include <limits>
#include <set>
 
namespace ZonoOpt
{
 
using namespace detail;
 
// forward declarations
class Zono;
class ConZono;
 
class HybZono
{
    public:
        
        // constructors
 
        HybZono() = default;
 
        HybZono(const Eigen::SparseMatrix<zono_float>& Gc, const Eigen::SparseMatrix<zono_float>& Gb, const Eigen::Vector<zono_float, -1>& c,
            const Eigen::SparseMatrix<zono_float>& Ac, const Eigen::SparseMatrix<zono_float>& Ab, const Eigen::Vector<zono_float, -1>& b,
            bool zero_one_form=false, bool sharp=false);
 
        // virtual destructor
        virtual ~HybZono() = default;
 
        void set(const Eigen::SparseMatrix<zono_float>& Gc, const Eigen::SparseMatrix<zono_float>& Gb, const Eigen::Vector<zono_float, -1>& c,
            const Eigen::SparseMatrix<zono_float>& Ac, const Eigen::SparseMatrix<zono_float>& Ab, const Eigen::Vector<zono_float, -1>& b,
            bool zero_one_form=false, bool sharp=false);
 
        virtual HybZono* clone() const;
 
        // get methods
 
        virtual int get_n() const { return this->n; }
 
        virtual int get_nC() const { return this->nC; }
 
        virtual int get_nG() const { return this->nG; }
 
        virtual int get_nGc() const { return this->nGc; }
 
        virtual int get_nGb() const { return this->nGb; }
 
        virtual Eigen::SparseMatrix<zono_float> get_Gc() const { return this->Gc; }
 
        virtual Eigen::SparseMatrix<zono_float> get_Gb() const { return this->Gb; }
 
        virtual Eigen::SparseMatrix<zono_float> get_G() const { return this->G; }
 
        virtual Eigen::SparseMatrix<zono_float> get_Ac() const { return this->Ac; }
 
        virtual Eigen::SparseMatrix<zono_float> get_Ab() const { return this->Ab; }
 
        virtual Eigen::SparseMatrix<zono_float> get_A() const { return this->A; }
 
        virtual Eigen::Vector<zono_float, -1> get_c() const { return this->c; }
        
        virtual Eigen::Vector<zono_float, -1> get_b() const { return this->b; }
 
        virtual bool is_0_1_form() const { return this->zero_one_form; }
 
        bool is_sharp() const { return this->sharp; }
 
        virtual void convert_form();
 
        virtual void remove_redundancy(int contractor_iter=100);
 
        virtual std::unique_ptr<ConZono> convex_relaxation() const;
 
        virtual std::unique_ptr<HybZono> complement(const zono_float delta_m = 100, const bool remove_redundancy=true, const OptSettings &settings=OptSettings(),
            OptSolution* solution=nullptr, const int n_leaves = std::numeric_limits<int>::max(), const int contractor_iter=100)
        {
            return do_complement(delta_m, remove_redundancy, settings, solution, n_leaves, contractor_iter);
        }
 
        // type checking
        bool is_point() const;
 
        bool is_zono() const;
 
        bool is_conzono() const;
 
        bool is_hybzono() const;
 
        bool is_empty_set() const;
        
        // display methods
        virtual std::string print() const;
 
        friend std::ostream& operator<<(std::ostream& os, const HybZono& Z);
 
        // optimization
        Eigen::Vector<zono_float, -1> optimize_over(
            const Eigen::SparseMatrix<zono_float> &P, const Eigen::Vector<zono_float, -1> &q, zono_float c=0,
            const OptSettings &settings=OptSettings(), OptSolution* solution=nullptr) const
        {
            return do_optimize_over(P, q, c, settings, solution);
        }
 
        Eigen::Vector<zono_float, -1> project_point(const Eigen::Vector<zono_float, -1>& x,
            const OptSettings &settings=OptSettings(), OptSolution* solution=nullptr) const
        {
            return do_project_point(x, settings, solution);
        }
 
        bool is_empty(const OptSettings &settings=OptSettings(),
            OptSolution* solution=nullptr) const
        {
            return do_is_empty(settings, solution);
        }
 
        zono_float support(const Eigen::Vector<zono_float, -1>& d, const OptSettings &settings=OptSettings(),
            OptSolution* solution=nullptr)
        {
            return do_support(d, settings, solution);
        }
 
        bool contains_point(const Eigen::Vector<zono_float, -1>& x, const OptSettings &settings=OptSettings(),
            OptSolution* solution=nullptr) const
        {
            return do_contains_point(x, settings, solution);
        }
 
        Box bounding_box(const OptSettings &settings=OptSettings(), OptSolution* solution=nullptr)
        {
            return do_bounding_box(settings, solution);
        }
 
        std::vector<ConZono> get_leaves(bool remove_redundancy=true, const OptSettings &settings=OptSettings(),
            OptSolution* solution=nullptr, int n_leaves = std::numeric_limits<int>::max(), int contractor_iter=10) const;
 
        // friend function declarations
        friend std::unique_ptr<HybZono> affine_map(const HybZono& Z,
            const Eigen::SparseMatrix<zono_float>& R, const Eigen::Vector<zono_float, -1>& s);
        friend std::unique_ptr<HybZono> project_onto_dims(const HybZono& Z, const std::vector<int>& dims);
        friend std::unique_ptr<HybZono> minkowski_sum(const HybZono& Z1, HybZono& Z2);
        friend std::unique_ptr<HybZono> pontry_diff(HybZono& Z1, HybZono& Z2, bool exact);
        friend std::unique_ptr<HybZono> intersection(const HybZono& Z1, HybZono& Z2, 
            const Eigen::SparseMatrix<zono_float>& R);
        friend std::unique_ptr<HybZono> intersection_over_dims(const HybZono& Z1, HybZono& Z2, 
            const std::vector<int>& dims);
        friend std::unique_ptr<HybZono> halfspace_intersection(HybZono& Z, const Eigen::SparseMatrix<zono_float>& H, 
            const Eigen::Vector<zono_float, -1>& f, const Eigen::SparseMatrix<zono_float>& R);
        friend std::unique_ptr<HybZono> union_of_many(const std::vector<std::shared_ptr<HybZono>>& Zs, bool preserve_sharpness, bool expose_indicators);
        friend std::unique_ptr<HybZono> cartesian_product(const HybZono& Z1, HybZono& Z2);
        friend std::unique_ptr<HybZono> constrain(HybZono& Z, const std::vector<Inequality> &ineqs, const Eigen::SparseMatrix<zono_float>& R);
        friend std::unique_ptr<HybZono> set_diff(const HybZono& Z1, HybZono& Z2, zono_float delta_m, bool remove_redundancy,
            const OptSettings &settings, OptSolution* solution, int n_leaves, int contractor_iter);
        friend std::unique_ptr<HybZono> vrep_2_hybzono(const std::vector<Eigen::Matrix<zono_float, -1, -1>> &Vpolys, bool expose_indicators);
        friend std::unique_ptr<HybZono> zono_union_2_hybzono(std::vector<Zono> &Zs, bool expose_indicators);
 
    protected:
 
        // fields
 
        Eigen::SparseMatrix<zono_float> G = Eigen::SparseMatrix<zono_float>(0, 0);
 
        Eigen::SparseMatrix<zono_float> Gc = Eigen::SparseMatrix<zono_float>(0, 0);
 
        Eigen::SparseMatrix<zono_float> Gb = Eigen::SparseMatrix<zono_float>(0, 0);
 
        Eigen::SparseMatrix<zono_float> A = Eigen::SparseMatrix<zono_float>(0, 0);
 
        Eigen::SparseMatrix<zono_float> Ac = Eigen::SparseMatrix<zono_float>(0, 0);
 
        Eigen::SparseMatrix<zono_float> Ab = Eigen::SparseMatrix<zono_float>(0, 0);
 
        Eigen::Vector<zono_float, -1> c = Eigen::Vector<zono_float, -1>(0);
 
        Eigen::Vector<zono_float, -1> b = Eigen::Vector<zono_float, -1>(0);
 
        int n = 0;
 
        int nG = 0;
 
        int nGc = 0;
 
        int nGb = 0;
 
        int nC = 0;
 
        bool zero_one_form = false;
 
        bool sharp = false;
 
        // methods
        virtual Eigen::Vector<zono_float, -1> do_optimize_over(
            const Eigen::SparseMatrix<zono_float> &P, const Eigen::Vector<zono_float, -1> &q, zono_float c,
            const OptSettings &settings, OptSolution* solution) const;
 
        virtual Eigen::Vector<zono_float, -1> do_project_point(const Eigen::Vector<zono_float, -1>& x,
            const OptSettings &settings, OptSolution* solution) const;
 
        virtual bool do_is_empty(const OptSettings &settings, OptSolution* solution) const;
 
        virtual zono_float do_support(const Eigen::Vector<zono_float, -1>& d, const OptSettings &settings,
            OptSolution* solution);
 
        virtual bool do_contains_point(const Eigen::Vector<zono_float, -1>& x, const OptSettings &settings,
            OptSolution* solution) const;
 
        virtual Box do_bounding_box(const OptSettings &settings, OptSolution* solution);
 
        virtual std::unique_ptr<HybZono> do_complement(zono_float, bool remove_redundancy, const OptSettings &settings,
            OptSolution* solution, int n_leaves, int contractor_iter);
 
 
        static void remove_generators(Eigen::SparseMatrix<zono_float>& G, Eigen::SparseMatrix<zono_float>& A, const std::set<int>& idx_to_remove);
        static std::set<int> find_unused_generators(const Eigen::SparseMatrix<zono_float>& G, const Eigen::SparseMatrix<zono_float>& A);
        OptSolution mi_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 OptSettings &settings=OptSettings(), OptSolution* solution=nullptr) const;
        std::vector<OptSolution> mi_opt_multisol(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, int n_sols,
            const OptSettings &settings=OptSettings(), OptSolution* solution=nullptr) const;
 
    private:
 
        void make_G_A();
        void set_Ac_Ab_from_A();
        std::vector<Eigen::Vector<zono_float, -1>> get_bin_leaves(const OptSettings &settings=OptSettings(), OptSolution* solution=nullptr,
            int n_leaves = std::numeric_limits<int>::max()) const;
};
 
// forward delcarations
std::unique_ptr<HybZono> affine_map(const HybZono& Z,
    const Eigen::SparseMatrix<zono_float>& R, const Eigen::Vector<zono_float, -1>& s = Eigen::Vector<zono_float, -1>());
 
std::unique_ptr<HybZono> project_onto_dims(const HybZono& Z, const std::vector<int>& dims);
 
std::unique_ptr<HybZono> minkowski_sum(const HybZono& Z1, HybZono& Z2);
 
std::unique_ptr<HybZono> pontry_diff(HybZono& Z1, HybZono& Z2, bool exact=false);
 
std::unique_ptr<HybZono> intersection(const HybZono& Z1, HybZono& Z2,
    const Eigen::SparseMatrix<zono_float>& R=Eigen::SparseMatrix<zono_float>());
 
std::unique_ptr<HybZono> intersection_over_dims(const HybZono& Z1, HybZono& Z2,
    const std::vector<int>& dims);
 
std::unique_ptr<HybZono> halfspace_intersection(HybZono& Z, const Eigen::SparseMatrix<zono_float>& H,
    const Eigen::Vector<zono_float, -1>& f, const Eigen::SparseMatrix<zono_float>& R=Eigen::SparseMatrix<zono_float>());
 
std::unique_ptr<HybZono> union_of_many(const std::vector<std::shared_ptr<HybZono>>& Zs, bool preserve_sharpness=false, bool expose_indicators=false);
 
std::unique_ptr<HybZono> cartesian_product(const HybZono& Z1, HybZono& Z2);
 
std::unique_ptr<HybZono> constrain(HybZono& Z, const std::vector<Inequality> &ineqs, const Eigen::SparseMatrix<zono_float>& R=Eigen::SparseMatrix<zono_float>());
 
std::unique_ptr<HybZono> set_diff(const HybZono& Z1, HybZono& Z2, zono_float delta_m = 100, bool remove_redundancy=true,
    const OptSettings &settings=OptSettings(), OptSolution* solution=nullptr, int n_leaves = std::numeric_limits<int>::max(), int contractor_iter = 100);
 
 
std::unique_ptr<HybZono> vrep_2_hybzono(const std::vector<Eigen::Matrix<zono_float, -1, -1>> &Vpolys, bool expose_indicators=false);
 
 
std::unique_ptr<HybZono> zono_union_2_hybzono(std::vector<Zono> &Zs, bool expose_indicators=false);
 
 
} // end namespace ZonoOpt
 
#endif