fa/f1cc8c1000b4f794313826149a907df876c1ac980f7a0e327b4b18ef658f/zonoopt-2.4.0.tar.gz

#ifndef ZONOOPT_HYBZONO_HPP_

#define ZONOOPT_HYBZONO_HPP_


#include "SparseMatrixUtilities.hpp"

#include "BranchAndBound.hpp"

#include "BnbDataStructures.hpp"

#include "IntervalMatrix.hpp"


#include <cassert>

#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,

            const bool zero_one_form=false, const 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 std::unique_ptr<HybZono> remove_redundancy(int contractor_iter=10) const;


        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 SolverSettings &settings=get_default_solver_settings(),

            std::shared_ptr<OptSolution>* solution=nullptr, const int n_leaves = std::numeric_limits<int>::max(), const int contractor_iter=10)

        {

            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 SolverSettings &settings=get_default_solver_settings(), std::shared_ptr<OptSolution>* solution=nullptr,

            const WarmStartParams& warm_start_params=WarmStartParams()) const

        {

            return do_optimize_over(P, q, c, settings, solution, warm_start_params);

        }


        Eigen::Vector<zono_float, -1> project_point(const Eigen::Vector<zono_float, -1>& x,

            const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr<OptSolution>* solution=nullptr,

            const WarmStartParams& warm_start_params=WarmStartParams()) const

        {

            return do_project_point(x, settings, solution, warm_start_params);

        }


        bool is_empty(const SolverSettings &settings=get_default_solver_settings(),

            std::shared_ptr<OptSolution>* solution=nullptr, const WarmStartParams& warm_start_params=WarmStartParams()) const

        {

            return do_is_empty(settings, solution, warm_start_params);

        }


        zono_float support(const Eigen::Vector<zono_float, -1>& d, const SolverSettings &settings=get_default_solver_settings(),

            std::shared_ptr<OptSolution>* solution=nullptr, const WarmStartParams& warm_start_params=WarmStartParams())

        {

            return do_support(d, settings, solution, warm_start_params);

        }


        bool contains_point(const Eigen::Vector<zono_float, -1>& x, const SolverSettings &settings=get_default_solver_settings(),

            std::shared_ptr<OptSolution>* solution=nullptr, const WarmStartParams& warm_start_params=WarmStartParams()) const

        {

            return do_contains_point(x, settings, solution, warm_start_params);

        }


        Box bounding_box(const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr<OptSolution>* solution=nullptr,

            const WarmStartParams& warm_start_params=WarmStartParams())

        {

            return do_bounding_box(settings, solution, warm_start_params);

        }


        std::vector<std::unique_ptr<ConZono>> get_leaves(bool remove_redundancy=false, const SolverSettings &settings=get_default_solver_settings(),

            std::shared_ptr<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> affine_inclusion(const HybZono& Z, const IntervalMatrix& 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, Zono& 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<ConZono> convex_hull(const std::vector<std::shared_ptr<HybZono>>& Zs, bool exact);

        friend std::unique_ptr<HybZono> cartesian_product(const HybZono& Z1, HybZono& Z2);

        friend std::unique_ptr<HybZono> constrain(HybZono& Z, const Eigen::SparseMatrix<zono_float>& H,

            const Eigen::Vector<zono_float, -1>& f, char direction, 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 SolverSettings &settings, std::shared_ptr<OptSolution>* solution, const WarmStartParams& warm_start_params, 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<std::shared_ptr<Zono>> &Zs, bool expose_indicators);


        // operator overloading


        std::unique_ptr<HybZono> operator+(HybZono& other) const;


        std::unique_ptr<HybZono> operator+(const Eigen::Vector<zono_float, -1>& v) const;


        friend std::unique_ptr<HybZono> operator+(const Eigen::Vector<zono_float, -1>& v, HybZono& Z);


        std::unique_ptr<HybZono> operator+(const Box& box) const;


        friend std::unique_ptr<HybZono> operator+(const Box& box, HybZono& Z);


        void operator+=(HybZono& other);


        void operator+=(const Eigen::Vector<zono_float, -1>& v);


        void operator+=(const Box& box);


        friend std::unique_ptr<HybZono> operator*(const Eigen::SparseMatrix<zono_float>& R, const HybZono& Z);


        friend std::unique_ptr<HybZono> operator*(const Eigen::Matrix<zono_float, -1, -1>& R, const HybZono& Z);


        friend std::unique_ptr<HybZono> operator*(const IntervalMatrix& R, const HybZono& Z);


        std::unique_ptr<HybZono> operator*(zono_float f) const;


        friend std::unique_ptr<HybZono> operator*(zono_float f, const HybZono& Z);


        void operator*=(zono_float f);


        std::unique_ptr<HybZono> operator-(Zono& other);


        std::unique_ptr<HybZono> operator-(const Eigen::Vector<zono_float, -1>& v);


        std::unique_ptr<HybZono> operator-(const Box& box);


        void operator-=(Zono& other);


        void operator-=(const Eigen::Vector<zono_float, -1>& v);


        void operator-=(const Box& box);


        std::unique_ptr<HybZono> operator*(HybZono& other) const;


        std::unique_ptr<HybZono> operator*(const Box& box) const;


        friend std::unique_ptr<HybZono> operator*(const Box& box, HybZono& Z);


        void operator*=(HybZono& other);


        void operator*=(const Box& box);


        std::unique_ptr<HybZono> operator&(HybZono& other) const;


        std::unique_ptr<HybZono> operator|(HybZono& other) const;


        std::unique_ptr<HybZono> operator-() const; // unary minus


    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 SolverSettings &settings, std::shared_ptr<OptSolution>* solution,

            const WarmStartParams& warm_start_params) const;


        virtual 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;


        virtual bool do_is_empty(const SolverSettings &settings, std::shared_ptr<OptSolution>* solution,

            const WarmStartParams& warm_start_params) const;


        virtual zono_float do_support(const Eigen::Vector<zono_float, -1>& d, const SolverSettings &settings,

            std::shared_ptr<OptSolution>* solution, const WarmStartParams& warm_start_params);


        virtual 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;


        virtual Box do_bounding_box(const SolverSettings &settings, std::shared_ptr<OptSolution>* solution,

            const WarmStartParams& warm_start_params);


        virtual std::unique_ptr<HybZono> do_complement(zono_float, bool remove_redundancy, const SolverSettings &settings,

            std::shared_ptr<OptSolution>* solution, int n_leaves, int contractor_iter);


        static void remove_cols(Eigen::SparseMatrix<zono_float>& M, 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 SolverSettings &settings=get_default_solver_settings(), std::shared_ptr<OptSolution>* solution=nullptr,

            const WarmStartParams& warm_start_params=WarmStartParams()) 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 SolverSettings &settings=get_default_solver_settings(), std::shared_ptr<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 SolverSettings &settings=get_default_solver_settings(), std::shared_ptr<OptSolution>* solution=nullptr,

            int n_leaves = std::numeric_limits<int>::max()) const;

        std::vector<std::pair<int, int>> get_simplifiable_constraints() const;

        void apply_constraint_simplification(const std::vector<std::pair<int, int>>& cons, Box& box);

        bool rescale_generators(MI_Box& box); // returns false if empty set detected

        void remove_generators(const std::set<int>& idx_c, const std::set<int>& idx_b, MI_Box& box);

        void remove_fixed_vars(MI_Box& box);

        static std::unique_ptr<Zono> zono_hull(Zono& Z1, Zono& Z2);

};


