synaps/arithm/Interval.h

#ifndef SYNAPS_ARITHM_INTERVAL_H
#define SYNAPS_ARITHM_INTERVAL_H

#include <cassert>
#include <synaps/init.h>
#include <synaps/base/type.h>
#include <synaps/arithm/traits.h>
#include <synaps/arithm/texp.h>
#include <synaps/arithm/let.h>
#include <synaps/arithm/rounding.h>
#include <synaps/arithm/rdw.h>

__BEGIN_NAMESPACE_SYNAPS

namespace  numerics { template<class T, int r> struct interval_base; }
template<class T, int r = 3 >
struct Interval : numerics::interval_base<T,((unsigned)r)%4>
  {
    typedef T value_type;
    typedef T coeff_t;
    typedef numerics::interval_base<T,((unsigned)r)%4> base_t;
    typedef typename base_t::rnd rnd_t;
    typedef Interval<T,r> self_t;
    struct extended { T a,b; extended( const T& c, const T& d ) { a = c; b = d; }; };
    T m, M;
    template<class S> Interval( const arithm::template_expression<S>& e );
    Interval();    
    Interval( int n );
    Interval( const T& x );
    Interval( const T& a, const T& b );
    Interval( const char * s );
    Interval& operator=( const char * s ){ let::assign(*this,s); return *this; }
    Interval & operator=( const Interval & i )
    {
      m = i.m;
      M = i.M;
    };
    
    template<class X>
    Interval & operator=( const arithm::template_expression<X> & x ) ;
    
    void define( const T& m, const T& M ) { this->m = m; this->M = M; };
    void assign( const T& m, const T& M ) { define(m,M); };
    void assign( const Interval& b ) { *this = b; };

    template<class X> bool operator==( const X& k) const { return m == M && M == k ; };
    template<class X, int r_> bool operator==( const Interval<X,r_> & b ) const 
    { return b.m == m && b.M == M ; };
    template<class X> inline bool operator>( const X& x ) const { return m > x; };
    template<class X> inline bool operator>=( const X& x ) const { return  m >= x; };
    template<class X> inline bool operator<( const X& x ) const { return M < x; };
    template<class X> inline bool operator<=( const X& x ) const { return M <= x; };
    template<class X> inline bool operator!=(const X& x ) const { return !(*this == x); };
    template<class X, int _r> bool operator<( const Interval<X,_r>& i ) const { return M < i.m; };
    template<class X, int _r> bool operator>( const Interval<X,_r>& i ) const { return m > i.M; };
    
    const T& lower() const { return m; };
    const T& upper() const { return M; };
    T& lower() { return m; };
    T& upper() { return M; };
    const T& inf() const { return lower(); };
    const T& sup() const { return upper(); };
    T& inf() { return m; };
    T& sup() { return M; };
    
    Interval& operator=( const T& x ) { m = M = x; return *this; };
    template<class X, int R>
    Interval& operator=( const Interval<X,R> & x );
    template<class X>
    Interval& operator+=( const X & x ) { *this = *this + x; return *this; };
    template<class X>
    Interval& operator-=( const X & x ) { *this = *this - x; return *this; };
    template<class X>
    Interval& operator*=( const X & x ) { *this = *this * x; return *this; };
    template<class X>
    Interval& operator/=( const X & x ) { *this = *this / x; return *this; };

    T width() const { return M-m; };
    T size() const { return width(); };
    operator T()const  { return (lower()+upper())/2.0; };
  };


  

template<class T, int r>
void hull( Interval<T,r>& v, const Interval<T,r>& a, const Interval<T,r>& b );
template<class T,  int r> inline
bool intersect( Interval<T,r>& result, 
                const Interval<T,r>& a, const Interval<T,r>& b );

__END_NAMESPACE_SYNAPS

#include "Interval.C"

__BEGIN_NAMESPACE_SYNAPS

namespace let {
  template<class X, class Y, int r0, int r1> inline void 
  assign( Interval<X,r0>& a, const Interval<Y,r1> & b )
  {
    assign(a.m,b.m);
    assign(a.M,b.M);
  };
};

template<class C,int R>
template<class X> inline
Interval<C,R> & Interval<C,R>::operator=( const arithm::template_expression<X> & x )
{
  rnd_t rnd;        // rounding mode verification
  let::assign(*this,x);  // evaluation of template expression
  return *this;
};

template<class C,int R>
template<class X> inline
Interval<C,R>::Interval( const arithm::template_expression<X> & x )
{
  rnd_t rnd;        // rounding mode verification
  let::assign(*this,x);  // evaluation of template expression
};

template<class C, int mode>
template<class X, int R>
Interval<C,mode>& Interval<C,mode>::operator=( const Interval<X,R> & x )
{
  let::assign(*this,x);
  return *this;
};



__END_NAMESPACE_SYNAPS
    
#endif