codac2::Interval Class Reference

Interval class, for representing closed and connected subsets of \(\mathbb{R}\). More...

#include <codac2_Interval.h>

Public Member Functions
	Interval ()
	Creates an interval \([-\infty,\infty]\).
	Interval (double a)
	Creates a degenerate interval \([a,a]\), \(a\in\mathbb{R}\).
	Interval (double a, double b)
	Creates an interval \([a,b]\), \(a\in\mathbb{R}, b\in\mathbb{R}\).
	Interval (const Interval &x)
	Creates an interval from another one.
	Interval (const std::array< double, 1 > &array)
	Create an interval \([a,a]\) from a fixed-sized array of size 1.
	Interval (const std::array< double, 2 > &array)
	Create an interval \([a,b]\) from a fixed-sized array of size 2.
	Interval (std::initializer_list< double > l)
	Create an interval as the hull of a list of values.
Interval &	init (const Interval &x)
	Sets the value of this interval to x.
Interval &	init_from_list (const std::list< double > &l)
	Sets the bounds as the hull of a list of values.
Interval &	operator= (double x)
	Sets this to x.
Interval &	operator= (const Interval &x)
	Sets this to x.
bool	operator== (const Interval &x) const
	Comparison (equality) between two intervals.
bool	operator!= (const Interval &x) const
	Comparison (non equality) between two intervals.
double	lb () const
	Returns the lower bound of this.
double	ub () const
	Returns the upper bound of this.
double	mid () const
	Returns the midpoint of this.
double	mag () const
	Returns the magnitude of this i.e. max(|lower bound|, |upper bound|).
double	mig () const
	Returns the mignitude of this.
double	rand () const
	Returns a random value inside the interval.
double	rad () const
	Returns the radius of this.
double	diam () const
	Returns the diameter of this.
double	volume () const
	Returns the diameter of this.
Index	size () const
	Returns the dimension of this (which is always )
void	set_empty ()
	Sets this interval to the empty set.
bool	is_empty () const
	Tests if this is empty.
bool	contains (const double &x) const
	Tests if this contains x.
bool	interior_contains (const double &x) const
	Tests if the interior of this contains x.
bool	is_unbounded () const
	Tests if one of the bounds of this is infinite.
bool	is_degenerated () const
	Tests if this is degenerated, that is, in the form of \([a,a]\).
bool	intersects (const Interval &x) const
	Tests if this and x intersect.
bool	is_disjoint (const Interval &x) const
	Tests if this and x do not intersect.
bool	overlaps (const Interval &x) const
	Tests if this and x intersect and their intersection has a non-null volume.
bool	is_subset (const Interval &x) const
	Tests if this is a subset of x.
bool	is_strict_subset (const Interval &x) const
	Tests if this is a subset of x and not x itself.
bool	is_interior_subset (const Interval &x) const
	Tests if this is in the interior of x.
bool	is_strict_interior_subset (const Interval &x) const
	Tests if this is in the interior of x and different from x.
bool	is_superset (const Interval &x) const
	Tests if this is a superset of x.
bool	is_strict_superset (const Interval &x) const
	Tests if this is a superset of x and different from x.
Interval &	inflate (const double &rad)
	Adds [-rad,+rad] to this.
bool	is_bisectable () const
	Tests if this can be bisected into two non-degenerated intervals.
std::pair< Interval, Interval >	bisect (float ratio=0.49) const
	Bisects this into two subintervals.
std::vector< Interval >	complementary (bool compactness=true) const
	Computes the complementary of this.
std::vector< Interval >	diff (const Interval &y, bool compactness=true) const
	Computes the result of \([x]\[y]\).
Interval &	operator|= (const Interval &x)
	Self union of this and x.
Interval &	operator&= (const Interval &x)
	Self intersection of this and x.
Interval &	operator+= (double x)
	Self addition of this and a real x.
Interval &	operator+= (const Interval &x)
	Self addition of this and x.
Interval	operator- () const
	Substraction of this.
Interval &	operator-= (double x)
	Self substraction of this and a real x.
