codac2::SlicedTube< T > Class Template Reference

Tube represented over a sliced temporal domain. More...

#include <codac2_SlicedTube.h>

Inheritance diagram for codac2::SlicedTube< T >:

Collaboration diagram for codac2::SlicedTube< T >:

Classes
struct	iterator
	Mutable iterator over the slices of this tube. More...
struct	reverse_iterator
	Mutable reverse iterator over the slices of this tube. More...
struct	const_iterator
	Constant iterator over the slices of this tube. More...
struct	const_reverse_iterator
	Constant reverse iterator over the slices of this tube. More...

Public Member Functions
	SlicedTube (const std::shared_ptr< TDomain > &tdomain, const T &codomain)
	Creates a sliced tube with constant codomain over all temporal slices.
	SlicedTube (const std::shared_ptr< TDomain > &tdomain, const AnalyticFunction< typename ExprType< T >::Type > &f)
	Creates a sliced tube by evaluating an analytic function on each temporal slice.
template<typename V>
	SlicedTube (const std::shared_ptr< TDomain > &tdomain, const AnalyticTraj< V > &x)
	Creates a sliced tube by evaluating an analytic trajectory on each temporal slice.
template<typename V>
	SlicedTube (const std::shared_ptr< TDomain > &tdomain, const SampledTraj< V > &x)
	Creates a sliced tube from a sampled trajectory.
	SlicedTube (const SlicedTube< T > &x)
	Copy constructor.
SlicedTube &	operator= (const SlicedTube &x)
	Assignment operator.
Index	size () const
	Returns the codomain dimension.
virtual std::pair< Index, Index >	shape () const
	Returns the matrix shape of this tube codomain.
double	volume () const
	Returns the volume of this tube.
std::shared_ptr< Slice< T > >	first_slice ()
	Returns the first slice of this tube.
std::shared_ptr< const Slice< T > >	first_slice () const
	Returns the first slice of this tube.
std::shared_ptr< Slice< T > >	last_slice ()
	Returns the last slice of this tube.
std::shared_ptr< const Slice< T > >	last_slice () const
	Returns the last slice of this tube.
std::shared_ptr< Slice< T > >	slice (const std::list< TSlice >::iterator &it)
	Returns the slice attached to a temporal iterator.
std::shared_ptr< const Slice< T > >	slice (const std::list< TSlice >::const_iterator &it) const
	Returns the slice attached to a temporal iterator.
std::shared_ptr< Slice< T > >	slice (const std::list< TSlice >::reverse_iterator &it)
	Returns the slice attached to a reverse temporal iterator.
std::shared_ptr< const Slice< T > >	slice (const std::list< TSlice >::const_reverse_iterator &it) const
	Returns the slice attached to a reverse temporal iterator.
std::shared_ptr< Slice< T > >	slice (std::shared_ptr< TSlice > ptr)
	Returns the slice attached to a temporal slice pointer.
bool	is_empty () const
	Tests whether this tube is empty.
bool	is_unbounded () const
	Tests whether this tube is unbounded.
T	codomain () const
	Returns the global codomain of this tube.
T	operator() (const Interval &t) const
	Evaluates this tube over a temporal interval.
T	operator() (const Interval &t, const SlicedTube< T > &v) const
	Returns the optimal evaluation over a temporal interval using a derivative tube.
std::pair< T, T >	enclosed_bounds (const Interval &t) const
	Returns enclosed lower and upper bounds over a temporal interval.
void	set (const T &codomain)
	Sets all codomains of this tube to the same value.
void	set (const T &codomain, double t)
	Sets the codomain at one temporal instant.
void	set (const T &codomain, const Interval &t)
	Sets the codomain over a temporal interval.
void	set_ith_slice (const T &codomain, Index i)
	Sets the codomain of the \(i\)-th stored slice.
template<typename V>
const SlicedTube< T > &	inflate (const V &rad)
	Inflates this tube by a constant radius.
template<typename V>
const SlicedTube< T > &	inflate (const SampledTraj< V > &rad)
	Inflates this tube by a time-varying sampled radius.
SlicedTube< Interval >	operator[] (Index i) const
	Extracts one scalar component of this tube.
SlicedTube< IntervalVector >	subvector (Index i, Index j) const
	Extracts a subvector of this tube.
