itkVariableLengthVector.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkVariableLengthVector.h,v $
  Language:  C++
  Date:      $Date: 2009-05-25 08:34:20 $
  Version:   $Revision: 1.16 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkVariableLengthVector_h
#define __itkVariableLengthVector_h

#include "itkMacro.h"
#include "itkNumericTraits.h"

namespace itk
{
template <typename TValueType >
class VariableLengthVector
{
public:
 
  typedef TValueType                                    ValueType;
  typedef TValueType                                    ComponentType;
  typedef typename NumericTraits< ValueType >::RealType RealValueType;
  typedef VariableLengthVector                          Self;

  typedef unsigned int ElementIdentifier;
  
  VariableLengthVector(); 

  VariableLengthVector(unsigned int dimension);

  VariableLengthVector( ValueType* data, unsigned int sz, 
                                        bool LetArrayManageMemory = false);
  
  VariableLengthVector( const ValueType* data, unsigned int sz, 
                                        bool LetArrayManageMemory = false);


  template< class T >
  VariableLengthVector(const VariableLengthVector< T > & v)
    {
    m_NumElements = v.Size();
    m_Data = this->AllocateElements(m_NumElements);
    m_LetArrayManageMemory = true;
    for( ElementIdentifier i=0; i< v.Size(); i++ )
      {
      this->m_Data[i] = static_cast< ValueType >( v[i] );
      }
    }

  VariableLengthVector(const VariableLengthVector< TValueType > & v);
  
  void Fill (TValueType const& v); 

  template< class T >
  const VariableLengthVector< TValueType > & operator= 
                          (const VariableLengthVector< T > & v)
    {
    if( m_Data == static_cast< void * >(const_cast< T * >
              ((const_cast< VariableLengthVector< T > & >(v)).GetDataPointer())) )
      {
      return *this;
      }
    this->SetSize( v.Size() );
    for( ElementIdentifier i=0; i< v.Size(); i++ )
      {
      this->m_Data[i] = static_cast< ValueType >( v[i] );
      }
    return *this;
    }
  
  const Self & operator=(const Self & v);
     
  inline unsigned int Size (void ) const 
    { return m_NumElements; }
  inline unsigned int GetNumberOfElements(void) const 
    { return m_NumElements; }

  TValueType       & operator[](unsigned int i) { return this->m_Data[i]; }
  TValueType const & operator[](unsigned int i) const { return this->m_Data[i]; }

  inline const TValueType & GetElement( unsigned int i ) const
    { return m_Data[i]; }

  void SetElement( unsigned int i, const TValueType & value )
    { m_Data[i] = value; }

  void SetSize(unsigned int sz, bool destroyExistingData=true);
  inline unsigned int GetSize(void) const 
    { return m_NumElements; }

  void SetData(TValueType* data,bool LetArrayManageMemory = false);

  void SetData(TValueType* data, unsigned int sz, bool LetArrayManageMemory = false);

  
  ~VariableLengthVector();


  void Reserve( ElementIdentifier );

  TValueType * AllocateElements( ElementIdentifier size ) const;

  const TValueType* GetDataPointer() const { return m_Data; }

