Integration and primitive operations on sliced tubes

The following methods are valid for tubes defined for Interval or IntervalVector codomains. The returned values are integral enclosures of same type (respectively, Interval or IntervalVector). More...

Functions
T	codac2::SlicedTube< T >::integral (const Interval &t) const
	Returns an enclosure of the integrals of this tube from \(t_0\) to \([t]\).
T	codac2::SlicedTube< 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 >	codac2::SlicedTube< 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 >	codac2::SlicedTube< 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 >	codac2::SlicedTube< T >::primitive () const
	Returns a primitive of this tube with zero initial condition.
SlicedTube< T >	codac2::SlicedTube< T >::primitive (const T &x0) const
	Returns a primitive of this tube with prescribed initial condition.

Detailed Description

The following methods are valid for tubes defined for Interval or IntervalVector codomains. The returned values are integral enclosures of same type (respectively, Interval or IntervalVector).

Function Documentation

integral() [1/2]

template<typename T>

T codac2::SlicedTube< T >::integral

(

const Interval &

t

)

const

Returns an enclosure of the integrals of this tube from \(t_0\) to \([t]\).

This method computes an enclosure of

\[ \left\{ \int_{t_0}^{\tau} [x](s)\,ds \;\middle|\; \tau\in[t] \right\}. \]

It is obtained from partial_integral(t) by taking the hull between the lower bound of the lower enclosure and the upper bound of the upper enclosure.

Parameters

t	temporal interval \([t]\)

Returns

enclosure of the integrals of this tube over t

  {
    auto partial_integ = partial_integral(t);
 
    if(partial_integ.first.is_empty() || partial_integ.second.is_empty())
      return this->empty_value();
 
    else if(partial_integ.first.is_unbounded() || partial_integ.second.is_unbounded())
      return this->all_reals_value();
 
    else
      return T(partial_integ.first.lb()) | partial_integ.second.ub();
  }

integral() [2/2]

template<typename T>

T codac2::SlicedTube< 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]\).

This method computes an enclosure of

\[ \left\{ \int_{\tau_1}^{\tau_2} [x](s)\,ds \;\middle|\; \tau_1\in[t_1],\ \tau_2\in[t_2] \right\}. \]

The result is obtained by subtracting the partial integral enclosures at t1 and t2.

Parameters

t1	first temporal interval \([t_1]\)
t2	second temporal interval \([t_2]\)

Returns

enclosure of the integrals of this tube between t1 and t2

  {
    auto integ_t1 = partial_integral(t1);
    auto integ_t2 = partial_integral(t2);
 
    if(integ_t1.first.is_empty() || integ_t1.second.is_empty() ||
       integ_t2.first.is_empty() || integ_t2.second.is_empty())
    {
      return this->empty_value();
    }
 
    else if(integ_t1.first.is_unbounded() || integ_t1.second.is_unbounded() ||
            integ_t2.first.is_unbounded() || integ_t2.second.is_unbounded())
    {
      return this->all_reals_value();
    }
 
    else
    {
      auto lb = (integ_t2.first - integ_t1.first).lb();
      auto ub = (integ_t2.second - integ_t1.second).ub();
      return T(lb) | ub;
    }
  }

partial_integral() [1/2]

template<typename T>

std::pair< T, T > codac2::SlicedTube< 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]\).

This method returns a pair \(([p^-],[p^+])\) such that:

\[ [p^-]\supset \left\{ \int_{t_0}^{\tau} x^-(s)\,ds \;\middle|\; \tau\in[t] \right\} \mathrm{~~and~~} [p^+]\supset \left\{\int_{t_0}^{\tau} x^+(s)\,ds \;\middle|\; \tau\in[t] \right\}. \]

This representation preserves more information than integral(t), which only returns the hull of these partial integral bounds.

Parameters

t	temporal interval \([t]\)

Returns