bool	operator== (const SlicedTube &x) const
	Compares two sliced tubes.
SlicedTube &	operator&= (const SlicedTube &x)
	Intersects this tube with another one.
AnalyticFunction< typename ExprType< T >::Type >	as_function () const
	Returns an analytic wrapper of this tube, allowing to evaluate this tube as an operator in an analytic expression.
Interval	invert (const T &y) const
	Returns the interval inversion \(\left[[x]^{-1}([y])\right]\).
Interval	invert (const T &y, const Interval &t) const
	Returns the interval inversion \(\left[[x]^{-1}([y])\right]\).
void	invert (const T &y, std::vector< Interval > &v_t) const
	Computes the set of continuous values of the inversion \([x]^{-1}([y])\).
void	invert (const T &y, std::vector< Interval > &v_t, const Interval &t) const
	Computes the set of continuous values of the inversion \([x]^{-1}([y])\).
Interval	invert (const T &y, const SlicedTube< T > &v) const
	Returns the optimal interval inversion \(\left[[x]^{-1}([y])\right]\).
Interval	invert (const T &y, const SlicedTube< T > &v, const Interval &t) const
	Returns the optimal interval inversion \(\left[[x]^{-1}([y])\right]\).
void	invert (const T &y, std::vector< Interval > &v_t, const SlicedTube< T > &v) const
	Computes the set of continuous values of the optimal inversion \([x]^{-1}([y])\).
void	invert (const T &y, std::vector< Interval > &v_t, const SlicedTube< T > &v, const Interval &t) const
	Computes the set of continuous values of the optimal inversion \([x]^{-1}([y])\).
T	integral (const Interval &t) const
	Returns an enclosure of the integrals of this tube from \(t_0\) to \([t]\).
T	integral (const Interval &t1, const Interval &t2) const
	Returns an enclosure of the integrals of this tube between the time intervals \([t_1]\) and \([t_2]\).
std::pair< T, T >	partial_integral (const Interval &t) const
	Returns lower and upper enclosures of the integrals of this tube \([x](\cdot)=[x^-(\cdot),x^+(\cdot)]\) from \(t_0\) to \([t]\).
std::pair< T, T >	partial_integral (const Interval &t1, const Interval &t2) const
	Returns lower and upper enclosures of the integrals of this tube \([x](\cdot)=[x^-(\cdot),x^+(\cdot)]\) between \([t_1]\) and \([t_2]\).
SlicedTube< T >	primitive () const
	Returns a primitive of this tube with zero initial condition.
SlicedTube< T >	primitive (const T &x0) const
	Returns a primitive of this tube with prescribed initial condition.
T	all_reals_value () const
	Returns the unbounded codomain value associated with T.
T	empty_value () const
	Returns the empty codomain value associated with T.
SampledTraj< typename Scalar< T >::Type >	mid () const
	Returns the approximated midpoint trajectory of this tube.
iterator	begin ()
	Returns an iterator to the first temporal slice.
iterator	end ()
	Returns an iterator past the last temporal slice.
reverse_iterator	rbegin ()
	Returns a reverse iterator to the last temporal slice.
reverse_iterator	rend ()
	Returns a reverse iterator past the first temporal slice.
const_iterator	begin () const
	Returns a constant iterator to the first temporal slice.
const_iterator	end () const
	Returns a constant iterator past the last temporal slice.
const_reverse_iterator	rbegin () const
	Returns a constant reverse iterator to the last temporal slice.
const_reverse_iterator	rend () const
	Returns a constant reverse iterator past the first temporal slice.
Public Member Functions inherited from codac2::SlicedTubeBase
	SlicedTubeBase (const std::shared_ptr< TDomain > &tdomain)
	Creates a sliced tube over a given temporal domain.
	~SlicedTubeBase ()
	Destroys this sliced tube.
size_t	nb_slices () const
	Returns the number of temporal elements of this tube.
std::shared_ptr< const SliceBase >	first_slice () const
	Returns the first slice of this tube.
std::shared_ptr< const SliceBase >	last_slice () const
	Returns the last slice of this tube.
Public Member Functions inherited from codac2::TubeBase
	TubeBase (const std::shared_ptr< TDomain > &tdomain)
	Creates a tube over a given temporal domain.
