codac2::Slice< T > Class Template Reference

Codomain of a sliced tube over one temporal slice. More...

#include <codac2_Slice.h>

Inheritance diagram for codac2::Slice< T >:

Collaboration diagram for codac2::Slice< T >:

Public Member Functions
	Slice (const SlicedTubeBase &tube, const std::list< TSlice >::iterator &it_tslice, const T &codomain)
	Creates a slice attached to a tube over a temporal slice.
	Slice (const Slice &s, const SlicedTubeBase &tube)
	Creates a slice from another one for a given tube.
const SlicedTube< T > &	tube () const
	Returns the sliced tube owning this slice.
std::shared_ptr< SliceBase >	copy () const override
	Duplicates this slice.
Index	size () const
	Returns the codomain dimension.
T &	codomain ()
	Returns a mutable reference to the codomain.
const T &	codomain () const
	Returns a constant reference to the codomain.
bool	is_gate () const
	Tests whether this slice is a gate.
std::shared_ptr< const Slice< T > >	prev_slice () const
	Returns the previous slice.
std::shared_ptr< Slice< T > >	prev_slice ()
	Returns the previous slice.
std::shared_ptr< const Slice< T > >	next_slice () const
	Returns the next slice.
std::shared_ptr< Slice< T > >	next_slice ()
	Returns the next slice.
T	input_gate () const
	Returns the input gate of this slice.
T	output_gate () const
	Returns the output gate of this slice.
std::pair< T, T >	enclosed_bounds (const Interval &t) const
	Returns enclosed lower and upper bounds over a temporal interval.
void	set (const T &x, bool propagate=true)
	Sets the codomain of this slice.
void	init ()
	Initializes this codomain to its unbounded value.
void	set_empty ()
	Sets this codomain to the empty set.
bool	operator== (const Slice &x) const
	Compares two slices.
ConvexPolygon	polygon_slice (const Slice< T > &v) const
	Returns the polygonal enclosure associated with this scalar slice.
ConvexPolygon	polygon_slice_i (const Slice< T > &v, Index i) const
	Returns the polygonal enclosure associated with one component of a vector slice.
T	operator() (double t) const
	Returns the evaluation of this slice at \(t\).
T	operator() (const Interval &t) const
	Returns the evaluation of this slice over \([t]\).
T	operator() (double t, const Slice< T > &v) const
	Returns the optimal evaluation of this slice at \(t\), based on the derivative information \(\llbracket v\rrbracket(\cdot)\).
T	operator() (const Interval &t, const Slice< T > &v) const
	Returns the optimal evaluation of this slice over \([t]\), based on the derivative information \(\llbracket v\rrbracket(\cdot)\).
Interval	invert (const T &y, const Interval &t=Interval()) const
	Returns the interval inversion \(\llbracket x\rrbracket^{-1}([y])\).
Interval	invert (const T &y, const Slice< T > &v, const Interval &t=Interval()) const
	Returns the optimal interval inversion \(\llbracket x\rrbracket^{-1}([y])\).
T	all_reals_value () const
	Returns the unbounded value associated with this codomain type.
T	empty_value () const
	Returns the empty value associated with this codomain type.
Public Member Functions inherited from codac2::SliceBase
virtual	~SliceBase ()=default
	Virtual destructor.
const Interval &	t0_tf () const
	Returns the temporal domain of this slice.
const TSlice &	tslice () const
	Returns the temporal slice associated with this object.
std::shared_ptr< const SliceBase >	prev_slice () const
	Returns the previous slice of the same tube.
std::shared_ptr< const SliceBase >	next_slice () const
	Returns the next slice of the same tube.

Protected Member Functions
void	set_empty (bool propagate)
	Sets this codomain to the empty set.
void	update_adjacent_codomains ()
	Propagates codomain contractions to adjacent gates.
Protected Member Functions inherited from codac2::SliceBase
	SliceBase (const SlicedTubeBase &tube, const std::list< TSlice >::iterator &it_tslice)
	Creates a slice attached to a tube and a temporal slice.

Additional Inherited Members
Protected Attributes inherited from codac2::SliceBase
const SlicedTubeBase &	_tube
	Parent sliced tube.
std::list< TSlice >::iterator	_it_tslice
	Iterator to the associated temporal slice.

