measurevector.h

Go to the documentation of this file.

/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */
#ifndef BRAINRAT_DATA_MEASUREVECTOR_H
#define BRAINRAT_DATA_MEASUREVECTOR_H
 
#include <sstream>
#include <vector>
#include <math.h>
 
#include <aims/def/assert.h>
#include <cartobase/object/object.h>
#include <cartobase/object/property.h>
#include <cartobase/smart/rcptr.h>
#include <brainrat/object/array.h>
 
namespace bio {
  
  template <typename T>
  class BaseMeasureVector
  {
  public:
    typedef T value_type;
    typedef T* pointer;
    typedef T* iterator;
    typedef const T* const_iterator;
    typedef T& reference;
    typedef const T& const_reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
 
    // Constructors
    BaseMeasureVector( const size_type size, const T* = NULL );
    BaseMeasureVector( const BaseMeasureVector<T> & );
 
 
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;
 
    // Destructor does nothing
    ~BaseMeasureVector() {
      delete [] _data;
    }
      
      
    
    const size_type size() const;
    T &operator [] ( unsigned x );
    T &operator [] ( unsigned x ) const;
    BaseMeasureVector<T>& operator = (const BaseMeasureVector<T> &other);
    BaseMeasureVector<T>& operator = (const T &val);
    BaseMeasureVector<T>& operator += (const BaseMeasureVector<T> &other);
    BaseMeasureVector<T>& operator -= (const BaseMeasureVector<T> &other);
    BaseMeasureVector<T>& operator *= (const T &val);
    BaseMeasureVector<T>& operator /= (const T &val);
    
    double distance (const BaseMeasureVector<T> &aa) const;
    
    
  // @}
    
  private :
    typename BaseMeasureVector<T>::size_type _size;
    T * _data;
  };
  
  template <typename T>
  inline
  const typename BaseMeasureVector<T>::size_type BaseMeasureVector<T>::size() const { 
    return _size;
  }
  
  template <typename T>
  inline
  BaseMeasureVector<T>::BaseMeasureVector ( const size_type size, const T* values )
  {
    _size = size;
    _data = new T[size];
    for (int32_t i = 0; i < this->size(); i++)
      if (values)
        (&*_data)[i] = values[i];
      else
        (&*_data)[i] = (T)0;
  }
  
  template <typename T>
  inline
  BaseMeasureVector<T>::BaseMeasureVector( const BaseMeasureVector<T> &other )
  {
    _size = other.size();
    _data = new T[other.size()];
    typename BaseMeasureVector::iterator it2;
    typename BaseMeasureVector::const_iterator it1, e = other.end();
    
    for(it1 = other.begin(), it2 = begin(); it1 < e; it1++, it2++ ) {
      // Copy data
      *it2 = *it1;
    }
  }
  
  template<typename T>
  inline
  typename BaseMeasureVector<T>::iterator BaseMeasureVector<T>::begin() {
    return (&*_data);
  }
 
 
  template<typename T>
  inline
  typename BaseMeasureVector<T>::const_iterator BaseMeasureVector<T>::begin() const {
    return (&*_data);
  }
 
 
  template<typename T>
  inline
  typename BaseMeasureVector<T>::iterator BaseMeasureVector<T>::end() {
    return (&*_data) + size();
  }
 
 
  template<typename T>
  inline
  typename BaseMeasureVector<T>::const_iterator BaseMeasureVector<T>::end() const {
    return (&*_data) + size();
  }
 
  template<typename T>
  inline
  T &BaseMeasureVector<T>::operator [] ( unsigned x ) { 
    ASSERT(x < size());
    return (&*_data)[x];
  }
  
  template<typename T>
  inline
  T &BaseMeasureVector<T>::operator [] ( unsigned x ) const { 
    ASSERT(x < size());
    return (&*_data)[x];
  }
  
  
  template<typename T>
  inline
  BaseMeasureVector<T>& BaseMeasureVector<T>::operator = (const BaseMeasureVector<T> &other) {
    ASSERT(size() == other.size());
    for (int32_t i = 0; i < size(); i++)
      (*this)[i] = other[i];
    
    return (*this);
  }
  
  template<typename T>
  inline
  BaseMeasureVector<T>& BaseMeasureVector<T>::operator = (const T &val) { 
    for (int32_t i = 0; i < size(); i++)
      (*this)[i] = val;
    
    return (*this);
  }
  
