/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/OpenTissue/OpenTissue/core/math/interval/interval.h

Go to the documentation of this file.

#ifndef OPENTISSUE_CORE_MATH_INTERVAL_H
#define OPENTISSUE_CORE_MATH_INTERVAL_H
//
// OpenTissue Template Library
// - A generic toolbox for physics-based modeling and simulation.
// Copyright (C) 2008 Department of Computer Science, University of Copenhagen.
//
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>

#include <OpenTissue/core/math/interval/io/interval_io.h>
#include <OpenTissue/core/math/interval/interval_vector.h>
#include <OpenTissue/core/math/interval/interval_matrix.h>
#include <OpenTissue/core/math/interval/interval_intersect.h>
#include <OpenTissue/core/math/interval/interval_empty.h>

#include <OpenTissue/core/math/math_value_traits.h>


#include <cassert>

namespace OpenTissue
{
  namespace math
  {
    namespace interval
    {

      template <typename value_type_>
      class Interval
      {
      public:

        typedef value_type_                    T;
        typedef typename math::ValueTraits<T>  value_traits;
        typedef T                              value_type;
        typedef T                              base_type;   //--- boost::interval interface compatibility
        typedef size_t                         index_type;

      protected:

        T m_lower;  
        T m_upper;  

      public:

        T       & lower()       { return m_lower; }
        T const & lower() const { return m_lower; }
        T       & upper()       { return m_upper; }
        T const & upper() const { return m_upper; }

        T & operator() (index_type index) 
        {
          assert(index==0u || index==1u || !"interval::operator(): index must be zero or one");
          return (!index) ? m_lower : m_upper;
        }

        T const & operator() (index_type index) const
        {
          assert(index==0u || index==1u || !"interval::operator() const : index must be zero or one");
          return (!index) ? m_lower : m_upper;
        }

        T & operator[] (index_type index)
        {
          assert(index==0u || index==1u || !"interval::operator[]: index must be zero or one");
          return (!index) ? m_lower : m_upper;
        }

        T const & operator[] (index_type index) const
        {
          assert(index==0u || index==1u || !"interval::operator[] const : index must be zero or one");
          return (!index) ? m_lower : m_upper;
        }

      public:

        Interval()
          : m_lower()
          , m_upper()
        {}

        Interval(Interval const &i)
          : m_lower( i.m_lower )
          , m_upper( i.m_upper )
        {}

        explicit Interval(T const & value)
          : m_lower( value )
          , m_upper( value ) 
        {}

        explicit Interval(T const & l, T const & u)
          : m_lower( l )
          , m_upper( u ) 
        {
          //assert(lower_val <= upper_val || !"interval(lower_val,upper_val): lower bound must be less than or equal to upper bound");
        }

        ~Interval() {}

      public:

        Interval & operator=(Interval const &rhs) 
        {
          m_lower =  rhs.m_lower;
          m_upper =  rhs.m_upper;
          return (*this);
        }

        //--- boost::interval interface compatibility
        void assign(T const &l, T const &u)
        {
          m_lower = l;
          m_upper = u;
        }

        void clear()
        {
          m_lower = m_upper = value_traits::zero();
        }

        bool is_valid() const     {      return !is_empty();    }

        bool is_empty() const     {      return m_lower > m_upper;    }

        //--- boost::interval interface compatibility
        static Interval const & empty() 
        { 
          static Interval const empty_value(value_traits::one(),-value_traits::one()); 
          return empty_value;
        };

      public:

        bool operator< (Interval const & i) const { return m_upper < i.m_lower;                  }
        bool operator> (Interval const & i) const { return m_lower > i.m_upper;                  }
        bool operator<=(Interval const & i) const { return m_upper <= i.m_lower;                 }
        bool operator>=(Interval const & i) const { return m_lower >= i.m_upper;                 }
        bool operator==(Interval const & i) const { return m_lower == i.m_lower && m_upper == i.m_upper; }
        bool operator!=(Interval const & i) const { return m_lower != i.m_lower || m_upper != i.m_upper; }