  template< class T > 
  inline Self operator+(const VariableLengthVector< T > &v) const
    {
    // if( m_NumElements != v.GetSize() ) 
    //   { 
    //   itkGenericExceptionMacro( << "Cannot add VariableLengthVector of length " 
    //                             << m_NumElements " and " << v.GetSize() );
    //   }
    const ElementIdentifier length = v.Size();
    Self result( length );
    for( ElementIdentifier i=0; i< length; i++ )
      {
      result[i] = (*this)[i] + static_cast< ValueType >( v[i] );
      }
    return result;
    }
  template< class T > 
  inline Self operator-(const VariableLengthVector< T > &v) const
    {
    // if( m_NumElements != v.GetSize() ) 
    //   { 
    //   itkGenericExceptionMacro( << "Cannot add VariableLengthVector of length " 
    //                             << m_NumElements " and " << v.GetSize() );
    //   }
    const ElementIdentifier length = v.Size();
    Self result( length );
    for( ElementIdentifier i=0; i< length; i++ )
      {
      result[i] = (*this)[i] - static_cast< ValueType >( v[i] );
      }
    return result;
    }
  template< class T > inline Self operator*( T s ) const
    {
    Self result( m_NumElements );
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      result[i] = m_Data[i] * static_cast< ValueType >( s );
      }
    return result;
    }
  template< class T > inline Self operator/( T s ) const
    {
    Self result( m_NumElements );
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      result[i] = static_cast< ValueType >(
                     static_cast< RealValueType >(m_Data[i]) / 
                     static_cast< RealValueType >( s ));
      }
    return result;
    }
  inline Self operator+( TValueType s ) const
    {
    Self result( m_NumElements );
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      result[i] = m_Data[i] + s;
      }
    return result;
    }
  inline Self operator-( TValueType s ) const
    {
    Self result( m_NumElements );
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      result[i] = m_Data[i] - s;
      }
    return result;
    }
  inline Self& operator--()
    {
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      this->m_Data[i] -= static_cast< ValueType >( 1.0 );
      }
    return *this;
    }
  inline Self& operator++() // prefix operator ++v;
    {
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      this->m_Data[i] += static_cast< ValueType >( 1.0 );
      }
    return *this;
    }
  inline Self operator--(int) // postfix operator v--;
    {
    Self tmp(*this);
    --tmp;
    return tmp;
    }
  inline Self operator++(int) // postfix operator v++;
    {
    Self tmp(*this);
    ++tmp;
    return tmp;
    }
  template< class T > inline Self& operator-=
  ( const VariableLengthVector< T > &v )
    {
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      m_Data[i] -= static_cast< ValueType >( v[i] );
      }
    return *this;
    }
  inline Self& operator-=( TValueType s )
    {
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      m_Data[i] -= s;
      }
    return *this;
    }
  template< class T > inline Self& operator+=
                  ( const VariableLengthVector< T > &v )
    {
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      m_Data[i] += static_cast< ValueType >( v[i] );
      }
    return *this;
    }
  inline Self& operator+=( TValueType s )
    {
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      m_Data[i] += s;
      }
    return *this;
    }
  template< class T > inline Self& operator*=( T s )
    {
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      m_Data[i] *= (static_cast< ValueType >( s ));
      }
    return *this;
    }
  template< class T > inline Self& operator/=( T s )
    {
    for( ElementIdentifier i=0; i< m_NumElements; i++ )
      {
      m_Data[i] = static_cast< ValueType >(
                     static_cast< RealValueType >(m_Data[i]) / 
                     static_cast< RealValueType >( s ));
      }
    return *this;
    }
  Self & operator- (); // negation operator
  bool operator==( const Self &v) const;
  bool operator!=( const Self &v) const;
    
  RealValueType GetNorm() const;  

  RealValueType GetSquaredNorm() const;

private:

  bool              m_LetArrayManageMemory; // if true, the array is responsible for memory of data
  TValueType *      m_Data; // Array to hold data
  ElementIdentifier m_NumElements;
};

template< class TValueType, class T >
inline
VariableLengthVector<TValueType>
operator*(const T &scalar, const VariableLengthVector<TValueType> &v)
{
  return v * scalar;
}

  
template <typename TValueType >
std::ostream & operator<<(std::ostream &os, const VariableLengthVector<TValueType> &arr)
{
  const unsigned int length = arr.Size();
  const signed int last   = (unsigned int) length - 1;

  os << "[";
  for (signed int i=0; i < last; ++i)
    {
    os << arr[i] << ", ";
    }
  if (length >= 1)
    {
    os << arr[last];
    }
  os << "]";
  return os;
}

} // namespace itk

#include "itkNumericTraitsVariableLengthVectorPixel.h"

// Define instantiation macro for this template.
#define ITK_TEMPLATE_VariableLengthVector(_, EXPORT, x, y) namespace itk { \
  _(1(class EXPORT VariableLengthVector< ITK_TEMPLATE_1 x >)) \
  namespace Templates { typedef VariableLengthVector< ITK_TEMPLATE_1 x > VariableLengthVector##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkVariableLengthVector+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkVariableLengthVector.txx"
#endif

#endif