Interval &	operator-= (const Interval &x)
	Self substraction of this and x.
Interval &	operator*= (double x)
	Self multiplication of this and a real x.
Interval &	operator*= (const Interval &x)
	Self multiplication of this and x.
Interval &	operator/= (double x)
	Self division of this and a real x.
Interval &	operator/= (const Interval &x)
	Self division of this and x.

Static Public Member Functions
static Interval	empty ()
	Provides an empty interval.
static Interval	zero ()
	Provides an interval for \([0]\).
static Interval	one ()
	Provides an interval for \([1]\).
static Interval	half_pi ()
	Provides an interval for \([\frac{\pi}{2}]\).
static Interval	pi ()
	Provides an interval for \([\pi]\).
static Interval	two_pi ()
	Provides an interval for \([2\pi]\).

Detailed Description

Interval class, for representing closed and connected subsets of \(\mathbb{R}\).

The class also encapsulates the interval representation provided by the Gaol library.

This class reuses several functions developed for ibex::Interval. See ibex::Interval (IBEX lib, main author: Gilles Chabert) https://ibex-lib.readthedocs.io

Constructor & Destructor Documentation

Interval() [1/6]

codac2::Interval::Interval ( double a )

inline

Creates a degenerate interval \([a,a]\), \(a\in\mathbb{R}\).

Parameters

a	single value contained in the resulting interval

    : gaol::interval(a)
  {
    if(a == -oo || a == oo)
      set_empty();
  }

Interval() [2/6]

codac2::Interval::Interval ( double a, double b )

inline

Creates an interval \([a,b]\), \(a\in\mathbb{R}, b\in\mathbb{R}\).

Parameters

a	lower bound of the interval
b	upper bound of the interval

    : gaol::interval(a,b)
  { }

Interval() [3/6]

codac2::Interval::Interval ( const Interval & x )

inline

Creates an interval from another one.

Parameters

x	the interval to be copied

    : gaol::interval(x)
  { }

Interval() [4/6]

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

inlineexplicit

Create an interval \([a,a]\) from a fixed-sized array of size 1.

Parameters

array

the array of doubles

    : Interval(array[0])
  { }

Interval() [5/6]

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

inlineexplicit

Create an interval \([a,b]\) from a fixed-sized array of size 2.

Parameters

array

the array of doubles

    : Interval(array[0],array[1])
  { }

Interval() [6/6]

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

inline

Create an interval as the hull of a list of values.

Parameters

l	list of values contained in the resulting interval

    : Interval()
  {
    init_from_list(l);
  }

Member Function Documentation

init()

Interval & codac2::Interval::init ( const Interval & x )

inline

Sets the value of this interval to x.

Note

This function is used for template purposes.

Parameters

x	the value for re-initialization

Returns

a reference to this

  {
    *this = x;
    return *this;
  }

init_from_list()

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

inline

Sets the bounds as the hull of a list of values.

Note

This function is separated from the constructor for py binding purposes.

Parameters

l	list of values contained in the resulting interval

Returns

a reference to this

  {
    if(l.size() == 1)
      *this = Interval(*l.begin());
 
    else if(l.size() == 2)
      *this = Interval(*l.begin(),*std::prev(l.end()));
 
    else
    {
      assert_release("'Interval' can only be defined by one or two 'double' values.");
    }
 
    return *this;
  }

operator=() [1/2]

Interval & codac2::Interval::operator= ( double x )

inline

Sets this to x.

Parameters

x	real to be intervalized

Returns

a reference to this

  {
    if(x == -oo || x == oo)
      set_empty();
    else
      gaol::interval::operator=(x);
 
    return *this;
  }

operator=() [2/2]

Interval & codac2::Interval::operator= ( const Interval & x )

inline

Sets this to x.

Parameters

x	interval to be copied

Returns

a reference to this

  {
    gaol::interval::operator=(x);
    return *this;
  }

operator==()

bool codac2::Interval::operator== ( const Interval & x ) const

inline

Comparison (equality) between two intervals.