const std::shared_ptr< TDomain > &	tdomain () const
	Returns the temporal domain of this tube.
Interval	t0_tf () const
	Returns the global temporal interval of this tube.

Additional Inherited Members
Protected Attributes inherited from codac2::TubeBase
const std::shared_ptr< TDomain >	_tdomain
	Shared temporal domain of this tube.

Detailed Description

template<typename T>
class codac2::SlicedTube< T >

Tube represented over a sliced temporal domain.

A SlicedTube<T> is a tube whose temporal domain is represented by a shared TDomain made of TSlice objects.

For each temporal slice of this partition, the tube stores a Slice<T> describing the codomain of the tube over that temporal support.

The codomain type T is typically Interval or IntervalVector, or any custom domain implemented by the user.

Template Parameters

T	codomain type of the tube

Constructor & Destructor Documentation

SlicedTube() [1/5]

template<typename T>

codac2::SlicedTube< T >::SlicedTube ( const std::shared_ptr< TDomain > & tdomain, const T & codomain )

inlineexplicit

Creates a sliced tube with constant codomain over all temporal slices.

Parameters

tdomain	shared temporal domain of the tube
codomain	codomain assigned to each slice

        : SlicedTubeBase(tdomain)
      {
        for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it)
          it->_slices.insert({
            this,
            std::make_shared<Slice<T>>(*this, it, codomain)
          });
      }

SlicedTube() [2/5]

template<typename T>

codac2::SlicedTube< T >::SlicedTube ( const std::shared_ptr< TDomain > & tdomain, const AnalyticFunction< typename ExprType< T >::Type > & f )

inlineexplicit

Creates a sliced tube by evaluating an analytic function on each temporal slice.

The function is evaluated on each temporal interval of the associated TDomain.

Parameters

tdomain	shared temporal domain of the tube
f	analytic function of one scalar variable

        : SlicedTubeBase(tdomain)
      {
        assert_release(f.args().size() == 1
          && "function's inputs must be limited to one system variable");
      
        for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it)
          it->_slices.insert({
            this,
            std::make_shared<Slice<T>>(*this, it, f.eval((Interval)*it))
          });
      }

SlicedTube() [3/5]

template<typename T>

template<typename V>

codac2::SlicedTube< T >::SlicedTube ( const std::shared_ptr< TDomain > & tdomain, const AnalyticTraj< V > & x )

inlineexplicit

Creates a sliced tube by evaluating an analytic trajectory on each temporal slice.

The function is evaluated on each temporal interval of the associated TDomain.

Parameters

tdomain	shared temporal domain of the tube
x	analytic trajectory

        : SlicedTubeBase(tdomain)
      {
        for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it)
          it->_slices.insert({
            this,
            std::make_shared<Slice<T>>(*this, it, x.eval((Interval)*it))
          });
      }

SlicedTube() [4/5]

template<typename T>

template<typename V>

codac2::SlicedTube< T >::SlicedTube ( const std::shared_ptr< TDomain > & tdomain, const SampledTraj< V > & x )

inlineexplicit

Creates a sliced tube from a sampled trajectory.

Template Parameters

V	sampled value type

Parameters

tdomain	shared temporal domain of the tube
x	sampled trajectory evaluated on each temporal slice

        : SlicedTubeBase(tdomain)
      {
        for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it)
          it->_slices.insert({
            this,
            std::make_shared<Slice<T>>(*this, it, x((Interval)*it))
          });
      }

SlicedTube() [5/5]

template<typename T>

codac2::SlicedTube< T >::SlicedTube ( const SlicedTube< T > & x )

inline

Copy constructor.

The copied tube shares the same TDomain as the source tube.

Parameters

x	tube to be copied

        : SlicedTubeBase(x.tdomain())
      {
        for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it)
          it->_slices.insert({
            this,
            std::make_shared<Slice<T>>(*x.slice(it), *this)
          });
      }

Member Function Documentation

operator=()

template<typename T>

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

inline

Assignment operator.

Both tubes are expected to share the same temporal domain object.

Parameters

x	source tube

Returns

reference to this tube

      {
        assert_release(_tdomain == x._tdomain);
 
        for(auto it = _tdomain->begin(); it != _tdomain->end(); ++it)
          slice(it)->set(x.slice(it)->codomain(), false);
 
        return *this;
      }