// 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> affine_inclusion(const HybZono& Z, const IntervalMatrix& 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, Zono& Z2, bool exact=true);


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<ConZono> convex_hull(const std::vector<std::shared_ptr<HybZono>>& Zs, bool exact=true);


std::unique_ptr<HybZono> cartesian_product(const HybZono& Z1, HybZono& Z2);


std::unique_ptr<HybZono> constrain(HybZono& Z, const Eigen::SparseMatrix<zono_float>& H,

            const Eigen::Vector<zono_float, -1>& f, char direction, 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 SolverSettings &settings=get_default_solver_settings(), std::shared_ptr<OptSolution>* solution=nullptr,

    int n_leaves = std::numeric_limits<int>::max(), int contractor_iter = 10);


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<std::shared_ptr<Zono>> &Zs, bool expose_indicators=false);


} // end namespace ZonoOpt


#endif

BnbDataStructures.hpp
Data structures for mixed-integer optimization in ZonoOpt library.

BranchAndBound.hpp
Internal branch-and-bound routines for ZonoOpt library.

IntervalMatrix.hpp
IntervalMatrix class.

cons
SCIPApi::ConsPtr cons
Definition SCIPSolver.cpp:58

SparseMatrixUtilities.hpp
Utilities for sparse matrix operations in ZonoOpt library.