Parameters

x	interval to be compared with

Returns

true iff this and x are exactly the same intervals

  {
    return (is_empty() && x.is_empty()) || (lb() == x.lb() && ub() == x.ub());
  }

operator!=()

bool codac2::Interval::operator!= ( const Interval & x ) const

inline

Comparison (non equality) between two intervals.

Parameters

x	interval to be compared with

Returns

true iff this and x are not exactly the same intervals

  {
    return !(*this == x);
  }

lb()

double codac2::Interval::lb ( ) const

inline

Returns the lower bound of this.

Returns

lower bound

  {
    return gaol::interval::left();
  }

ub()

double codac2::Interval::ub ( ) const

inline

Returns the upper bound of this.

Returns

upper bound

  {
    return gaol::interval::right();
  }

mid()

double codac2::Interval::mid ( ) const

inline

Returns the midpoint of this.

Note

The return point is guaranteed to be included in this but not necessarily to be the closest floating point from the real midpoint. In particular, cases are:

• [empty] -> Quiet NaN
• [-oo,+oo] -> mid = 0.0
• [-oo,b] -> mid = -MAXREAL
• [a,+oo] -> mid = MAXREAL
• [a,b] -> mid ~ a + .5*(b-a)

Returns

midpoint

  {
    double m = gaol::interval::midpoint();
    gaol::round_upward();
    return m;
  }

mag()

double codac2::Interval::mag ( ) const

inline

Returns the magnitude of this i.e. max(|lower bound|, |upper bound|).

Returns

the magnitude of the interval

  {
    return gaol::interval::mag();
  }

mig()

double codac2::Interval::mig ( ) const

inline

Returns the mignitude of this.

+(lower bound) if lower_bound > 0 -(upper bound) if upper_bound < 0 0 otherwise.

Returns

the mignitude of the interval

  {
    return gaol::interval::mig();
  }

rand()

double codac2::Interval::rand ( ) const

inline

Returns a random value inside the interval.

Note

The seed of the pseudo-random number generator is voluntarily initialized outside this function, on demand.

In case of infinite bounds, only floating point values can be returned.

Returns

random value

  {
    if(is_empty())
      return std::numeric_limits<double>::quiet_NaN();
 
    double a = std::max<double>(next_float(-oo),lb());
    double b = std::min<double>(previous_float(oo),ub());
    double r = a + (((double)std::rand())/(double)RAND_MAX)*(b-a);
    // The above operation may result in a floating point outside the bounds,
    // due to floating-point errors. Such possible error is corrected below:
    return std::max<double>(lb(),std::min<double>(r,ub()));
  }

rad()

double codac2::Interval::rad ( ) const

inline

Returns the radius of this.

Returns

the radius, or 0 if this is empty

  {
    if(is_empty())
      return std::numeric_limits<double>::quiet_NaN();
 
    else if(is_unbounded())
      return oo;
 
    else
    {
      double t = mid();
      double t1 = (t-*this).ub();
      double t2 = (*this-t).ub();
      return (t1>t2) ? t1 : t2;
    }
  }

diam()

double codac2::Interval::diam ( ) const

inline

Returns the diameter of this.

Returns

the diameter, or 0 if this is empty

  {
    if(is_empty())
      return std::numeric_limits<double>::quiet_NaN();
 
    else
    {
      double d = gaol::interval::width();
      gaol::round_upward();
      return d;
    }
  }

volume()

double codac2::Interval::volume ( ) const

inline

Returns the diameter of this.

Note

This function is used for template purposes. See diam()

Returns

the diameter, or 0 if this is empty

  {
    return diam();
  }

size()

Index codac2::Interval::size ( ) const

inline

Returns the dimension of this (which is always )

Note

This function is used for template purposes.

Returns

1

  {
    return 1;
  }

is_empty()

bool codac2::Interval::is_empty ( ) const

inline

Tests if this is empty.

Returns

true in case of empty set

  {
    return gaol::interval::is_empty();
  }

contains()

bool codac2::Interval::contains ( const double & x ) const