size()

template<typename T>

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

inline

Returns the codomain dimension.

Returns

dimension of the codomain type T

      {
        return first_slice()->size();
      }

shape()

template<typename T>

virtual std::pair< Index, Index > codac2::SlicedTube< T >::shape ( ) const

inlinevirtual

Returns the matrix shape of this tube codomain.

For scalar codomains, the returned shape is {1,1}.

Returns

pair (rows, cols)

      {
        if constexpr(std::is_same_v<typename ExprType<T>::Type,ScalarType>)
          return {1,1};
        else
          return {first_slice()->codomain().rows(),first_slice()->codomain().cols()};
      }

volume()

template<typename T>

double codac2::SlicedTube< T >::volume ( ) const

inline

Returns the volume of this tube.

Only non-gate slices contribute to the volume.

Returns

sum of the volumes of all non-gate slices

      {
        double volume = 0.;
        for(const auto& s : *this)
          if(!s.is_gate())
            volume += s.volume();
        return volume;
      }

first_slice() [1/2]

template<typename T>

std::shared_ptr< Slice< T > > codac2::SlicedTube< T >::first_slice ( )

inline

Returns the first slice of this tube.

Returns

shared pointer to the first slice

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

first_slice() [2/2]

template<typename T>

std::shared_ptr< const Slice< T > > codac2::SlicedTube< T >::first_slice ( ) const

inline

Returns the first slice of this tube.

Returns

shared pointer to the first slice

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

last_slice() [1/2]

template<typename T>

std::shared_ptr< Slice< T > > codac2::SlicedTube< T >::last_slice ( )

inline

Returns the last slice of this tube.

Returns

shared pointer to the last slice

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

last_slice() [2/2]

template<typename T>

std::shared_ptr< const Slice< T > > codac2::SlicedTube< T >::last_slice ( ) const

inline

Returns the last slice of this tube.

Returns

shared pointer to the last slice

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

slice() [1/5]

template<typename T>

std::shared_ptr< Slice< T > > codac2::SlicedTube< T >::slice ( const std::list< TSlice >::iterator & it )

inline

Returns the slice attached to a temporal iterator.

Parameters

it	iterator to a TSlice of the shared TDomain

Returns

shared pointer to the corresponding slice

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

slice() [2/5]

template<typename T>

std::shared_ptr< const Slice< T > > codac2::SlicedTube< T >::slice ( const std::list< TSlice >::const_iterator & it ) const

inline

Returns the slice attached to a temporal iterator.

Parameters

it	constant iterator to a TSlice of the shared TDomain

Returns

shared pointer to the corresponding slice

      {
        return std::static_pointer_cast<const Slice<T>>(
          it->slices().at(this));
      }

slice() [3/5]

template<typename T>

std::shared_ptr< Slice< T > > codac2::SlicedTube< T >::slice ( const std::list< TSlice >::reverse_iterator & it )

inline

Returns the slice attached to a reverse temporal iterator.

Parameters

it	reverse iterator to a TSlice of the shared TDomain

Returns

shared pointer to the corresponding slice

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

slice() [4/5]

template<typename T>

std::shared_ptr< const Slice< T > > codac2::SlicedTube< T >::slice ( const std::list< TSlice >::const_reverse_iterator & it ) const

inline

Returns the slice attached to a reverse temporal iterator.

Parameters

it	constant reverse iterator to a TSlice of the shared TDomain

Returns

shared pointer to the corresponding slice

      {
        return std::static_pointer_cast<const Slice<T>>(
          it->slices().at(this));
      }

slice() [5/5]

template<typename T>

std::shared_ptr< Slice< T > > codac2::SlicedTube< T >::slice ( std::shared_ptr< TSlice > ptr )

inline

Returns the slice attached to a temporal slice pointer.

This overload is mainly intended for language bindings.

Parameters

ptr	pointer to a temporal slice of the shared TDomain

Returns

shared pointer to the corresponding slice

      {
        // Used in Python binding
        auto it = std::find_if(_tdomain->begin(), _tdomain->end(),
                    [&](TSlice& t){ return &t == ptr.get(); });
        assert(it != _tdomain->end());
        return slice(it);
      }

is_empty()