ZonoOpt::Box
Box (i.e., interval vector) class.
Definition Box.hpp:25

ZonoOpt::HybZono
Hybrid zonotope class.
Definition HybZono.hpp:43

ZonoOpt::HybZono::affine_map
friend std::unique_ptr< HybZono > affine_map(const HybZono &Z, const Eigen::SparseMatrix< zono_float > &R, const Eigen::Vector< zono_float, -1 > &s)
Returns affine map R*Z + s of set Z.
Definition SetOperations.cpp:12

ZonoOpt::HybZono::is_0_1_form
virtual bool is_0_1_form() const
Returns true if factors are in range [0,1], false if they are in range [-1,1].
Definition HybZono.hpp:194

ZonoOpt::HybZono::nC
int nC
number of constraints
Definition HybZono.hpp:743

ZonoOpt::HybZono::constrain
friend std::unique_ptr< HybZono > constrain(HybZono &Z, const Eigen::SparseMatrix< zono_float > &H, const Eigen::Vector< zono_float, -1 > &f, char direction, const Eigen::SparseMatrix< zono_float > &R)
Computes the generalized intersection of set Z with H*x <= f, H*x >= f, or H*x = f over matrix R.
Definition SetOperations.cpp:857

ZonoOpt::HybZono::get_n
virtual int get_n() const
Returns dimension of set.
Definition HybZono.hpp:103

ZonoOpt::HybZono::pontry_diff
friend std::unique_ptr< HybZono > pontry_diff(HybZono &Z1, Zono &Z2, bool exact)
Computes the Pontryagin difference Z1 - Z2.
Definition SetOperations.cpp:330

ZonoOpt::HybZono::is_sharp
bool is_sharp() const
Returns true if set is known to be sharp.
Definition HybZono.hpp:203

ZonoOpt::HybZono::cartesian_product
friend std::unique_ptr< HybZono > cartesian_product(const HybZono &Z1, HybZono &Z2)
Computes the Cartesian product of two sets Z1 and Z2.
Definition SetOperations.cpp:797

ZonoOpt::HybZono::n
int n
set dimension
Definition HybZono.hpp:731

ZonoOpt::HybZono::get_Gc
virtual Eigen::SparseMatrix< zono_float > get_Gc() const
Returns continuous generator matrix.
Definition HybZono.hpp:138

ZonoOpt::HybZono::minkowski_sum
friend std::unique_ptr< HybZono > minkowski_sum(const HybZono &Z1, HybZono &Z2)
Computes Minkowski sum of two sets Z1 and Z2.
Definition SetOperations.cpp:155

ZonoOpt::HybZono::intersection_over_dims
friend std::unique_ptr< HybZono > intersection_over_dims(const HybZono &Z1, HybZono &Z2, const std::vector< int > &dims)
Computes the generalized intersection of sets Z1 and Z2 over the specified dimensions.
Definition SetOperations.cpp:291