pair of lower and upper partial integral enclosures over t

  {
    //if(!t.is_subset(tdomain()->t0_tf()))
    //  return { Interval(), Interval() };
 
    auto zero = this->all_reals_value();
    zero.init(Interval(0.));
 
    std::pair<T,T> p_integ { zero, zero };
    auto p_integ_uncertain = p_integ;
 
    for(const auto& si : *this)
    {
      if(si.t0_tf().lb() >= t.ub())
        break;
 
      if(si.codomain().is_empty())
      {
        auto e = this->empty_value();
        return { e, e };
      }
 
      if(si.codomain().is_unbounded())
      {
        auto u = this->all_reals_value();
        return { u, u };
      }
 
      // From t0 to tlb
 
        Interval intv_t = si.t0_tf() & Interval(tdomain()->t0_tf().lb(), t.lb());
        if(!intv_t.is_empty())
        {
          p_integ.first += intv_t.diam() * si.codomain().lb();
          p_integ.second += intv_t.diam() * si.codomain().ub();
          p_integ_uncertain = p_integ;
 
          if(intv_t.ub() == t.ub())
            return p_integ; // end of the integral evaluation
        }
 
      // From tlb to tub
 
        intv_t = si.t0_tf() & t;
        if(!intv_t.is_empty())
        {
          auto p_integ_temp = p_integ_uncertain;
          p_integ_uncertain.first += Interval(0., intv_t.diam()) * si.codomain().lb();
          p_integ_uncertain.second += Interval(0., intv_t.diam()) * si.codomain().ub();
        
          p_integ.first |= p_integ_uncertain.first;
          p_integ.second |= p_integ_uncertain.second;
 
          p_integ_uncertain.first = p_integ_temp.first + intv_t.diam() * si.codomain().lb();
          p_integ_uncertain.second = p_integ_temp.second + intv_t.diam() * si.codomain().ub();
        }
    }
 
    return p_integ;
  }

partial_integral() [2/2]

template<typename T>

std::pair< T, T > codac2::SlicedTube< 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]\).

This method returns a pair obtained by subtracting the partial integral enclosures at t1 from those at t2. The returned pair \(([p^-],[p^+])\) is such that:

\[ [p^-]\supset \left\{ \int_{\tau_1}^{\tau_2} x^-(s)\,ds \;\middle|\; \tau_1\in[t_1],\ \tau_2\in[t_2] \right\}, \]

and

\[ [p^+]\supset \left\{\int_{\tau_1}^{\tau_2} x^+(s)\,ds \;\middle|\; \tau_1\in[t_1],\ \tau_2\in[t_2] \right\}. \]

Parameters

t1	first temporal interval \([t_1]\)
t2	second temporal interval \([t_2]\)

Returns

pair of lower and upper enclosures of the integrals

  {
    auto integ_t1 = partial_integral(t1);
    auto integ_t2 = partial_integral(t2);
    return {
      integ_t2.first - integ_t1.first,
      integ_t2.second - integ_t1.second
    };
  }

primitive() [1/2]

template<typename T>

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

inline

Returns a primitive of this tube with zero initial condition.

This is a shorthand for primitive(x0) with \(x_0 = 0\).

In other words, the returned tube encloses solutions of

\[ \dot{p}(\cdot) \in [x](\cdot), \qquad p(t_0)=0. \]

Returns

primitive tube with zero initial condition

      {
        auto x0 = all_reals_value();
        x0.init(0.);
        return primitive(x0);
      }

primitive() [2/2]

template<typename T>

SlicedTube< T > codac2::SlicedTube< T >::primitive ( const T & x0 ) const

inline

Returns a primitive of this tube with prescribed initial condition.

This method constructs a tube p on the same temporal domain as this tube, imposes the initial condition \(p(t_0)=x_0\), and contracts p with this tube through the derivative relation using CtcDeriv.

In other words, the returned tube encloses solutions of

\[ \dot{p}(\cdot) \in [x](\cdot), \qquad p(t_0)=x_0. \]

Note

The current implementation may create an explicit gate at the initial time \(t_0\) if it is not already present in the temporal partition.

Parameters

x0	initial condition at \(t_0\)

Returns

primitive tube satisfying the prescribed initial condition

      {
        auto x = all_reals_value();
        auto p = SlicedTube<T>(this->tdomain(), x);
        p.set(x0, this->tdomain()->t0_tf().lb()); // may create an unwanted gate
        CtcDeriv c;
        c.contract(p,*this);
        return p;
      }