template<typename T>

bool codac2::SlicedTube< T >::is_empty ( ) const

inline

Tests whether this tube is empty.

A fast evaluation is done by considering gates first, then envelopes, which allows to quickly identify an empty set

Returns

true if at least one slice is empty, false otherwise

      {
        for(const auto& s : *this)
          if(s.is_gate() && s.is_empty())
            return true;
        for(const auto& s : *this)
          if(!s.is_gate() && s.is_empty())
            return true;
        return false;
      }

is_unbounded()

template<typename T>

bool codac2::SlicedTube< T >::is_unbounded ( ) const

inline

Tests whether this tube is unbounded.

Returns

true if at least one slice is unbounded, false otherwise

      {
        for(const auto& s : *this)
          if(s.is_unbounded())
            return true;
        return false;
      }

codomain()

template<typename T>

T codac2::SlicedTube< T >::codomain ( ) const

inline

Returns the global codomain of this tube.

The returned codomain is the union of the codomains of all slices.

Returns

global codomain enclosure

      {
        T x = first_slice()->codomain();
        for(const auto& s : *this)
          x |= s.codomain();
        return x;
      }

operator()() [1/2]

template<typename T>

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

inline

Evaluates this tube over a temporal interval.

Parameters

t	temporal interval

Returns

enclosure of \([x]([t])\)

      {
        return eval_common(t,
          [this](auto it, const Interval& t_) {
            return slice(it)->operator()(t_);
          });
      }

operator()() [2/2]

template<typename T>

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

inline

Returns the optimal evaluation over a temporal interval using a derivative tube.

Parameters

t	temporal interval
v	derivative tube such that \(\dot{x}(\cdot)\in[v](\cdot)\)

Returns

enclosure of \([x]([t])\)

      {
        return eval_common(t,
          [this,&v](auto it, const Interval& t_) {
            return slice(it)->operator()(t_, *v.slice(it));
          });
      }

enclosed_bounds()

template<typename T>

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

inline

Returns enclosed lower and upper bounds over a temporal interval.

Parameters

t	temporal interval

Returns

pair made of enclosed lower and upper bounds

      {
        auto x = this->empty_value();
        auto bounds = std::make_pair(x,x);
 
        if(t.lb() < _tdomain->t0_tf().lb() || t.ub() > _tdomain->t0_tf().ub())
        {
          x.init(Interval(-oo,0));
          bounds.first |= x;
          x.init(Interval(0,oo));
          bounds.second |= x;
        }
 
        Interval t_inter = t & _tdomain->t0_tf();
        auto si = slice(_tdomain->tslice(t_inter.lb()));
 
        while(si && si->t0_tf().lb() <= t_inter.ub())
        {
          auto slice_bounds = si->enclosed_bounds(t_inter & si->t0_tf());
          bounds.first |= slice_bounds.first;
          bounds.second |= slice_bounds.second;
          si = si->next_slice();
        }
 
        return bounds;
      }

set() [1/3]

template<typename T>

void codac2::SlicedTube< T >::set ( const T & codomain )

inline

Sets all codomains of this tube to the same value.

Parameters

codomain

new codomain

      {
        assert_release(codomain.size() == this->size());
 
        for(auto& s : *this)
          if(!s.is_gate())
            s.set(codomain, false);
 
        for(auto& s : *this)
          if(s.is_gate())
            s.set(codomain, false);
      }

set() [2/3]

template<typename T>

void codac2::SlicedTube< T >::set ( const T & codomain, double t )

inline

Sets the codomain at one temporal instant.

The temporal domain may be refined so that t becomes an explicit gate.

Parameters

codomain	new codomain
t	temporal instant

      {
        assert_release(codomain.size() == this->size());
        slice(_tdomain->sample(t,true))->set(codomain);
      }

set() [3/3]

template<typename T>

void codac2::SlicedTube< T >::set ( const T & codomain, const Interval & t )

inline

Sets the codomain over a temporal interval.

The temporal domain may be refined so that the bounds of t become explicit gates.

Parameters