ZonoOpt::HybZono::get_leaves
std::vector< std::unique_ptr< ConZono > > get_leaves(bool remove_redundancy=false, const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, int n_leaves=std::numeric_limits< int >::max(), int contractor_iter=10) const
Computes individual constrained zonotopes whose union is the hybrid zonotope object.
Definition HybZono.cpp:956

ZonoOpt::HybZono::operator*
friend std::unique_ptr< HybZono > operator*(const Eigen::SparseMatrix< zono_float > &R, const HybZono &Z)
affine map with sparse matrix: returns R*Z
Definition HybZono.cpp:1379

ZonoOpt::HybZono::is_hybzono
bool is_hybzono() const
Polymorphic type checking: true if set is a hybrid zonotope.
Definition HybZono.cpp:1320

ZonoOpt::HybZono::contains_point
bool contains_point(const Eigen::Vector< zono_float, -1 > &x, const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, const WarmStartParams &warm_start_params=WarmStartParams()) const
Checks whether the point x is contained in the set object.
Definition HybZono.hpp:399

ZonoOpt::HybZono::do_support
virtual zono_float do_support(const Eigen::Vector< zono_float, -1 > &d, const SolverSettings &settings, std::shared_ptr< OptSolution > *solution, const WarmStartParams &warm_start_params)
Definition HybZono.cpp:1163

ZonoOpt::HybZono::operator|
std::unique_ptr< HybZono > operator|(HybZono &other) const
union
Definition HybZono.cpp:1501

ZonoOpt::HybZono::convex_hull
friend std::unique_ptr< ConZono > convex_hull(const std::vector< std::shared_ptr< HybZono > > &Zs, bool exact)
Computes convex hull of several sets.
Definition SetOperations.cpp:744

ZonoOpt::HybZono::get_nC
virtual int get_nC() const
Returns number of constraints in set definition.
Definition HybZono.hpp:110

ZonoOpt::HybZono::vrep_2_hybzono
friend std::unique_ptr< HybZono > vrep_2_hybzono(const std::vector< Eigen::Matrix< zono_float, -1, -1 > > &Vpolys, bool expose_indicators)
Computes a hybrid zonotope from a union of vertex representation polytopes.
Definition HybZono.cpp:1022

ZonoOpt::HybZono::get_nGb
virtual int get_nGb() const
Returns number of binary generators in set definition.
Definition HybZono.hpp:131

ZonoOpt::HybZono::operator-
std::unique_ptr< HybZono > operator-() const
unary minus: returns -I * this
Definition HybZono.cpp:1420

ZonoOpt::HybZono::zero_one_form
bool zero_one_form
flag to indicate whether the set is in 0-1 or -1-1 form
Definition HybZono.hpp:746

ZonoOpt::HybZono::Gc
Eigen::SparseMatrix< zono_float > Gc
continuous generator matrix
Definition HybZono.hpp:710

ZonoOpt::HybZono::do_optimize_over
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 SolverSettings &settings, std::shared_ptr< OptSolution > *solution, const WarmStartParams &warm_start_params) const
Definition HybZono.cpp:581

ZonoOpt::HybZono::convert_form
virtual void convert_form()
Converts the set representation between -1-1 and 0-1 forms.
Definition HybZono.cpp:54

ZonoOpt::HybZono::print
virtual std::string print() const
Returns set information as a string.
Definition HybZono.cpp:556

ZonoOpt::HybZono::Gb
Eigen::SparseMatrix< zono_float > Gb
binary generator matrix
Definition HybZono.hpp:713

ZonoOpt::HybZono::nG
int nG
total number of factors. nG = nGc + nGb
Definition HybZono.hpp:734

ZonoOpt::HybZono::mi_opt_multisol
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 SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr) const
Definition HybZono.cpp:741

ZonoOpt::HybZono::clone
virtual HybZono * clone() const
Clone method for polymorphic behavior.
Definition HybZono.cpp:18