Detailed Description

template<class T>
class codac2::Slice< T >

Codomain of a sliced tube over one temporal slice.

A Slice<T> represents the codomain of a SlicedTube<T> over one temporal interval of a TDomain.

This object is attached to one temporal slice TSlice and stores a codomain of type T. The type T is typically Interval or IntervalVector, or any custom domain implemented by the user.

The inheritance from T is protected so that modifications of the codomain remain controlled by the Slice interface. Indeed, changing the codomain of a slice may require propagating contractions to adjacent gates.

Template Parameters

T	codomain type

Constructor & Destructor Documentation

Slice() [1/2]

template<class T>

codac2::Slice< T >::Slice ( const SlicedTubeBase & tube, const std::list< TSlice< T > >::iterator & it_tslice, const T & codomain )

inlineexplicit

Creates a slice attached to a tube over a temporal slice.

Parameters

tube	sliced tube owning this slice
it_tslice	iterator to the associated temporal slice
codomain	codomain associated with this slice

        : SliceBase(tube, it_tslice), T(codomain)
      { }

Slice() [2/2]

template<class T>

codac2::Slice< T >::Slice ( const Slice< T > & s, const SlicedTubeBase & tube )

inline

Creates a slice from another one for a given tube.

This constructor duplicates the codomain and keeps the same temporal support.

Parameters

s	source slice
tube	sliced tube owning the copied slice

        : SliceBase(tube, s._it_tslice), T(s.codomain())
      { }

Member Function Documentation

tube()

template<class T>

const SlicedTube< T > & codac2::Slice< T >::tube ( ) const

inline

Returns the sliced tube owning this slice.

Returns

reference to the parent sliced tube

      {
        return static_cast<const SlicedTube<T>&>(_tube);
      }

copy()

template<class T>

std::shared_ptr< SliceBase > codac2::Slice< T >::copy ( ) const

inlineoverridevirtual

Duplicates this slice.

Returns

shared pointer to a copy of this slice

Implements codac2::SliceBase.

      {
        return std::make_shared<Slice>(*this, this->_tube);
      }

size()

template<class T>

Index codac2::Slice< T >::size ( ) const

inline

Returns the codomain dimension.

Returns

size of the codomain

      {
        return this->T::size();
      }

codomain() [1/2]

template<class T>

T & codac2::Slice< T >::codomain ( )

inline

Returns a mutable reference to the codomain.

Note

Prefer set() when adjacency propagation is required.

Returns

mutable reference to the codomain

      {
        return static_cast<T&>(*this);
      }

codomain() [2/2]

template<class T>

const T & codac2::Slice< T >::codomain ( ) const

inline

Returns a constant reference to the codomain.

Returns

constant reference to the codomain

      {
        return static_cast<const T&>(*this);
      }

is_gate()

template<class T>

bool codac2::Slice< T >::is_gate ( ) const

inline

Tests whether this slice is a gate.

A slice is considered a gate when its temporal support is degenerate.

Returns

true if this slice is a gate, false otherwise

      {
        return t0_tf().is_degenerated();
      }

prev_slice() [1/2]

template<class T>

std::shared_ptr< const Slice< T > > codac2::Slice< T >::prev_slice ( ) const

inline

Returns the previous slice.

Returns

shared pointer to the previous slice, or nullptr if none exists

      {
        return std::static_pointer_cast<const Slice<T>>(
          this->SliceBase::prev_slice());
      }

prev_slice() [2/2]

template<class T>

std::shared_ptr< Slice< T > > codac2::Slice< T >::prev_slice ( )

inline

Returns the previous slice.

Returns

shared pointer to the previous slice, or nullptr if none exists

      {
        return std::const_pointer_cast<Slice<T>>(
          static_cast<const Slice<T>&>(*this).prev_slice());
      }

next_slice() [1/2]

template<class T>

std::shared_ptr< const Slice< T > > codac2::Slice< T >::next_slice ( ) const

inline

Returns the next slice.

Returns

shared pointer to the next slice, or nullptr if none exists

      {
        return std::static_pointer_cast<const Slice<T>>(
          this->SliceBase::next_slice());
      }

next_slice() [2/2]

template<class T>

std::shared_ptr< Slice< T > > codac2::Slice< T >::next_slice ( )