codomain	new codomain
t	temporal interval

      {
        auto it_lb = _tdomain->sample(t.lb(), t.is_degenerated());
        std::list<TSlice>::iterator it_ub;
        
        if(!t.is_degenerated())
        {
          it_ub = _tdomain->sample(t.ub(), false);
 
          if(it_ub->lb() == t.ub())
            it_ub--; // pointing to the tslice [..,t.ub()]
 
          if(it_lb->ub() == t.lb())
            it_lb++;
        }
 
        else
          it_ub = it_lb;
 
        do
        {
          slice(it_lb)->set(codomain);
        } while(it_lb != it_ub && (++it_lb) != _tdomain->end());
      }

set_ith_slice()

template<typename T>

void codac2::SlicedTube< T >::set_ith_slice ( const T & codomain, Index i )

inline

Sets the codomain of the \(i\)-th stored slice.

Parameters

codomain	new codomain
i	slice index

      {
        Index j = 0;
        for(auto& si : *this)
          if(j++ == i)
          {
            si.set(codomain);
            break;
          }
      }

inflate() [1/2]

template<typename T>

template<typename V>

const SlicedTube< T > & codac2::SlicedTube< T >::inflate ( const V & rad )

inline

Inflates this tube by a constant radius.

Template Parameters

V	radius type

Parameters

rad	inflation radius

Returns

reference to this tube

      {
        // todo: faster implementation with iterators
        for(auto& s : *this)
          if(!s.is_gate())
            s.set(T(s.codomain()).inflate(rad), false);
 
        for(auto& s : *this)
          if(s.is_gate())
            s.set(T(s.codomain()).inflate(rad), false);
 
        return *this;
      }

inflate() [2/2]

template<typename T>

template<typename V>

const SlicedTube< T > & codac2::SlicedTube< T >::inflate ( const SampledTraj< V > & rad )

inline

Inflates this tube by a time-varying sampled radius.

Template Parameters

V	sampled radius type

Parameters

rad	sampled inflation radius

Returns

reference to this tube

      {
        // todo: faster implementation with iterators
        assert_release(tdomain()->t0_tf().is_subset(rad.tdomain()));
 
        for(auto& s : *this)
          if(!s.is_gate())
            s.set(T(s.codomain()).inflate(rad(s.t0_tf()).ub()), false);
 
        for(auto& s : *this)
          if(s.is_gate())
            s.set(T(s.codomain()).inflate(rad(s.t0_tf()).ub()), false);
 
        return *this;
      }

operator[]()

template<typename T>

SlicedTube< Interval > codac2::SlicedTube< T >::operator[] ( Index i ) const

inline

Extracts one scalar component of this tube.

Parameters

i	component index

Returns

scalar sliced tube corresponding to the \(i\)-th component

      {
        assert_release(i >= 0 && i < size());
        SlicedTube<Interval> xi(tdomain(), Interval());
        for(auto it = tdomain()->begin() ; it != tdomain()->end() ; it++)
          xi.slice(it)->codomain() = slice(it)->codomain()[i];
        return xi;
      }

subvector()

template<typename T>

SlicedTube< IntervalVector > codac2::SlicedTube< T >::subvector ( Index i, Index j ) const

inline

Extracts a subvector of this tube.

Parameters

i	first component index
j	last component index

Returns

sliced tube associated with the subvector \([i,j]\)

      {
        assert_release(i >= 0 && i <= j && j < size());
        SlicedTube<IntervalVector> xij(tdomain(), IntervalVector(j-i+1));
        for(auto it = tdomain()->begin() ; it != tdomain()->end() ; it++)
          xij.slice(it)->codomain() = slice(it)->codomain().subvector(i,j);
        return xij;
      }

operator==()

template<typename T>

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

inline

Compares two sliced tubes.

Two sliced tubes are equal if they share the same temporal partition and if all corresponding codomains are equal.

Parameters

x	tube to compare with

Returns

true if both tubes are equal, false otherwise

      {
        if(!TDomain::are_same(tdomain(), x.tdomain()))
          return false;
 
        auto it_this = _tdomain->begin();
        auto it_x = x.tdomain()->cbegin();
 
        while(it_this != _tdomain->end())
          if(*slice(it_this++) != *x.slice(it_x++))
            return false;
 
        return true;
      }

operator&=()

template<typename T>

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

inline

Intersects this tube with another one.

Both tubes are expected to be defined over the same temporal partition.

Parameters

x	tube to intersect with

Returns