ZonoOpt::HybZono::set_diff
friend std::unique_ptr< HybZono > set_diff(const HybZono &Z1, HybZono &Z2, zono_float delta_m, bool remove_redundancy, const SolverSettings &settings, std::shared_ptr< OptSolution > *solution, const WarmStartParams &warm_start_params, int n_leaves, int contractor_iter)

ZonoOpt::HybZono::is_conzono
bool is_conzono() const
Polymorphic type checking: true if set is a constrained zonotope.
Definition HybZono.cpp:1311

ZonoOpt::HybZono::halfspace_intersection
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)
Computes the intersection generalized intersection of set Z with halfspace H*x <= f over matrix R.
Definition SetOperations.cpp:322

ZonoOpt::HybZono::do_bounding_box
virtual Box do_bounding_box(const SolverSettings &settings, std::shared_ptr< OptSolution > *solution, const WarmStartParams &warm_start_params)
Definition HybZono.cpp:1194

ZonoOpt::HybZono::optimize_over
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 SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, const WarmStartParams &warm_start_params=WarmStartParams()) const
Solves optimization problem with quadratic objective over the current set.
Definition HybZono.hpp:326

ZonoOpt::HybZono::get_c
virtual Eigen::Vector< zono_float, -1 > get_c() const
Returns center vector.
Definition HybZono.hpp:180

ZonoOpt::HybZono::is_point
bool is_point() const
Polymorphic type checking: true if set is a point.
Definition HybZono.cpp:1298

ZonoOpt::HybZono::~HybZono
virtual ~HybZono()=default

ZonoOpt::HybZono::get_nGc
virtual int get_nGc() const
Returns number of continuous generators in set definition.
Definition HybZono.hpp:124

ZonoOpt::HybZono::do_is_empty
virtual bool do_is_empty(const SolverSettings &settings, std::shared_ptr< OptSolution > *solution, const WarmStartParams &warm_start_params) const
Definition HybZono.cpp:629

ZonoOpt::HybZono::do_project_point
virtual 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
Definition HybZono.cpp:606

ZonoOpt::HybZono::zono_union_2_hybzono
friend std::unique_ptr< HybZono > zono_union_2_hybzono(std::vector< std::shared_ptr< Zono > > &Zs, bool expose_indicators)
Computes a hybrid zonotope from a union of zonotopes.
Definition SetOperations.cpp:992

ZonoOpt::HybZono::operator+=
void operator+=(HybZono &other)
in-place minkowski sum
Definition HybZono.cpp:1364

ZonoOpt::HybZono::set
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)
Reset hybrid zonotope object with the given parameters.
Definition HybZono.cpp:23

ZonoOpt::HybZono::do_contains_point
virtual 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
Definition HybZono.cpp:650

ZonoOpt::HybZono::get_Ab
virtual Eigen::SparseMatrix< zono_float > get_Ab() const
Returns binary constraint matrix.
Definition HybZono.hpp:166

ZonoOpt::HybZono::convex_relaxation
virtual std::unique_ptr< ConZono > convex_relaxation() const
Returns convex relaxation of the hybrid zonotope.
Definition HybZono.cpp:1002

ZonoOpt::HybZono::get_A
virtual Eigen::SparseMatrix< zono_float > get_A() const
Returns constraint matrix.
Definition HybZono.hpp:173

ZonoOpt::HybZono::sharp
bool sharp
flag to indicate whether the set is known to be sharp (i.e., convex relaxation = convex hull)
Definition HybZono.hpp:749

ZonoOpt::HybZono::c
Eigen::Vector< zono_float, -1 > c
center vector
Definition HybZono.hpp:725

ZonoOpt::HybZono::complement
virtual std::unique_ptr< HybZono > complement(const zono_float delta_m=100, const bool remove_redundancy=true, const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, const int n_leaves=std::numeric_limits< int >::max(), const int contractor_iter=10)
Computes the complement of the set Z.
Definition HybZono.hpp:259

ZonoOpt::HybZono::nGb
int nGb
number of binary factors
Definition HybZono.hpp:740

