codac2_Interval.h

Go to the documentation of this file.

 
#pragma once
 
#include <list>
#include <array>
#include <3rd/gaol/gaol_interval.h>
#include "codac2_Index.h"
#include "codac2_Domain.h"
#include "codac2_assert.h"
#include "codac2_TypeInfo.h"
 
namespace codac2
{
  const double oo = []() {
 
    // (from IBEX lib, main author: Gilles Chabert)
    // We use Gaol not in PRESERVE_ROUNDING mode, thus
    // assuming the rounding mode is always set upward.
    // Calling this function in the initialization of
    // the 'oo' constant should be enough as this constant
    // is initialized before the first Codac function call occurs.
    gaol::round_upward();
 
    return std::numeric_limits<double>::infinity();
  }();
 
  class Interval;
 
  template<>
  struct is_interval_based<Interval> : std::true_type {};
 
  template<>
  struct is_ctc<Interval> : std::false_type {};
 
  template<>
  struct is_sep<Interval> : std::false_type {};

  class Interval : protected gaol::interval, public DomainInterface<Interval,double>
  {
    public:
 
      using DegeneratedType = double;

      Interval();

      Interval(double a);

      Interval(double a, double b);

      Interval(const Interval& x);

      explicit Interval(const std::array<double,1>& array);

      explicit Interval(const std::array<double,2>& array);

      Interval(std::initializer_list<double> l);

      Interval& init();

      Interval& init(const Interval& x);

      Interval& init_from_list(const std::list<double>& l);

      Interval& operator=(double x);

      Interval& operator=(const Interval& x);

      bool operator==(const Interval& x) const;

      bool operator!=(const Interval& x) const;

      double lb() const;

      double ub() const;
      
      double mid() const;

      double mag() const;

      double mig() const;

      double rand() const;

      double rad() const;

      double diam() const;

      double volume() const;

      Index size() const;
    
      void set_empty();

      bool is_empty() const;

      bool contains(const double& x) const;

      bool interior_contains(const double& x) const;

      bool is_unbounded() const;

      bool is_degenerated() const;

      bool is_integer() const;

      bool intersects(const Interval &x) const;

      bool is_disjoint(const Interval& x) const;

      bool overlaps(const Interval &x) const;

      bool is_subset(const Interval& x) const;

      bool is_strict_subset(const Interval& x) const;

      bool is_interior_subset(const Interval& x) const;

      bool is_strict_interior_subset(const Interval& x) const;

      bool is_superset(const Interval& x) const;

      bool is_strict_superset(const Interval& x) const;

      Interval& inflate(const double& rad);

      bool is_bisectable() const;

      std::pair<Interval,Interval> bisect(float ratio = 0.49) const;

      std::vector<Interval> complementary(bool compactness = true) const;

      std::vector<Interval> diff(const Interval& y, bool compactness = true) const;

      Interval& operator|=(const Interval& x);

      Interval& operator&=(const Interval& x);

      Interval& operator+=(double x);

      Interval& operator+=(const Interval& x);

      Interval operator-() const;

      Interval& operator-=(double x);

      Interval& operator-=(const Interval& x);

      Interval& operator*=(double x);

      Interval& operator*=(const Interval& x);

      Interval& operator/=(double x);

      Interval& operator/=(const Interval& x);

      static Interval empty();

      static Interval zero();

      static Interval one();

      static Interval half_pi();

      static Interval pi();

      static Interval two_pi();
      
      friend std::ostream& operator<<(std::ostream& os, const Interval& x);
 
      // Getting 'inaccessible' operators from GAOL, required for pybind11
      
        void* operator new(std::size_t size)
        { 
          return ::operator new(size); 
        }
 
        void operator delete(void* ptr)
        { 
          ::operator delete(ptr); 
        }
 
    protected:
      
      Interval(const gaol::interval& x);
 
      #define _dec_friend_interval2_arithm_op(f) \
        friend Interval f(double, const Interval&); \
        friend Interval f(const Interval&, double); \
        friend Interval f(const Interval&, const Interval&); \
 