inline

Tests if this contains x.

Note

x can also be an "open bound", i.e., infinity. So this function is not restricted to a set-membership interpretation.

Parameters

x	real value

Returns

true if this contains x

  {
    return gaol::interval::set_contains(x);
  }

interior_contains()

bool codac2::Interval::interior_contains ( const double & x ) const

inline

Tests if the interior of this contains x.

Parameters

x	real value

Returns

true if the interior of this contains x

  {
    return !is_empty() && x > lb() && x < ub();
  }

is_unbounded()

bool codac2::Interval::is_unbounded ( ) const

inline

Tests if one of the bounds of this is infinite.

Note

An empty interval is always bounded

Returns

true if of the bounds of this is infinite

  {
    return !gaol::interval::is_finite();
  }

is_degenerated()

bool codac2::Interval::is_degenerated ( ) const

inline

Tests if this is degenerated, that is, in the form of \([a,a]\).

Note

An empty interval is considered here as degenerated

Returns

true if this is degenerated

  {
    return is_empty() || gaol::interval::is_a_double();
  }

intersects()

bool codac2::Interval::intersects ( const Interval & x ) const

inline

Tests if this and x intersect.

Parameters

x	the other interval

Returns

true if the intervals intersect

  {
    return !is_empty() && !x.is_empty() && lb() <= x.ub() && ub() >= x.lb();
  }

is_disjoint()

bool codac2::Interval::is_disjoint ( const Interval & x ) const

inline

Tests if this and x do not intersect.

Parameters

x	the other interval

Returns

true if the intervals are disjoint

  {
    return is_empty() || x.is_empty() || lb() > x.ub() || ub() < x.lb();
  }

overlaps()

bool codac2::Interval::overlaps ( const Interval & x ) const

inline

Tests if this and x intersect and their intersection has a non-null volume.

Parameters

x	the other interval

Returns

true if some interior points (of this or x) belong to their intersection

  {
    return !is_empty() && !x.is_empty() && ub() > x.lb() && x.ub() > lb();
  }

is_subset()

bool codac2::Interval::is_subset ( const Interval & x ) const

inline

Tests if this is a subset of x.

Note

If this is empty, always returns true

Parameters

x	the other interval

Returns

true iff this interval is a subset of x

  {
    return is_empty() || (!x.is_empty() && x.lb() <= lb() && x.ub() >= ub());
  }

is_strict_subset()

bool codac2::Interval::is_strict_subset ( const Interval & x ) const

inline

Tests if this is a subset of x and not x itself.

Note

In particular, \([-\infty,\infty]\) is not a strict subset of \([-\infty,\infty]\) and \(\varnothing\) is not a strict subset of \(\varnothing\), although in both cases, the first is inside the interior of the second.

Parameters

x	the other interval

Returns

true iff this interval is a strict subset of x

  {
    return !x.is_empty() && (is_empty() || (x.lb() < lb() && x.ub() >= ub()) || (x.ub() > ub() && x.lb() <= lb()));
  }

is_interior_subset()

bool codac2::Interval::is_interior_subset ( const Interval & x ) const

inline

Tests if this is in the interior of x.

Note

In particular, \([-\infty,\infty]\) is in the interior of \([-\infty,\infty]\) and \(\varnothing\) is in the interior of \(\varnothing\).

Parameters

x	the other interval

Returns

true iff this interval is in the interior of x

  {
    return is_empty() || (!x.is_empty() && (x.lb() == -oo || x.lb() < lb()) && (x.ub() == oo || x.ub() > ub()));
  }

is_strict_interior_subset()

bool codac2::Interval::is_strict_interior_subset ( const Interval & x ) const

inline

Tests if this is in the interior of x and different from x.

Note

In particular, \([-\infty,\infty]\) is not strictly in the interior of \([-\infty,\infty]\) and \(\varnothing\) is not strictly in the interior of \(\varnothing\).

Parameters

x	the other interval

Returns