updated tube

      {
        assert(TDomain::are_same(tdomain(), x.tdomain()));
        auto it_this = _tdomain->begin();
        auto it_x = x.tdomain()->cbegin();
 
        while(it_this != _tdomain->end())
        {
          auto s = slice(it_this);
          s->set(s->codomain() & x.slice(it_x)->codomain());
          it_this++; it_x++;
        }
 
        assert(it_x == x.tdomain()->cend());
        return *this;
      }

as_function()

template<typename T>

AnalyticFunction< typename ExprType< T >::Type > codac2::SlicedTube< T >::as_function ( ) const

inline

Returns an analytic wrapper of this tube, allowing to evaluate this tube as an operator in an analytic expression.

Returns

analytic function associated with this tube

      {
        ScalarVar t;
        return {{t},
          AnalyticExprWrapper<typename ExprType<T>::Type>(
            std::make_shared<AnalyticOperationExpr<
              TubeOp<SlicedTube<T>>,typename ExprType<T>::Type,ScalarType>>(*this,t))
        };
      }

invert() [1/4]

template<typename T>

Interval codac2::SlicedTube< T >::invert ( const T & y ) const

inline

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

If the inversion results in several pre-images, their union is returned.

Parameters

y	interval codomain

Returns

the hull of \([x]^{-1}([y])\)

      {
        return invert(y,t0_tf());
      }

invert() [2/4]

template<typename T>

void codac2::SlicedTube< T >::invert ( const T & y, std::vector< Interval > & v_t ) const

inline

Computes the set of continuous values of the inversion \([x]^{-1}([y])\).

Parameters

y	interval codomain
v_t	vector of the sub-tdomains \([t_k]\) for which \(\forall t\in[t_k] \mid x(t)\in[y], x(\cdot)\in[x](\cdot)\)

      {
        invert(y,v_t,t0_tf());
      }

invert() [3/4]

template<typename T>

Interval codac2::SlicedTube< T >::invert ( const T & y, const SlicedTube< T > & v ) const

inline

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

The knowledge of the derivative tube \([v](\cdot)\) allows a finer inversion. If the inversion results in several pre-images, their union is returned.

Parameters

y	interval codomain
v	derivative tube such that \(\dot{x}(\cdot)\in[v](\cdot)\)

Returns

hull of \([x]^{-1}([y])\)

      {
        return invert(y,v,t0_tf());
      }

invert() [4/4]

template<typename T>

void codac2::SlicedTube< T >::invert ( const T & y, std::vector< Interval > & v_t, const SlicedTube< T > & v ) const

inline

Computes the set of continuous values of the optimal inversion \([x]^{-1}([y])\).

The knowledge of the derivative tube \([v](\cdot)\) allows finer inversions.

Parameters

y	interval codomain
v_t	vector of the sub-tdomains \([t_k]\) for which \(\forall t\in[t_k] \mid x(t)\in[y], x(\cdot)\in[x](\cdot), \dot{x}(\cdot)\in[v](\cdot)\)
v	derivative tube such that \(\dot{x}(\cdot)\in[v](\cdot)\)

      {
        invert(y,v_t,v,t0_tf());
      }

all_reals_value()

template<typename T>

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

inline

Returns the unbounded codomain value associated with T.

Returns

unbounded value of type T

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

empty_value()

template<typename T>

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

inline

Returns the empty codomain value associated with T.

Returns

empty value of type T

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

mid()

template<typename T>

SampledTraj< typename Scalar< T >::Type > codac2::SlicedTube< T >::mid ( ) const

inline

Returns the approximated midpoint trajectory of this tube.

Template Parameters

V	sampled value type

Returns

midpoint sampled trajectory

      {
        SampledTraj<typename Scalar<T>::Type> m;
        double t0 = _tdomain->t0_tf().lb();
        m.set((*this)(t0).mid(), t0);
        for(const auto& s : *this)
          if(!s.is_gate())
            m.set(s.output_gate().mid(),s.t0_tf().ub());
        return m;
      }

---

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

• /home/simon/codac-simon/src/core/contractors/codac2_Ctc.h
• /home/simon/codac-simon/src/core/domains/tube/codac2_SlicedTube.h
• /home/simon/codac-simon/src/core/domains/tube/codac2_SlicedTube_integral_impl.h