Box.hpp

Go to the documentation of this file.

#ifndef ZONOOPT_BOX_HPP_
#define ZONOOPT_BOX_HPP_
 
#include "Interval.hpp"
 
namespace ZonoOpt
{
    using namespace detail;
 
    class Box
    {
    public:
        // constructors
 
        Box() = default;
 
        explicit Box(const size_t size);
 
        explicit Box(const std::vector<Interval>& vals);
 
        explicit Box(const Eigen::Vector<Interval, -1>& vals);
 
        Box(const Eigen::Vector<zono_float, -1>& x_lb, const Eigen::Vector<zono_float, -1>& x_ub);
 
        std::vector<Interval> to_array() const;
 
        // virtual destructor
        virtual ~Box() = default;
 
        // copy assignment
        Box& operator=(const Box& other);
 
        // copy constructor
        Box(const Box& other);
 
        // element-wise assignment, access
 
        Interval get_element(int i) const;
 
 
        void set_element(int i, const Interval& val);
 
        size_t size() const;
 
        // project onto box
 
        virtual void project(Eigen::Ref<Eigen::Vector<zono_float, -1>> x) const;
 
        virtual Box* clone() const;
 
        // access bounds
        const Eigen::Vector<zono_float, -1>& lower() const { return x_lb; }
 
        const Eigen::Vector<zono_float, -1>& upper() const { return x_ub; }
 
        // width of box
        zono_float width() const;
 
        Box radius() const;
 
        Eigen::Vector<zono_float, -1> center() const;
 
        bool is_empty() const;
 
        bool is_single_valued() const;
 
        Box intersect(const Box& other) const;
 
        Box interval_hull(const Box& other) const;
 
        bool contains(const Eigen::Vector<zono_float, -1>& v);
 
        bool contains_set(const Box& other) const;
 
        // operator overloading
 
        Box operator+(const Box& other) const;
 
        void operator+=(const Box& other);
 
        Box operator+(const Eigen::Vector<zono_float, -1>& v) const;
 
 
        void operator+=(const Eigen::Vector<zono_float, -1>& v);
 
        friend Box operator+(const Eigen::Vector<zono_float, -1>& v, const Box& box);
 
        Box operator-(const Box& other) const;
 
        void operator-=(const Box& other);
 
        Box operator-(const Eigen::Vector<zono_float, -1>& v) const;
 
        void operator-=(const Eigen::Vector<zono_float, -1>& v);
 
        friend Box operator-(const Eigen::Vector<zono_float, -1>& v, const Box& box);
 
        Box operator*(const Box& other) const;
 
        void operator*=(const Box& other);
 
        Box operator*(zono_float alpha) const;
 
        void operator*=(zono_float alpha);
 
        friend Box operator*(zono_float alpha, const Box& box);
 
        Box operator*(const Eigen::Vector<zono_float, -1>& v) const;
 
        void operator*=(const Eigen::Vector<zono_float, -1>& v);
 
        friend Box operator*(const Eigen::Vector<zono_float, -1>& v, const Box& box);
 
        Box operator*(const Interval& interval) const;
 
        void operator*=(const Interval& interval);
 
        friend Box operator*(const Interval& interval, const Box& box);
 
        friend Box operator*(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A, const Box& box);
 
        friend Box operator*(const Eigen::Matrix<zono_float, -1, -1>& A, const Box& box);
 
        Box operator/(const Box& other) const;
 
        void operator/=(const Box& other);
 
        Box operator/(zono_float alpha) const;
 
        void operator/=(zono_float alpha);
 
        friend Box operator/(zono_float alpha, const Box& box);
 
        Box operator/(const Interval& interval) const;
 
        void operator/=(const Interval& interval);
 
        friend Box operator/(const Interval& interval, const Box& box);
 
        Box operator-() const;
 
        Box operator&(const Box& other) const;
 
        Box operator|(const Box& other) const;
 
        bool operator<=(const Box& other) const;
 
        bool operator>=(const Box& other) const;
 
        bool operator==(const Box& other) const;
 
        // interval contractors
 
        bool contract(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A, const Eigen::Vector<zono_float, -1>& b,
                      int iter);
 
        bool contract_subset(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A_rm,
                             const Eigen::Vector<zono_float, -1>& b, int iter,
                             const Eigen::SparseMatrix<zono_float>& A, const std::set<int>& inds,
                             int tree_search_depth);
 
        Box linear_map(const Eigen::Matrix<zono_float, -1, -1>& A) const;
 
        Box linear_map(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A) const;
 
        Interval dot(const Eigen::Vector<zono_float, -1>& x) const;
 
        void permute(const Eigen::PermutationMatrix<Eigen::Dynamic, Eigen::Dynamic>& P);
 
        std::string print() const;
 
        friend std::ostream& operator<<(std::ostream& os, const Box& box);
 
    protected:
        // members
        Eigen::Vector<zono_float, -1> x_lb;
 
        Eigen::Vector<zono_float, -1> x_ub;
 
    private:
        // back end for contraction operator
 
        virtual bool contract_helper(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A,
                                     const Eigen::Vector<zono_float, -1>& b, const int iter,
                                     const std::set<int>& constraints);
 
        bool contract_forward(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A,
                              const Eigen::Vector<zono_float, -1>& b, const std::set<int>& constraints);
 
        void contract_backward(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A,
                               const Eigen::Vector<zono_float, -1>& b, const std::set<int>& constraints);
 
        static void get_vars_cons(const Eigen::SparseMatrix<zono_float>& A,
                                  const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A_rm,
                                  std::set<int>& constraints, std::set<int>& vars, const std::set<int>& new_vars,
                                  int depth, int max_depth);
 
    private:
        friend class MI_Box;
    };
 
    // mixed-integer box (some bounds are fixed)
    class MI_Box final : public Box
    {
    public:
        // constructors
 
        MI_Box() = default;
 
        MI_Box(const Eigen::Vector<zono_float, -1>& x_lb, const Eigen::Vector<zono_float, -1>& x_ub,
               const std::pair<int, int>& idx_b, bool zero_one_form);
 
        MI_Box(const std::vector<Interval>& intervals, const std::pair<int, int>& idx_b, bool zero_one_form);
 
        // clone operation
        Box* clone() const override;
 
        // project
        void project(Eigen::Ref<Eigen::Vector<zono_float, -1>> x) const override;
 
        // get binary indices
        const std::pair<int, int>& binary_indices() const { return idx_b; }
 
        // get binary range
        zono_float get_bin_low() const { return bin_low; }
        zono_float get_bin_high() const { return bin_high; }
 
    protected:
        bool contract_helper(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A,
                             const Eigen::Vector<zono_float, -1>& b, const int iter,
                             const std::set<int>& constraints) override;
 
    private:
        std::pair<int, int> idx_b;
        zono_float bin_low = zero, bin_high = one;
    };
 
 
 
}
 
 
#endif