inline

Returns the next slice.

Returns

shared pointer to the next slice, or nullptr if none exists

      {
        return std::const_pointer_cast<Slice<T>>(
          static_cast<const Slice<T>&>(*this).next_slice());
      }

input_gate()

template<class T>

T codac2::Slice< T >::input_gate ( ) const

inline

Returns the input gate of this slice.

If the previous temporal element is an explicit gate, its codomain is returned. Otherwise, the returned value is the intersection between this codomain and the codomain of the previous slice. If no previous slice exists, the codomain of this slice is returned.

Returns

enclosure of the input gate

      {
        if(!prev_slice())
          return codomain();
 
        else
        {
          if(prev_slice()->is_gate())
            return prev_slice()->codomain();
          else
            return codomain() & prev_slice()->codomain();
        }
      }

output_gate()

template<class T>

T codac2::Slice< T >::output_gate ( ) const

inline

Returns the output gate of this slice.

If the next temporal element is an explicit gate, its codomain is returned. Otherwise, the returned value is the intersection between this codomain and the codomain of the next slice. If no next slice exists, the codomain of this slice is returned.

Returns

enclosure of the output gate

      {
        if(!next_slice())
          return codomain();
 
        else
        {
          if(next_slice()->is_gate())
            return next_slice()->codomain();
          else
            return codomain() & next_slice()->codomain();
        }
      }

enclosed_bounds()

template<class T>

std::pair< T, T > codac2::Slice< T >::enclosed_bounds ( const Interval & t ) const

inline

Returns enclosed lower and upper bounds over a temporal interval.

This method returns a pair whose first component encloses the reachable lower bounds and whose second component encloses the reachable upper bounds over t.

Parameters

t	temporal interval

Returns

pair made of enclosed lower and upper bounds

      {
        T x = *this; x.set_empty(); 
        auto bounds = std::make_pair(x,x);
 
        if(t.lb() < t0_tf().lb() || t.ub() > t0_tf().ub())
        {
          x.init(Interval(-oo,0));
          bounds.first |= x;
          x.init(Interval(0,oo));
          bounds.second |= x;
        }
 
        if(t.contains(t0_tf().lb()))
        {
          bounds.first |= input_gate().lb();
          bounds.second |= input_gate().ub();
        }
 
        if(t.contains(t0_tf().ub()))
        {
          bounds.first |= output_gate().lb();
          bounds.second |= output_gate().ub();
        }
 
        if(t.is_subset(t0_tf()) && t != t0_tf().lb() && t != t0_tf().ub())
        {
          bounds.first |= this->lb();
          bounds.second |= this->ub();
        }
 
        return bounds;
      }

set()

template<class T>

void codac2::Slice< T >::set ( const T & x, bool propagate = true )

inline

Sets the codomain of this slice.

If propagate is set to true, adjacent gates are updated in order to preserve temporal consistency.

Parameters

x	new codomain
propagate	if set to true, propagates the update to adjacent gates

      {
        assert_release(x.size() == this->size());
        codomain() = x;
        if(propagate)
          update_adjacent_codomains();
      }

init()

template<class T>

void codac2::Slice< T >::init ( )

inlinevirtual

Initializes this codomain to its unbounded value.

No propagation is performed on adjacent slices.

Implements codac2::SliceBase.

      {
        this->T::init();
        // Nothing to propagate to adjacent codomains
      }

set_empty() [1/2]

template<class T>

void codac2::Slice< T >::set_empty ( )

inlinevirtual

Sets this codomain to the empty set.

Adjacent gates are updated accordingly.

Implements codac2::SliceBase.

      {
        set_empty(true);
      }

operator==()

template<class T>

bool codac2::Slice< T >::operator== ( const Slice< T > & x ) const

inline

Compares two slices.

The comparison only involves the codomain of the slices.

Parameters

x	slice to compare with

Returns

true if both codomains are equal, false otherwise

      {
        return codomain() == x.codomain();
      }

polygon_slice()

template<class T>

ConvexPolygon codac2::Slice< T >::polygon_slice ( const Slice< T > & v ) const

inline

Returns the polygonal enclosure associated with this scalar slice.

The enclosure is built from the codomain of this slice, its input/output gates and the derivative information provided by v.