true iff this interval is a strict interior subset of x

  {
    return !x.is_empty() && (is_empty() || (
         (x.lb() < lb() && (x.ub() == oo  || x.ub() > ub()))
      || (x.ub() > ub() && (x.lb() == -oo || x.lb() < lb()))
    ));
  }

is_superset()

bool codac2::Interval::is_superset ( const Interval & x ) const

inline

Tests if this is a superset of x.

Note

If this is empty, always returns true

Parameters

x	the other interval

Returns

true iff this interval is a superset of x

  {
    return x.is_subset(*this);
  }

is_strict_superset()

bool codac2::Interval::is_strict_superset ( const Interval & x ) const

inline

Tests if this is a superset of x and different from x.

See also

is_strict_subset()

Parameters

x	the other interval

Returns

true iff this interval is a strict superset of x

  {
    return x.is_strict_subset(*this);
  }

inflate()

Interval & codac2::Interval::inflate ( const double & rad )

inline

Adds [-rad,+rad] to this.

Parameters

rad	the radius of the inflation

Returns

a reference to this

  {
    (*this) += Interval(-rad,rad);
    return *this;
  }

is_bisectable()

bool codac2::Interval::is_bisectable ( ) const

inline

Tests if this can be bisected into two non-degenerated intervals.

Note

Examples of non bisectable intervals are [0,next_float(0)] or [DBL_MAX,+oo).

Returns

true iff this can be bisected

  {
    if(is_empty())
      return false;
    double m = mid();
    return lb() < m && m < ub();
  }

bisect()

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

inline

Bisects this into two subintervals.

Precondition

is_bisectable() must be true

0 < ratio < 1

Parameters

ratio

optional proportion of split (0.5 corresponds to middle)

Returns

a pair of resulting subintervals

  {
    assert_release(is_bisectable());
    assert_release(Interval(0,1).interior_contains(ratio));
 
    if(lb() == -oo)
    {
      if(ub() == oo)
        return { Interval(-oo,0), Interval(0,oo) };
      else
        return { Interval(-oo,-std::numeric_limits<double>::max()), Interval(-std::numeric_limits<double>::max(),ub()) };
    }
 
    else if(ub() == oo)
      return { Interval(lb(),std::numeric_limits<double>::max()), Interval(std::numeric_limits<double>::max(),oo) };
 
    else
    {
      double m;
 
      if(ratio == 0.5)
        m = mid();
 
      else
      {
        m = lb() + ratio*diam();
        if(m >= ub())
          m = next_float(lb());
 
        assert(m < ub());
      }
 
      return { Interval(lb(),m), Interval(m,ub()) };
    }
  }

complementary()

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

inline

Computes the complementary of this.

Parameters

compactness

optional boolean to obtain or not disjoint intervals

Returns

a vector of complementary intervals

  {
    if(is_empty() || (compactness && is_degenerated()))
      return { {-oo,oo} };
 
    std::vector<Interval> l;
 
    if(lb() > -oo)
      l.push_back({-oo,lb()});
 
    if(ub() < oo)
      l.push_back({ub(),oo});
 
    return l;
  }

diff()

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

inline

Computes the result of \([x]\[y]\).

Parameters

y	interval to remove from this
compactness	optional boolean to obtain or not disjoint intervals

Returns

a vector of resulting diff intervals

  {
    if(compactness && is_degenerated())
    {
      if(is_empty() || y.contains(lb()))
        return {};
      else
        return { *this };
    }
 
    std::vector<Interval> l;
    for(const auto& li : y.complementary(compactness))
    {
      Interval inter = li & *this;
      if(!inter.is_degenerated())
        l.push_back(inter);
    }
 
    return l;
  }

operator|=()

Interval & codac2::Interval::operator|= ( const Interval & x )

inline

Self union of this and x.

Parameters

x	the other interval

Returns

a reference to this

  {
    gaol::interval::operator|=(x);
    return *this;
  }

operator&=()

Interval & codac2::Interval::operator&= ( const Interval & x )

inline

Self intersection of this and x.

Parameters

x	the other interval

Returns

a reference to this

  {
    gaol::interval::operator&=(x);
    return *this;
  }

