codac2_Interval.h File Reference

#include <list>
#include <array>
#include <gaol/gaol_interval.h>
#include "codac2_Index.h"
#include "codac2_Domain.h"
#include "codac2_assert.h"
#include "codac2_TypeInfo.h"
#include "codac2_Interval_impl.h"

Include dependency graph for codac2_Interval.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

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

Functions
std::ostream &	codac2::operator<< (std::ostream &os, const Interval &x)
	Streams out this.
Interval	codac2::operator""_i (long double x)
	Codac defined literals allowing to produce an interval from a double.
double	codac2::previous_float (double x)
	Returns the previous representable double-precision floating-point value before x.
double	codac2::next_float (double x)
	Returns the next representable double-precision floating-point value after x.
Interval	codac2::operator& (const Interval &x, const Interval &y)
	Returns the intersection of two intervals: \([x]\cap[y]\).
Interval	codac2::operator| (const Interval &x, double y)
	Returns the squared-union of an interval and a real: \([x]\sqcup\{y\}\).
Interval	codac2::operator| (const Interval &x, const Interval &y)
	Returns the squared-union of two intervals: \([x]\sqcup[y]\).
const Interval &	codac2::operator+ (const Interval &x)
	Returns this.
Interval	codac2::operator+ (const Interval &x, double y)
	Returns \([x]+y\) with \(y\in\mathbb{R}\).
Interval	codac2::operator+ (double x, const Interval &y)
	Returns \(x+[y]\) with \(x\in\mathbb{R}\).
Interval	codac2::operator+ (const Interval &x, const Interval &y)
	Returns \([x]+[y]\).
Interval	codac2::operator- (const Interval &x, double y)
	Returns \([x]-y\) with \(y\in\mathbb{R}\).
Interval	codac2::operator- (double x, const Interval &y)
	Returns \(x-[y]\) with \(x\in\mathbb{R}\).
Interval	codac2::operator- (const Interval &x, const Interval &y)
	Returns \([x]-[y]\).
Interval	codac2::operator* (const Interval &x, double y)
	Returns \([x]*y\) with \(y\in\mathbb{R}\).
Interval	codac2::operator* (double x, const Interval &y)
	Returns \(x*[y]\) with \(x\in\mathbb{R}\).
Interval	codac2::operator* (const Interval &x, const Interval &y)
	Returns \([x]*[y]\).
Interval	codac2::operator/ (const Interval &x, double y)
	Returns \([x]/y\) with \(y\in\mathbb{R}\).
Interval	codac2::operator/ (double x, const Interval &y)
	Returns \(x/[y]\) with \(x\in\mathbb{R}\).
Interval	codac2::operator/ (const Interval &x, const Interval &y)
	Returns \([x]/[y]\).

Detailed Description

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

---

Date

2024

Author

Gilles Chabert, Simon Rohou

Copyright

Copyright 2024 Codac Team

License: GNU Lesser General Public License (LGPL)

Function Documentation

operator<<()

std::ostream & codac2::operator<< ( std::ostream & os, const Interval & x )

inline

Streams out this.

Parameters

os	the stream to be updated
x	the interval to stream out

Returns

a reference to the updated stream

  {
    gaol::interval::precision(os.precision());
    gaol::operator<<(os,x);
    return os;
  }

operator""_i()

Interval codac2::operator""_i ( long double x )

inline

Codac defined literals allowing to produce an interval from a double.

Parameters

x	value to convert into an interval object

Returns

the interval \([x]\)

  {
    return Interval(x);
  }

previous_float()

double codac2::previous_float ( double x )

inline

Returns the previous representable double-precision floating-point value before x.

This function computes the largest double value that is strictly less than the input value x, effectively moving one step down in the floating-point representation.

See also

For obtaining the next representable double value greater than x, use next_float().

Parameters

x	The input double value.

Returns

The previous representable double value before x.

  {
    return gaol::previous_float(x);
  }

next_float()

double codac2::next_float ( double x )

inline

Returns the next representable double-precision floating-point value after x.

This function computes the smallest double value that is strictly greater than the input value x, effectively moving one step up in the floating-point representation.

See also

For obtaining the previous representable double value less than x, use previous_float().

Parameters

x	The input double value.

Returns

The next representable double value after x.

  {
    return gaol::next_float(x);
  }

operator&()

Interval codac2::operator& ( const Interval & x, const Interval & y )

inline

Returns the intersection of two intervals: \([x]\cap[y]\).

Note

Returns an empty interval if there is no intersection.

Parameters

x	interval value
y	interval value

Returns

intersection result

  {
    if(x.is_empty() || y.is_empty() || x.ub() < y.lb())
      return Interval::empty();
    
    else
      return gaol::operator&(x,y);
  }

operator|() [1/2]

Interval codac2::operator| ( const Interval & x, double y )