Parameters

v	derivative slice

Returns

polygonal enclosure of this slice

      {
        const Interval& t = this->t0_tf();
        Interval input = this->input_gate(), output = this->output_gate();
 
        // /!\ .diam() method is not reliable (floating point result)
        // -> We need to compute the diameter with intervals
        Interval d = Interval(t.ub())-Interval(t.lb());
 
        Interval proj_output =  input + d * v;
        Interval proj_input  = output - d * v;
 
        return CtcDeriv::polygon_slice(
          t, *this,
          input, proj_input,
          output, proj_output,
          v);
      }

polygon_slice_i()

template<class T>

ConvexPolygon codac2::Slice< T >::polygon_slice_i ( const Slice< T > & v, Index i ) const

inline

Returns the polygonal enclosure associated with one component of a vector slice.

Parameters

v	derivative slice
i	component index

Returns

polygonal enclosure of the \(i\)-th component

      {
        const Interval& t = this->t0_tf();
 
        // /!\ .diam() method is not reliable (floating point result)
        // -> We need to compute the diameter with intervals
        Interval d = Interval(t.ub())-Interval(t.lb());
 
        Interval input = this->input_gate()[i], output = this->output_gate()[i];
        Interval proj_output =  input + d * v[i];
        Interval proj_input  = output - d * v[i];
 
        return CtcDeriv::polygon_slice(
          t, (*this)[i],
          input, proj_input,
          output, proj_output,
          v[i]);
      }

operator()() [1/4]

template<class T>

T codac2::Slice< T >::operator() ( double t ) const

inline

Returns the evaluation of this slice at \(t\).

Parameters