operator+=() [1/2]

Interval & codac2::Interval::operator+= ( double x )

inline

Self addition of this and a real x.

Parameters

x	the real to add

Returns

a reference to this

  {
    if(x == -oo || x == oo)
      set_empty();
    else
      gaol::interval::operator+=(x);
    return *this;
  }

operator+=() [2/2]

Interval & codac2::Interval::operator+= ( const Interval & x )

inline

Self addition of this and x.

Parameters

x	the other interval

Returns

a reference to this

  {
    gaol::interval::operator+=(x);
    return *this;
  }

operator-()

Interval codac2::Interval::operator- ( ) const

inline

Substraction of this.

Returns

(- this)

  {
    return 0.-*this;
  }

operator-=() [1/2]

Interval & codac2::Interval::operator-= ( double x )

inline

Self substraction of this and a real x.

Parameters

x	the real to substract

Returns

a reference to this

  {
    if(x == -oo || x == oo)
      set_empty();
    else
      gaol::interval::operator-=(x);
    return *this;
  }

operator-=() [2/2]

Interval & codac2::Interval::operator-= ( const Interval & x )

inline

Self substraction of this and x.

Parameters

x	the other interval

Returns

a reference to this

  {
    gaol::interval::operator-=(x);
    return *this;
  }

operator*=() [1/2]

Interval & codac2::Interval::operator*= ( double x )

inline

Self multiplication of this and a real x.

Parameters

x	the real to multiply

Returns

a reference to this

  {
    if(x == -oo || x == oo)
      set_empty();
    else
      gaol::interval::operator*=(x);
    return *this;
  }

operator*=() [2/2]

Interval & codac2::Interval::operator*= ( const Interval & x )

inline

Self multiplication of this and x.

Parameters

x	the other interval

Returns

a reference to this

  {
    gaol::interval::operator*=(x);
    return *this;
  }

operator/=() [1/2]

Interval & codac2::Interval::operator/= ( double x )

inline

Self division of this and a real x.

Parameters

x	the real to divide

Returns

a reference to this

  {
    if(x == -oo || x == oo)
      set_empty();
    else
      gaol::interval::operator/=(x);
    return *this;
  }

operator/=() [2/2]

Interval & codac2::Interval::operator/= ( const Interval & x )

inline

Self division of this and x.

Note

This computation is more efficient than the non-self div operator, because it calculates the union of this/x as intermediate result.

Parameters

x	the other interval

Returns

a reference to this

  {
    gaol::interval::operator/=(x);
    return *this;
  }

empty()

Interval codac2::Interval::empty ( )

inlinestatic

Provides an empty interval.

Returns

an empty set

  {
    return std::numeric_limits<double>::quiet_NaN();
  }

zero()

Interval codac2::Interval::zero ( )

inlinestatic

Provides an interval for \([0]\).

Returns

an interval containing \(0\)

  {
    return gaol::interval::zero();
  }

one()

Interval codac2::Interval::one ( )

inlinestatic

Provides an interval for \([1]\).

Returns

an interval containing \(1\)

  {
    return gaol::interval::one();
  }

half_pi()

Interval codac2::Interval::half_pi ( )

inlinestatic

Provides an interval for \([\frac{\pi}{2}]\).

Returns

an interval containing \(\frac{\pi}{2}\)

  {
    return gaol::interval::half_pi();
  }

pi()

Interval codac2::Interval::pi ( )

inlinestatic

Provides an interval for \([\pi]\).

Returns

an interval containing \(\pi\)

  {
    return gaol::interval::pi();
  }

two_pi()

Interval codac2::Interval::two_pi ( )

inlinestatic

Provides an interval for \([2\pi]\).

Returns

an interval containing \(2\pi\)

  {
    return gaol::interval::two_pi();
  }

---

The documentation for this class was generated from the following files:

• /home/simon/codac-simon/src/core/domains/interval/codac2_Interval.h
• /home/simon/codac-simon/src/core/domains/interval/codac2_Interval_impl.h