inline

Returns the squared-union of an interval and a real: \([x]\sqcup\{y\}\).

Note

The squared-union is defined as: \([x]\sqcup[y]=\left[[x]\cup[y]\right]\)

Parameters

x	interval value
y	real value

Returns

squared-union result

  {
    return gaol::operator|(x,Interval(y));
  }

operator|() [2/2]

Interval codac2::operator| ( const Interval & x, const Interval & y )

inline

Returns the squared-union of two intervals: \([x]\sqcup[y]\).

Note

The squared-union is defined as: \([x]\sqcup[y]=\left[[x]\cup[y]\right]\)

Parameters

x	interval value
y	interval value

Returns

squared-union result

  {
    return gaol::operator|(x,y);
  }

operator+() [1/4]

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

inline

Returns this.

Note

This operator is only provided for consistency purposes.

Parameters

x	interval value

Returns

the same interval

  {
    return x;
  }

operator+() [2/4]

Interval codac2::operator+ ( const Interval & x, double y )

inline

Returns \([x]+y\) with \(y\in\mathbb{R}\).

Parameters

x	interval value
y	real value

Returns

the addition result

  {
    if(y == -oo || y == oo)
      return Interval::empty();
 
    else
      return gaol::operator+(x,y);
  }

operator+() [3/4]

Interval codac2::operator+ ( double x, const Interval & y )

inline

Returns \(x+[y]\) with \(x\in\mathbb{R}\).

Parameters

x	real value
y	interval value

Returns

the addition result

  {
    if(x == -oo || x == oo)
      return Interval::empty();
 
    else
      return gaol::operator+(x,y);
  }

operator+() [4/4]

Interval codac2::operator+ ( const Interval & x, const Interval & y )

inline

Returns \([x]+[y]\).

Parameters

x	interval value
y	interval value

Returns

the addition result

  {
    return gaol::operator+(x,y);
  }

operator-() [1/3]

Interval codac2::operator- ( const Interval & x, double y )

inline

Returns \([x]-y\) with \(y\in\mathbb{R}\).

Parameters

x	interval value
y	real value

Returns

the substraction result

  {
    if(y == -oo || y == oo)
      return Interval::empty();
 
    else
      return gaol::operator-(x, y);
  }

operator-() [2/3]

Interval codac2::operator- ( double x, const Interval & y )

inline

Returns \(x-[y]\) with \(x\in\mathbb{R}\).

Parameters

x	real value
y	interval value

Returns

the substraction result

  {
    if(x == -oo || x == oo)
      return Interval::empty();
 
    else
      return gaol::operator-(x, y);
  }

operator-() [3/3]

Interval codac2::operator- ( const Interval & x, const Interval & y )

inline

Returns \([x]-[y]\).

Parameters

x	interval value
y	interval value

Returns

the substraction result

  {
    return gaol::operator-(x, y);
  }

operator*() [1/3]

Interval codac2::operator* ( const Interval & x, double y )

inline

Returns \([x]*y\) with \(y\in\mathbb{R}\).

Parameters

x	interval value
y	real value

Returns

the multiplication result

  {
    if(y == -oo || y == oo)
      return Interval::empty();
 
    else
      return gaol::operator*(x,y);
  }

operator*() [2/3]

Interval codac2::operator* ( double x, const Interval & y )

inline

Returns \(x*[y]\) with \(x\in\mathbb{R}\).

Parameters

x	real value
y	interval value

Returns

the multiplication result

  {
    if(x == -oo || x == oo)
      return Interval::empty();
 
    else
      return gaol::operator*(x,y);
  }

operator*() [3/3]

Interval codac2::operator* ( const Interval & x, const Interval & y )

inline

Returns \([x]*[y]\).

Parameters

x	interval value
y	interval value

Returns

the multiplication result

  {
    return gaol::operator*(x,y);
  }

operator/() [1/3]

Interval codac2::operator/ ( const Interval & x, double y )

inline

Returns \([x]/y\) with \(y\in\mathbb{R}\).

Parameters

x	interval value
y	real value

Returns

the division result

  {
    if(y == -oo || y == oo)
      return Interval::empty();
 
    else
      return gaol::operator/(x,y);
  }

operator/() [2/3]

Interval codac2::operator/ ( double x, const Interval & y )

inline

Returns \(x/[y]\) with \(x\in\mathbb{R}\).

Parameters

x	real value
y	interval value

Returns

the division result

  {
    if(x == -oo || x == oo)
      return Interval::empty();
 
    else
      return gaol::operator/(x,y);
  }

operator/() [3/3]

Interval codac2::operator/ ( const Interval & x, const Interval & y )

inline

Returns \([x]/[y]\).

Parameters

x	interval value
y	interval value

Returns

the division result

  {
    return gaol::operator/(x,y);
  }