t	temporal input (outside Slice's tdomain, result is unbounded)

Returns

value of \(\llbracket x\rrbracket(t)\)

      {
        if(t == t0_tf().lb())
          return input_gate();
 
        else if(t == t0_tf().ub())
          return output_gate();
 
        else if(t0_tf().contains(t))
          return codomain();
 
        else
          return all_reals_value();
      }

operator()() [2/4]

template<class T>

T codac2::Slice< T >::operator() ( const Interval & t ) const

inline

Returns the evaluation of this slice over \([t]\).

Parameters

t	Interval temporal input (outside Slice's tdomain, result is unbounded)

Returns

value of \(\llbracket x\rrbracket([t])\)

      {
        if(t.is_degenerated())
          return operator()(t.lb());
 
        else if(t.is_subset(t0_tf()))
          return codomain();
 
        else
          return all_reals_value();
      }

operator()() [3/4]

template<class T>

T codac2::Slice< T >::operator() ( double t, const Slice< T > & v ) const

inline

Returns the optimal evaluation of this slice at \(t\), based on the derivative information \(\llbracket v\rrbracket(\cdot)\).

Parameters

t	temporal input (outside Slice's tdomain, result is unbounded)
v	derivative slice such that \(\dot{x}(\cdot)\in\llbracket v\rrbracket(\cdot)\)

Returns

Interval value of \(\llbracket x\rrbracket(t)\)

      {
        return operator()(Interval(t),v);
      }

operator()() [4/4]

template<class T>

T codac2::Slice< T >::operator() ( const Interval & t, const Slice< T > & v ) const

inline

Returns the optimal evaluation of this slice over \([t]\), based on the derivative information \(\llbracket v\rrbracket(\cdot)\).

Parameters

t	Interval temporal input (outside Slice's tdomain, result is unbounded)
v	derivative slice such that \(\dot{x}(\cdot)\in\llbracket v\rrbracket(\cdot)\)

Returns

Interval value of \(\llbracket x\rrbracket([t])\)

      {
        if constexpr(std::is_same_v<T,Interval>)
          return untrunc((polygon_slice(v) & ConvexPolygon(cart_prod(t,trunc(codomain())))).box()[1]);
 
        else if constexpr(std::is_same_v<T,IntervalVector>)
        {
          T y = all_reals_value();
          IntervalVector codom = codomain();
          for(Index i = 0 ; i < size() ; i++)
            y[i] &= untrunc((polygon_slice_i(v,i) & ConvexPolygon(cart_prod(t,trunc(codom[i])))).box()[1]);
          return y;
        }
      }

invert() [1/2]

template<class T>

Interval codac2::Slice< T >::invert ( const T & y, const Interval & t = Interval() ) const

inline

Returns the interval inversion \(\llbracket x\rrbracket^{-1}([y])\).

Parameters

y	Interval codomain
t	optional interval tdomain on which the inversion will be performed

Returns

hull of \(\llbracket x\rrbracket^{-1}([y])\cap[t]\)

      {
        if(t.is_empty())
          return Interval::empty();
 
        else if(t.is_strict_superset(t0_tf()))
          return Interval();
 
        else if((t0_tf() & t) == t0_tf() && codomain().is_subset(y))
          return t0_tf();
 
        else if(t == t0_tf().lb())
        {
          if(y.intersects(input_gate()))
            return t0_tf().lb();
          else
            return Interval::empty();
        }
 
        else if(t == t0_tf().ub())
        {
          if(y.intersects(output_gate()))
            return t0_tf().ub();
          else
            return Interval::empty();
        }
 
        else
        {
          if(y.intersects(codomain()))
            return t & t0_tf();
          else
            return Interval::empty();
        }
      }

invert() [2/2]

template<class T>

Interval codac2::Slice< T >::invert ( const T & y, const Slice< T > & v, const Interval & t = Interval() ) const

inline

Returns the optimal interval inversion \(\llbracket x\rrbracket^{-1}([y])\).

Note

The knowledge of the derivative slice \(\llbracket v\rrbracket(\cdot)\) allows a finer inversion.

Parameters

y	Interval codomain
v	derivative slice such that \(\dot{x}(\cdot)\in\llbracket v\rrbracket(\cdot)\)
t	the optional interval tdomain on which the inversion will be performed

Returns

hull of \(\llbracket x\rrbracket^{-1}([y])\cap[t]\)

      {
        if(t.is_empty() || y.is_empty())
          return Interval::empty();
 
        else if(!t.is_subset(t0_tf()))
          return Interval();
 
        else
        {
          if constexpr(std::is_same_v<T,Interval>)
            return untrunc((polygon_slice(v) & ConvexPolygon(cart_prod(t,trunc(y)))).box()[0]);
 
          else if constexpr(std::is_same_v<T,IntervalVector>)
          {
            Interval t_(t);
            for(Index i = 0 ; i < size() ; i++)
              if(!t_.is_empty())
                t_ &= untrunc((polygon_slice_i(v,i) & ConvexPolygon(cart_prod(t_,trunc(y[i])))).box()[0]);
            return t_;
          }
        }
      }

all_reals_value()

template<class T>

T codac2::Slice< T >::all_reals_value ( ) const

inline

Returns the unbounded value associated with this codomain type.

Returns

unbounded value of type T

      {
        T x = codomain();
        x.init();
        return x;
      }

empty_value()

template<class T>

T codac2::Slice< T >::empty_value ( ) const

inline

Returns the empty value associated with this codomain type.

Returns

empty value of type T

      {
        T x = codomain();
        x.set_empty();
        return x;
      }

set_empty() [2/2]

template<class T>

void codac2::Slice< T >::set_empty ( bool propagate )

inlineprotected

Sets this codomain to the empty set.

Parameters

propagate

if set to true, propagates the update to adjacent gates

      {
        this->T::set_empty();
        if(propagate)
          update_adjacent_codomains();
      }

update_adjacent_codomains()

template<class T>

void codac2::Slice< T >::update_adjacent_codomains ( )

inlineprotected

Propagates codomain contractions to adjacent gates.

This method preserves consistency between a slice and its neighboring gates when one of them is contracted.

      {
        if(prev_slice())
        {
          assert(prev_slice()->size() == this->size());
          if(is_gate())
            codomain() &= prev_slice()->codomain();
          else if(prev_slice()->is_gate())
            prev_slice()->codomain() &= codomain();
        }
 
        if(next_slice())
        {
          assert(next_slice()->size() == this->size());
          if(is_gate())
            codomain() &= next_slice()->codomain();
          else if(next_slice()->is_gate())
            next_slice()->codomain() &= codomain();
        }
      }

---

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

• /home/simon/codac-simon/src/core/contractors/codac2_CtcDeriv.h
• /home/simon/codac-simon/src/core/domains/tube/codac2_Slice.h