ZonoOpt::HybZono::HybZono
HybZono()=default
Default constructor for HybZono class.

ZonoOpt::HybZono::operator-=
void operator-=(Zono &other)
in-place pontryagin difference
Definition HybZono.cpp:1454

ZonoOpt::HybZono::support
zono_float support(const Eigen::Vector< zono_float, -1 > &d, const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, const WarmStartParams &warm_start_params=WarmStartParams())
Computes support function of the set in the direction d.
Definition HybZono.hpp:380

ZonoOpt::HybZono::is_zono
bool is_zono() const
Polymorphic type checking: true if set is a zonotope.
Definition HybZono.cpp:1304

ZonoOpt::HybZono::get_b
virtual Eigen::Vector< zono_float, -1 > get_b() const
Returns constraint vector.
Definition HybZono.hpp:187

ZonoOpt::HybZono::project_point
Eigen::Vector< zono_float, -1 > project_point(const Eigen::Vector< zono_float, -1 > &x, const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, const WarmStartParams &warm_start_params=WarmStartParams()) const
Returns the projection of the point x onto the set object.
Definition HybZono.hpp:345

ZonoOpt::HybZono::union_of_many
friend std::unique_ptr< HybZono > union_of_many(const std::vector< std::shared_ptr< HybZono > > &Zs, bool preserve_sharpness, bool expose_indicators)
Computes union of several sets.
Definition SetOperations.cpp:449

ZonoOpt::HybZono::find_unused_generators
static std::set< int > find_unused_generators(const Eigen::SparseMatrix< zono_float > &G, const Eigen::SparseMatrix< zono_float > &A)
Definition HybZono.cpp:838

ZonoOpt::HybZono::get_nG
virtual int get_nG() const
Returns number of generators in set definition.
Definition HybZono.hpp:117

ZonoOpt::HybZono::remove_cols
static void remove_cols(Eigen::SparseMatrix< zono_float > &M, const std::set< int > &idx_to_remove)
Definition HybZono.cpp:809

ZonoOpt::HybZono::A
Eigen::SparseMatrix< zono_float > A
constraint matrix A = [Ac, Ab]
Definition HybZono.hpp:716

ZonoOpt::HybZono::b
Eigen::Vector< zono_float, -1 > b
constraint vector
Definition HybZono.hpp:728

ZonoOpt::HybZono::do_complement
virtual std::unique_ptr< HybZono > do_complement(zono_float, bool remove_redundancy, const SolverSettings &settings, std::shared_ptr< OptSolution > *solution, int n_leaves, int contractor_iter)
Definition HybZono.cpp:1263

ZonoOpt::HybZono::operator<<
friend std::ostream & operator<<(std::ostream &os, const HybZono &Z)
Displays set information to the given output stream.
Definition HybZono.cpp:575

ZonoOpt::HybZono::mi_opt
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 SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, const WarmStartParams &warm_start_params=WarmStartParams()) const
Definition HybZono.cpp:676

ZonoOpt::HybZono::project_onto_dims
friend std::unique_ptr< HybZono > project_onto_dims(const HybZono &Z, const std::vector< int > &dims)
Projects set Z onto the dimensions specified in dims.
Definition SetOperations.cpp:125

ZonoOpt::HybZono::intersection
friend std::unique_ptr< HybZono > intersection(const HybZono &Z1, HybZono &Z2, const Eigen::SparseMatrix< zono_float > &R)
Computes the generalized intersection of sets Z1 and Z2 over the matrix R.
Definition SetOperations.cpp:215

ZonoOpt::HybZono::is_empty_set
bool is_empty_set() const
Polymorphic type checking: true if set is empty set object.
Definition HybZono.cpp:1328

ZonoOpt::HybZono::bounding_box
Box bounding_box(const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, const WarmStartParams &warm_start_params=WarmStartParams())
Computes a bounding box of the set object as a Box object.
Definition HybZono.hpp:417