      _dec_friend_interval2_arithm_op(operator&)
      _dec_friend_interval2_arithm_op(operator|)
      _dec_friend_interval2_arithm_op(operator+)
      _dec_friend_interval2_arithm_op(operator-)
      _dec_friend_interval2_arithm_op(operator*)
      _dec_friend_interval2_arithm_op(operator/)
 
      #define _dec_friend_interval2_unary_op(f) \
        friend Interval f(const Interval&); \
 
      _dec_friend_interval2_unary_op(sqr)
      _dec_friend_interval2_unary_op(sqrt)
      _dec_friend_interval2_unary_op(exp)
      _dec_friend_interval2_unary_op(log)
      _dec_friend_interval2_unary_op(cos)
      _dec_friend_interval2_unary_op(sin)
      _dec_friend_interval2_unary_op(tan)
      _dec_friend_interval2_unary_op(acos)
      _dec_friend_interval2_unary_op(asin)
      _dec_friend_interval2_unary_op(atan)
      _dec_friend_interval2_unary_op(cosh)
      _dec_friend_interval2_unary_op(sinh)
      _dec_friend_interval2_unary_op(tanh)
      _dec_friend_interval2_unary_op(acosh)
      _dec_friend_interval2_unary_op(asinh)
      _dec_friend_interval2_unary_op(atanh)
      _dec_friend_interval2_unary_op(abs)
      _dec_friend_interval2_unary_op(sign)
      _dec_friend_interval2_unary_op(integer)
      _dec_friend_interval2_unary_op(floor)
      _dec_friend_interval2_unary_op(ceil)
 
      #define _dec_friend_interval2_binary_op(f) \
        friend Interval f(const Interval&, const Interval&); \
 
      _dec_friend_interval2_binary_op(max)
      _dec_friend_interval2_binary_op(min)
      _dec_friend_interval2_binary_op(atan2)
 
      friend Interval pow(const Interval&, int);
      friend Interval pow(const Interval&, double);
 
      _dec_friend_interval2_binary_op(pow)
 
      friend Interval root(const Interval&, int);
      friend Interval chi(const Interval&, const Interval&, const Interval&);
 
      friend struct AbsOp;
      friend struct AcosOp;
      friend struct AddOp;
      friend struct ChiOp;
      friend struct DivOp;
      friend struct MulOp;
      friend struct SubOp;
      friend struct AsinOp;
      friend struct AtanOp;
      friend struct Atan2Op;
      friend struct CosOp;
      friend struct CoshOp;
      friend struct DetOp;
      friend struct ExpOp;
      friend struct LogOp;
      friend struct PowOp;
      friend struct SinOp;
      friend struct SinhOp;
      friend struct SqrOp;
      friend struct SqrtOp;
      friend struct TanOp;
      friend struct TanhOp;
  };
      
  std::ostream& operator<<(std::ostream& os, const Interval& x);

  Interval operator""_i(long double x);
 
  double previous_float(double x);
  double next_float(double x);

  Interval operator&(const Interval& x, const Interval& y);

  Interval operator|(const Interval& x, double y);

  Interval operator|(const Interval& x, const Interval& y);

  const Interval& operator+(const Interval& x);

  Interval operator+(const Interval& x, double y);

  Interval operator+(double x, const Interval& y);

  Interval operator+(const Interval& x, const Interval& y);

  Interval operator-(const Interval& x, double y);

  Interval operator-(double x, const Interval& y);

  Interval operator-(const Interval& x, const Interval& y);

  Interval operator*(const Interval& x, double y);

  Interval operator*(double x, const Interval& y);

  Interval operator*(const Interval& x, const Interval& y);

  Interval operator/(const Interval& x, double y);

  Interval operator/(double x, const Interval& y);

  Interval operator/(const Interval& x, const Interval& y);
}
 
#include "codac2_Interval_impl.h"