      public:

        Interval & operator+=(Interval const & i)
        {
          m_lower += i.m_lower;
          m_upper += i.m_upper;
          return (*this);
        }

        Interval operator+(Interval const &i ) const { return Interval(m_lower+i.m_lower, m_upper+i.m_upper); }

        Interval & operator-=(Interval const & i)
        {
          m_lower -= i.m_upper;
          m_upper -= i.m_lower;
          return (*this);
        }

        Interval operator-(Interval const & i) const { return Interval(m_lower-i.m_upper, m_upper-i.m_lower); }

        Interval operator-() const {  return Interval(-m_upper, -m_lower); }

        Interval & operator*=(T const & val)
        {
          if (val < value_traits::zero() ) 
          {
            T x = m_lower;
            m_lower = m_upper * val;
            m_upper = x * val;
          }
          else 
          {
            m_upper *= val;
            m_lower *= val;
          }
          return (*this);
        }

        Interval operator*(T const & val) const
        {
          return (val < value_traits::zero()) ? Interval(m_upper*val, m_lower*val) : Interval(m_lower*val, m_upper*val);
        }

        Interval & operator*=(Interval const & i)
        {
          T tmp_lower;
          T tmp_upper;

          if (m_lower <= value_traits::zero() && i.m_upper >= value_traits::zero()) 
          {
            tmp_lower = m_lower * i.m_upper;
          }
          else if (m_upper >= value_traits::zero()) 
          {
            tmp_lower = (i.m_lower <= value_traits::zero()) ? m_upper*i.m_lower : m_lower*i.m_lower;
          }
          else 
          {
            tmp_lower = m_upper*i.m_upper;
          }

          if (m_lower <= value_traits::zero() && i.m_lower <= value_traits::zero()) 
          {
            tmp_upper = m_lower * i.m_lower;
          }
          else if (m_upper >= value_traits::zero()) 
          {
            tmp_upper = (i.m_upper >= value_traits::zero())  ? m_upper * i.m_upper : m_lower * i.m_upper;
          }
          else 
          {
            tmp_upper = m_upper * i.m_lower;
          }

          m_upper = tmp_upper;
          m_lower = tmp_lower;

          return *this;
        }

        /*
        * Interval Multiplication.
        * Performance Warning: Copy Constructor is invoked to create return value.
        *
        * Optimized version, more IFs, two less mul
        *
        * @param i  The interval to multiply with.
        *
        * @return   A new interval instance holding the result of the multiplication.
        */
        Interval operator*(Interval const & i) const   
        {    
          Interval tmp(i);
          tmp *= (*this);
          return tmp;
        }

        Interval & operator/=(Interval const & i)
        {
          assert(i.m_lower > value_traits::zero() || i.m_upper < value_traits::zero() || !"interval::operator/=(): lower must be positive or upper negative!");
          (*this) *= Interval(value_traits::one() / i.m_upper, value_traits::one() / i.m_lower);
          return (*this);
        }

        Interval operator/(Interval const & i) const
        {
          assert(i.m_lower > value_traits::zero() || i.m_upper < value_traits::zero() || !"interval::operator/=(): lower must be positive or upper negative!");
          return (*this) * Interval(value_traits::one() / i.m_upper, value_traits::one() / i.m_lower);
        }

        T get_abs_lower() const
        {
          // -------0-[   ]- <-R
          // -----[ 0 ]----- <-R
          // -[   ]-0------- <-R
          return (m_lower >= value_traits::zero()) ? m_lower  :  ( m_upper >= value_traits::zero() ? value_traits::zero() : -m_upper  );
        }

        T get_abs_upper() const
        {
          // -------0-[   ]- <-R
          // -----[ 0 ]----- <-R
          // -[   ]-0------- <-R
          return (m_lower+m_upper >= value_traits::zero()) ? m_upper : -m_lower;
        }

      };

    } // namespace interval
  } // namespace math
} // namespace OpenTissue

// OPENTISSUE_CORE_MATH_INTERVAL_H
#endif