  template<typename T>
  inline
  BaseMeasureVector<T>& BaseMeasureVector<T>::operator += (const BaseMeasureVector<T> &other) { 
    ASSERT(size() == other.size());
    for (int32_t i = 0; i < size(); i++)
      (*this)[i] += other[i];
    
    return (*this);
  }
  
  template<typename T>
  inline
  BaseMeasureVector<T>& BaseMeasureVector<T>::operator -= (const BaseMeasureVector<T> &other) { 
    ASSERT(size() == other.size());
    for (int32_t i = 0; i < size(); i++)
      (*this)[i] -= other[i];
    
    return (*this);
  }
    
  template<typename T>
  inline
  BaseMeasureVector<T>& BaseMeasureVector<T>::operator *= (const T &val) {
    for (int32_t i = 0; i < size(); i++)
      (*this)[i] *= val;
      
    return(*this); 
  }
  
  template<typename T>
  inline
  BaseMeasureVector<T>& BaseMeasureVector<T>::operator /= (const T &val) {
    ASSERT(val != 0);
    for (int32_t i = 0; i < size(); i++)
      (*this)[i] /= val;
    
    return(*this); 
  }
 
  // Euclidian distance
  template<typename T>
  inline
  double BaseMeasureVector<T>::distance (const BaseMeasureVector<T> &aa) const {
    double result = 0.;
    for (int32_t i = 0; i < size(); i++) {
      result += (aa[i] - (*this)[i]) * (aa[i] - (*this)[i]);
    }
    
    return( sqrt( result ) );
  }
 
  template<typename T>
  inline
  BaseMeasureVector<T> operator + (const BaseMeasureVector<T> &aa,
                                   const BaseMeasureVector<T> &bb) {
    BaseMeasureVector<T> a(aa);
    a += bb;
    return a;
  }
    
  template<typename T>
  inline
  BaseMeasureVector<T> operator - (const BaseMeasureVector<T> &aa,
                                   const BaseMeasureVector<T> &bb) {
    BaseMeasureVector<T> a(aa);
    a -= bb;
    return a;
  }
    
    
  template<typename T>
  inline
  BaseMeasureVector<T> operator * (const BaseMeasureVector<T>  &aa,
                                   const T &bb) {
    BaseMeasureVector<T> a(aa);
    a *= bb;
    return a;
  }
    
  template<typename T>
  inline
  BaseMeasureVector<T> operator * (const T &aa,
                                   const BaseMeasureVector<T>  &bb) { 
    return (bb * aa);
  }
  
  template<typename T>
  inline
  BaseMeasureVector<T> operator / (const BaseMeasureVector<T>  &aa,
                                   const T &bb) { 
    BaseMeasureVector<T> a(aa);
    a /= bb;
    return a;
  }
 
  typedef bio::BaseMeasureVector<double> MeasureVector;
 
  template<typename T>
  inline
  std::ostream& operator << (std::ostream &out, const bio::BaseMeasureVector<T> &aa) {
    out << '(';
    for (int32_t i = 0; i < aa.size(); i++) {
      out << carto::toString(aa[i]);
      if (i < (aa.size() - 1))
        out << ',';
    }
    out << ')';
 
    return out;
  }
 
} // namespace bio
 
template< typename T >
inline 
void printVector( std::ostream& os, const std::vector<T> & thing )
{
  typename std::vector<T>::const_iterator i, e = thing.end();
  os << "[ ";
  for(i = thing.begin(); i < e; ++i)
  {
    os << *i;
    if (i < (e - 1))
      os << ", ";
  }
  os << " ]";
}
 
namespace carto {
 
  inline std::ostream& operator << ( std::ostream& os, const carto::Array<double> & thing )
  {
    printVector<double>(os, thing);
    return os;
  }
 
  inline std::ostream& operator << ( std::ostream& os, const carto::Array<int> & thing )
  {
    printVector<int>(os, thing);
    return os;
  }
 
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<double> )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<double>::interfaced_iterator )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<float> )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<float>::interfaced_iterator )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<int> )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<int>::interfaced_iterator )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<carto::Array<int> > )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<carto::Array<int> >::interfaced_iterator )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<carto::Array<carto::Array<int> > > )
  DECLARE_GENERIC_OBJECT_TYPE( carto::Array<carto::Array<carto::Array<int> > >::interfaced_iterator )
}
 
#endif