IntervalMatrix.hpp

Go to the documentation of this file.

#ifndef ZONOOPT_INTERVALMATRIX_HPP_
#define ZONOOPT_INTERVALMATRIX_HPP_
 
#include "Interval.hpp"
#include "Box.hpp"
 
namespace ZonoOpt
{
    using namespace detail;
 
    class IntervalMatrix
    {
    public:
        IntervalMatrix() : rows_(0), cols_(0)
        {
        }
 
        IntervalMatrix(size_t rows, size_t cols, const std::vector<Eigen::Triplet<Interval>>& triplets);
 
        IntervalMatrix(const Eigen::Matrix<zono_float, -1, -1>& mat_lb,
                       const Eigen::Matrix<zono_float, -1, -1>& mat_ub);
 
        explicit IntervalMatrix(const Eigen::Matrix<Interval, -1, -1>& mat);
 
        std::vector<std::vector<Interval>> to_array() const;
 
        std::tuple<int, int, std::vector<Eigen::Triplet<Interval>>> to_triplets() const;
 
        Eigen::SparseMatrix<zono_float> center() const;
 
        Eigen::SparseMatrix<zono_float> diam() const;
 
        IntervalMatrix radius() const;
 
        zono_float width() const;
 
        bool is_empty() const;
 
        bool is_single_valued() const;
 
        IntervalMatrix intersect(const IntervalMatrix& other) const;
 
        IntervalMatrix interval_hull(const IntervalMatrix& other) const;
 
        bool contains(const Eigen::SparseMatrix<zono_float>& mat) const;
 
        bool contains_set(const IntervalMatrix& other) const;
 
        Box operator*(const Eigen::Vector<zono_float, -1>& v) const;
 
        Box operator*(const Box& box) const;
 
        IntervalMatrix operator*(zono_float alpha) const;
 
        void operator*=(zono_float alpha);
 
        friend IntervalMatrix operator*(zono_float alpha, const IntervalMatrix& A);
 
        IntervalMatrix operator*(const Interval& interval) const;
 
        friend IntervalMatrix operator*(const Interval& interval, const IntervalMatrix& A);
 
        void operator*=(const Interval& interval);
 
        IntervalMatrix operator/(zono_float alpha) const;
 
        friend IntervalMatrix operator/(zono_float alpha, const IntervalMatrix& A);
 
        void operator/=(zono_float alpha);
 
        IntervalMatrix operator/(const Interval& interval) const;
 
        friend IntervalMatrix operator/(const Interval& interval, const IntervalMatrix& A);
 
        void operator/=(const Interval& interval);
 
        IntervalMatrix operator*(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A) const;
 
        friend IntervalMatrix operator*(const Eigen::SparseMatrix<zono_float, Eigen::RowMajor>& A, const IntervalMatrix& B);
 
        IntervalMatrix operator*(const Eigen::Matrix<zono_float, -1, -1>& A) const;
 
        friend IntervalMatrix operator*(const Eigen::Matrix<zono_float, -1, -1>& A, const IntervalMatrix& B);
 
        IntervalMatrix operator*(const IntervalMatrix& other) const;
 
        void operator*=(const IntervalMatrix& other);
 
        IntervalMatrix operator+(const IntervalMatrix& other) const;
 
        void operator+=(const IntervalMatrix& other);
 
        IntervalMatrix operator+(const Interval& interval) const;
 
        friend IntervalMatrix operator+(const Interval& interval, const IntervalMatrix& mat);
 
        void operator+=(const Interval& interval);
 
        IntervalMatrix operator+(zono_float alpha) const;
 
        friend IntervalMatrix operator+(zono_float alpha, const IntervalMatrix& A);
 
        void operator+=(zono_float alpha);
 
 
        IntervalMatrix operator-(const IntervalMatrix& other) const;
 
        void operator-=(const IntervalMatrix& other);
 
 
        IntervalMatrix operator-(const Interval& interval) const;
 
        friend IntervalMatrix operator-(const Interval& interval, const IntervalMatrix& mat);
 
        void operator-=(const Interval& interval);
 
        IntervalMatrix operator-(zono_float alpha) const;
 
        friend IntervalMatrix operator-(zono_float alpha, const IntervalMatrix& A);
 
        void operator-=(zono_float alpha);
 
        IntervalMatrix operator-() const;
 
        IntervalMatrix operator&(const IntervalMatrix& other) const;
 
        IntervalMatrix operator|(const IntervalMatrix& other) const;
 
        bool operator<=(const IntervalMatrix& other) const;
 
        bool operator>=(const IntervalMatrix& other) const;
 
        bool operator==(const IntervalMatrix& other) const;
 
        size_t rows() const { return rows_; }
 
        size_t cols() const { return cols_; }
 
        std::string print() const;
 
        friend std::ostream& operator<<(std::ostream& os, const IntervalMatrix& interval_matrix);
 
    private:
        size_t rows_, cols_;
        std::vector<std::vector<std::pair<size_t, Interval>>> mat_; // rows->cols->vals
    };
 
}
 
 
#endif