itkVariableLengthVector.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkVariableLengthVector_h
#define itkVariableLengthVector_h

#include "itkNumericTraits.h"

namespace itk
{
template< typename TValue >
class VariableLengthVector
{
public:

  typedef TValue                                        ValueType;
  typedef TValue                                        ComponentType;
  typedef typename NumericTraits< ValueType >::RealType RealValueType;
  typedef VariableLengthVector                          Self;

  typedef unsigned int ElementIdentifier;

  VariableLengthVector();

  explicit VariableLengthVector(unsigned int dimension);

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

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

  template< typename 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< TValue > & v);

  void Fill(TValue const & v);

  template< typename T >
  const VariableLengthVector< TValue > & 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);

  const Self & operator=(TValue const & v);

  inline unsigned int Size(void) const { return m_NumElements; }
  inline unsigned int GetNumberOfElements(void) const { return m_NumElements; }

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

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

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

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

  void SetSize(unsigned int sz, bool destroyExistingData = true);

  void DestroyExistingData();

  inline unsigned int GetSize(void) const { return m_NumElements; }

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

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

  ~VariableLengthVector();

  void Reserve(ElementIdentifier);

  TValue * AllocateElements(ElementIdentifier size) const;

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

  template< typename 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< typename 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< typename 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< typename 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+(TValue 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-(TValue 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< typename 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-=(TValue s)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] -= s;
      }
    return *this;
  }

  template< typename 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+=(TValue s)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] += s;
      }
    return *this;
  }

  template< typename T >
  inline Self & operator*=(T s)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] *= ( static_cast< ValueType >( s ) );
      }
    return *this;
  }

  template< typename 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
  TValue *          m_Data;                 // Array to hold data
  ElementIdentifier m_NumElements;
};

template< typename TValue, typename T >
inline
VariableLengthVector< TValue >
operator*(const T & scalar, const VariableLengthVector< TValue > & v)
{
  return v.operator*(scalar);
}


template< typename TValue >
std::ostream & operator<<(std::ostream & os, const VariableLengthVector< TValue > & 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"

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkVariableLengthVector.hxx"
#endif

#endif