Interval.hpp

Go to the documentation of this file.

#ifndef ZONOOPT_INTERVAL_HPP_
#define ZONOOPT_INTERVAL_HPP_
 
#include <string>
#include <vector>
#include <set>
#include <Eigen/Dense>
#include <Eigen/Sparse>
#include <cmath>
#include <boost/numeric/interval.hpp>
 
namespace ZonoOpt
{
    namespace detail
    {
        // need this to get inverse hyperbolics to compile with MSVC
        template<class T>
        struct rounded_transc_fixed : boost::numeric::interval_lib::rounded_transc_std<T> {
            static T asinh_down(const T& x) { using std::asinh; return asinh(x); }
            static T asinh_up  (const T& x) { using std::asinh; return asinh(x); }
            static T acosh_down(const T& x) { using std::acosh; return acosh(x); }
            static T acosh_up  (const T& x) { using std::acosh; return acosh(x); }
            static T atanh_down(const T& x) { using std::atanh; return atanh(x); }
            static T atanh_up  (const T& x) { using std::atanh; return atanh(x); }
        };
    }
 
    using namespace detail;
 
 
    class Interval
    {
    public:
        // constructor
 
        Interval() : _val(zero, zero) {}
 
        Interval(const zono_float y_min, const zono_float y_max) : _val(y_min, y_max) {}
 
        Interval* clone() const;
 
        // get methods
 
        zono_float lower() const;
 
        zono_float upper() const;
 
        // operators
 
        Interval operator+(const Interval& other) const;
 
        void operator+=(const Interval& other);
 
        Interval operator+(const zono_float alpha) const;
 
        void operator+=(const zono_float alpha);
 
        friend Interval operator+(const zono_float alpha, const Interval& interval);
 
        Interval operator-(const Interval& other) const;
 
        void operator-=(const Interval& other);
 
        Interval operator-(const zono_float alpha) const;
 
        void operator-=(const zono_float alpha);
 
        friend Interval operator-( const zono_float alpha, const Interval& interval );
 
        Interval operator*(const Interval& other) const;
 
        void operator*=(const Interval& other);
 
        Interval operator*(const zono_float alpha) const;
 
        void operator*=(const zono_float alpha);
 
        friend Interval operator*(const zono_float alpha, const Interval& interval);
 
        Interval operator/(const Interval& other) const;
 
        void operator/=(const Interval& other);
 
        Interval operator/(const zono_float alpha) const;
 
        void operator/=(const zono_float alpha);
 
        friend Interval operator/(const zono_float alpha, const Interval& interval);
 
        Interval operator-() const;
 
        Interval operator&(const Interval& other) const;
 
        Interval operator|(const Interval& other) const;
 
        bool operator<=(const Interval& other) const;
 
        bool operator>=(const Interval& other) const;
        
        bool operator==(const Interval& other) const;
 
        Interval inv() const;
 
        Interval intersect(const Interval& other) const;
 
        Interval interval_hull(const Interval& other) const;
 
        bool contains(const zono_float x) const;
 
        bool contains_set(const Interval& other) const;
 
        bool is_single_valued() const;
 
        bool is_empty() const;
 
        zono_float center() const;
 
        zono_float width() const;
 
        Interval radius() const;
 
        Interval abs() const;
 
        Interval sqrt() const;
 
        Interval pow(const int n) const;
 
        Interval pow(const zono_float f) const;
 
        Interval nth_root(const int n) const;
 
        Interval exp() const;
 
        Interval log() const;
 
        Interval sin() const;
 
        Interval cos() const;
 
        Interval tan() const;
 
        Interval arcsin() const;
 
        Interval arccos() const;
 
        Interval arctan() const;
 
        Interval sinh() const;
 
        Interval cosh() const;
 
        Interval tanh() const;
 
        Interval arcsinh() const;
 
        Interval arccosh() const;
 
        Interval arctanh() const;
 
        std::string print() const;
 
        friend std::ostream& operator<<(std::ostream& os, const Interval& interval);
 
 
    private:
 
        typedef boost::numeric::interval_lib::policies<
            boost::numeric::interval_lib::save_state<rounded_transc_fixed<zono_float>>,
            boost::numeric::interval_lib::checking_base<zono_float>
        > interval_policy;
 
        boost::numeric::interval<zono_float, interval_policy> _val;
 
        explicit Interval(const boost::numeric::interval<zono_float, interval_policy>& val) : _val(val) {}
    };
 
} // namespace ZonoOpt
 
#endif