ZonoOpt::HybZono::Ab
Eigen::SparseMatrix< zono_float > Ab
binary constraint matrix
Definition HybZono.hpp:722

ZonoOpt::HybZono::get_G
virtual Eigen::SparseMatrix< zono_float > get_G() const
Returns generator matrix.
Definition HybZono.hpp:152

ZonoOpt::HybZono::affine_inclusion
friend std::unique_ptr< HybZono > affine_inclusion(const HybZono &Z, const IntervalMatrix &R, const Eigen::Vector< zono_float, -1 > &s)
Returns inclusion of zonotopic set for uncertain affine map R*Z + s.
Definition SetOperations.cpp:57

ZonoOpt::HybZono::Ac
Eigen::SparseMatrix< zono_float > Ac
continuous constraint matrix
Definition HybZono.hpp:719

ZonoOpt::HybZono::get_Gb
virtual Eigen::SparseMatrix< zono_float > get_Gb() const
Returns binary generator matrix.
Definition HybZono.hpp:145

ZonoOpt::HybZono::operator*=
void operator*=(zono_float f)
scalar multiplication in place
Definition HybZono.cpp:1415

ZonoOpt::HybZono::is_empty
bool is_empty(const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, const WarmStartParams &warm_start_params=WarmStartParams()) const
Returns true if the set is provably empty, false otherwise.
Definition HybZono.hpp:361

ZonoOpt::HybZono::G
Eigen::SparseMatrix< zono_float > G
generator matrix G = [Gc, Gb]
Definition HybZono.hpp:707

ZonoOpt::HybZono::nGc
int nGc
number of continuous factors
Definition HybZono.hpp:737

ZonoOpt::HybZono::remove_redundancy
virtual std::unique_ptr< HybZono > remove_redundancy(int contractor_iter=10) const
Removes redundant constraints and any unused generators.
Definition HybZono.cpp:83

ZonoOpt::HybZono::get_Ac
virtual Eigen::SparseMatrix< zono_float > get_Ac() const
Returns continuous constraint matrix.
Definition HybZono.hpp:159

ZonoOpt::HybZono::operator+
friend std::unique_ptr< HybZono > operator+(const Eigen::Vector< zono_float, -1 > &v, HybZono &Z)
minkowski sum with point
Definition HybZono.cpp:1346

ZonoOpt::HybZono::operator&
std::unique_ptr< HybZono > operator&(HybZono &other) const
intersection
Definition HybZono.cpp:1496

ZonoOpt::IntervalMatrix
Class for interval matrices (i.e., every element of the matrix is an interval)
Definition IntervalMatrix.hpp:27

ZonoOpt::MI_Box
Mixed-integer box.
Definition Box.hpp:644

ZonoOpt::Zono
Zonotope class.
Definition Zono.hpp:32

zono_float
#define zono_float
Defines the floating-point type used in ZonoOpt.
Definition ZonoOpt.hpp:45

ZonoOpt::pontry_diff
std::unique_ptr< HybZono > pontry_diff(HybZono &Z1, Zono &Z2, bool exact=true)
Computes the Pontryagin difference Z1 - Z2.
Definition SetOperations.cpp:330

ZonoOpt::cartesian_product
std::unique_ptr< HybZono > cartesian_product(const HybZono &Z1, HybZono &Z2)
Computes the Cartesian product of two sets Z1 and Z2.
Definition SetOperations.cpp:797

ZonoOpt::minkowski_sum
std::unique_ptr< HybZono > minkowski_sum(const HybZono &Z1, HybZono &Z2)
Computes Minkowski sum of two sets Z1 and Z2.
Definition SetOperations.cpp:155

ZonoOpt::project_onto_dims
std::unique_ptr< HybZono > project_onto_dims(const HybZono &Z, const std::vector< int > &dims)
Projects set Z onto the dimensions specified in dims.
Definition SetOperations.cpp:125

ZonoOpt::set_diff
std::unique_ptr< HybZono > set_diff(const HybZono &Z1, HybZono &Z2, zono_float delta_m=100, bool remove_redundancy=true, const SolverSettings &settings=get_default_solver_settings(), std::shared_ptr< OptSolution > *solution=nullptr, int n_leaves=std::numeric_limits< int >::max(), int contractor_iter=10)
Set difference Z1 \ Z2.
Definition SetOperations.cpp:973

ZonoOpt::affine_inclusion
std::unique_ptr< HybZono > affine_inclusion(const HybZono &Z, const IntervalMatrix &R, const Eigen::Vector< zono_float, -1 > &s=Eigen::Vector< zono_float, -1 >())
Returns inclusion of zonotopic set for uncertain affine map R*Z + s.
Definition SetOperations.cpp:57

ZonoOpt::affine_map
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 >())
Returns affine map R*Z + s of set Z.
Definition SetOperations.cpp:12

ZonoOpt::union_of_many
std::unique_ptr< HybZono > union_of_many(const std::vector< std::shared_ptr< HybZono > > &Zs, bool preserve_sharpness=false, bool expose_indicators=false)
Computes union of several sets.
Definition SetOperations.cpp:449

ZonoOpt::intersection
std::unique_ptr< HybZono > intersection(const HybZono &Z1, HybZono &Z2, const Eigen::SparseMatrix< zono_float > &R=Eigen::SparseMatrix< zono_float >())
Computes the generalized intersection of sets Z1 and Z2 over the matrix R.
Definition SetOperations.cpp:215

ZonoOpt::convex_hull
std::unique_ptr< ConZono > convex_hull(const std::vector< std::shared_ptr< HybZono > > &Zs, bool exact=true)
Computes convex hull of several sets.
Definition SetOperations.cpp:744

ZonoOpt::constrain
std::unique_ptr< HybZono > constrain(HybZono &Z, const Eigen::SparseMatrix< zono_float > &H, const Eigen::Vector< zono_float, -1 > &f, char direction, const Eigen::SparseMatrix< zono_float > &R=Eigen::SparseMatrix< zono_float >())
Computes the generalized intersection of set Z with H*x <= f, H*x >= f, or H*x = f over matrix R.
Definition SetOperations.cpp:857

ZonoOpt::halfspace_intersection
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 >())
Computes the intersection generalized intersection of set Z with halfspace H*x <= f over matrix R.
Definition SetOperations.cpp:322

ZonoOpt::intersection_over_dims
std::unique_ptr< HybZono > intersection_over_dims(const HybZono &Z1, HybZono &Z2, const std::vector< int > &dims)
Computes the generalized intersection of sets Z1 and Z2 over the specified dimensions.
Definition SetOperations.cpp:291

ZonoOpt::vrep_2_hybzono
std::unique_ptr< HybZono > vrep_2_hybzono(const std::vector< Eigen::Matrix< zono_float, -1, -1 > > &Vpolys, bool expose_indicators=false)
Computes a hybrid zonotope from a union of vertex representation polytopes.
Definition HybZono.cpp:1022

ZonoOpt::zono_union_2_hybzono
std::unique_ptr< HybZono > zono_union_2_hybzono(std::vector< std::shared_ptr< Zono > > &Zs, bool expose_indicators=false)
Computes a hybrid zonotope from a union of zonotopes.
Definition SetOperations.cpp:992

ZonoOpt
Definition ZonoOpt.hpp:58

ZonoOpt::get_default_solver_settings
const SolverSettings & get_default_solver_settings()
Returns a reference to the current program-wide default solver settings.
Definition SolverDataStructures.hpp:388

ZonoOpt::OptSolution
Solution data structure for optimization routines in ZonoOpt library.
Definition SolverDataStructures.hpp:288

ZonoOpt::SolverSettings
Abstract base for all solver settings.
Definition SolverDataStructures.hpp:35

ZonoOpt::WarmStartParams
Warm start parameters for optimization routines in ZonoOpt library.
Definition ADMM.hpp:49