Search  

---

C:/temp/src/j2k/Beta/Math/Vector.hpp

Go to the documentation of this file.

#ifndef __J2K__Vector_HPP__
#define __J2K__Vector_HPP__

#include <j2k/Fred/Basic.hpp>
#include <j2k/Fred/Boolean.hpp>
#include <j2k/Fred/StdTypes.hpp>

// len==0 should throw NO DATA

#define MC_Create_Vector( NAME, TYPE )                                     \
class Vector ## NAME                                                       \
{                                                                          \
private:                                                                   \
    /* Data contained in class Vector */                                   \
    TYPE* data;                                                            \
                                                                           \
    /* Length of the vector */                                             \
    ULONG length;                                                          \
                                                                           \
    /*   Sets length of vector to newLen       */                          \
    /*   and copies data newData into vector.  */                          \
    void init( ULONG newLen, const TYPE* newData = NULL ) {                \
          empty();                                                         \
                                                                           \
        length = newLen;                                                   \
                                                                           \
        if ( newData != NULL ) {                                           \
          if ( length == 0 ) length++;                                     \
            data = new TYPE[ length ];                                     \
            assert( data != NULL );                                        \
                                                                           \
            /* Copy in new data from initialization */                     \
            memcpy( data, newData, length * sizeof( TYPE ) );              \
        }                                                                  \
     }                                                                     \
                                                                           \
public:                                                                    \
  Vector ## NAME ## ( ULONG length = 0, const TYPE* newData = NULL )       \
    : data( NULL ), length( 0 )                                            \
  {                                                                        \
    init( length, newData );                                               \
  }                                                                        \
                                                                           \
  Vector ## NAME ## ( const Vector ## NAME ## & v )                        \
    : data( NULL ), length( 0 )                                            \
  {                                                                        \
    init( v.length, v.data );                                              \
  }                                                                        \
                                                                           \
  virtual ~Vector ## NAME ## () {                                          \
    empty();                                                               \
  }                                                                        \
                                                                           \
  Vector ## NAME ## & setLength( ULONG newLen ) {                          \
    init( newLen );                                                        \
    return *this;                                                          \
  }                                                                        \
                                                                           \
  BOOL isEmpty() const {                                                   \
    return ( data == NULL );                                               \
  }                                                                        \
                                                                           \
  /* Clear data members */                                                 \
  void empty() {                                                           \
    if ( data != NULL ) {                                                  \
      delete [] data;                                                      \
      data = NULL;                                                         \
    }                                                                      \
    length = 0;                                                            \
  }                                                                        \
                                                                           \
  ULONG length() const { return length; }                                  \
                                                                           \
  Vector ## NAME ## & operator=( const Vector ## NAME ## & v ) {           \
    if ( &v != this ) {                                                    \
      init( v.length, v.data );                                            \
    }                                                                      \
    return *this;                                                          \
  }                                                                        \
                                                                           \
  /* Set all elements of vector equal to a constant */                     \
  Vector ## NAME ## & operator=( const TYPE t ) {                          \
    TYPE *pt = data;                                                       \
    for ( int i = 0; i < length; i++ ) {                                   \
       *pt++ = t;                                                          \
    }                                                                      \
    return *this;                                                          \
  }                                                                        \
                                                                           \
  /* Return an element of the vector */                                    \
  TYPE& operator[]( ULONG element ) {                                      \
    assert( !isEmpty() );                                                  \
    assert( element < length );                                            \
    return data[element];                                                  \
  }                                                                        \
                                                                           \
  const TYPE operator[]( ULONG element ) const {                           \
    assert( !isEmpty() );                                                  \
    assert( element < length );                                            \
    return data[element];                                                  \
  }                                                                        \
                                                                           \
  /* Allow fast read-only access to data */                                \
  const TYPE* getData( ULONG len, ULONG b = 0 ) const {                    \
    assert( !isEmpty() );                                                  \
    assert( (b+len) < length );                                            \
    return &data[b];                                                       \
  }                                                                        \
                                                                           \
  /* Return a new read-only subvector of this vector */                    \
  const Vector ## NAME ## operator()( ULONG b, ULONG len ) const {         \
    assert( !isEmpty() );                                                  \
    assert( (b+len) < length );                                            \
                                                                           \
    /* Verify this !!! */                                                  \
                                                                           \
    Vector ## NAME                                                         \
      vRet( len, &data[b] );                                               \
                                                                           \
    return vRet;                                                           \
  }                                                                        \
                                                                           \
};                                                                         \
                                                                           \
/* Add two vectors, v = v1 + v2 */                                         \
Vector ## NAME ## add( const Vector ## NAME ## & v1,                       \
                       const Vector ## NAME ## & v2 )                      \
{                                                                          \
  ULONG len = min( v1.length(), v2.length() );                             \
  if ( len == 0 ) len++                                                    \
                                                                           \
  Vector ## NAME                                                           \
     vRet( len );                                                          \
                                                                           \
  for ( ULONG i = 0; i < len; i++ ) {                                      \
     vRet[i] = v1[i] + v2[i];                                              \
  }                                                                        \
                                                                           \
  return vRet;                                                             \
}                                                                          \
                                                                           \
/* Substracts two vectors, v = v1 - v2 */                                  \
                                                                           \
Vector ## NAME ## sub( const Vector ## NAME ## & v1,                       \
                       const Vector ## NAME ## & v2 )                      \
{                                                                          \
  ULONG len = min( v1.length(), v2.length() );                             \
  if ( len == 0 ) len++;                                                   \
  Vector ## NAME                                                           \
    vRet( len );                                                           \
                                                                           \
  for ( ULONG i = 0; i < len; i++ ) {                                      \
      vRet[i] = v1[i] - v2[i];                                             \
  }                                                                        \
  return vRet;                                                             \
}                                                                          \
                                                                           \
/* Multiplies two vectors, v = v1 * v2 */                                  \
                                                                           \
Vector ## NAME ## pwisemult( const Vector ## NAME ## & v1,                 \
                             const Vector ## NAME ## & v2 )                \
{                                                                          \
  ULONG len = min( v1.length(), v2.length() );                             \
  if ( len == 0 ) len++;                                                   \
  Vector## NAME                                                            \
    vRet( len );                                                           \
  for ( ULONG i = 0; i < len; i++ ) {                                      \
     vRet[i] = v1[i] * v2[i];                                              \
  }                                                                        \
  return vRet;                                                             \
}                                                                          \
                                                                           \
/* Scalar DOT products of two vectors, v = v1 DOT v2 */                    \
                                                                           \
TYPE mult( const Vector ## NAME ##& v1, const Vector ## NAME ## & v2 )     \
{                                                                          \
  ULONG len = min( v1.length(), v2.length() );                             \
  if ( len == 0 ) len++;                                                   \
  TYPE t = (TYPE)0;                                                        \
  for ( ULONG i = 0; i < len; i++ ) {                                      \
     t += v1[i] * v2[i];                                                   \
  }                                                                        \
  return t;                                                                \
}                                                                          \
                                                                           \
/* Scalar sum of all elements of a vector, s = E( Vi ) */                  \
TYPE sum( const Vector ## NAME ## & v )                                    \
{                                                                          \
  ULONG len = v.length();                                                  \
  if ( len == 0 ) len++;                                                   \
  TYPE t = (TYPE)0;                                                        \
  for ( ULONG i = 0; i < len; i++ ) {                                      \
     t += v[i];                                                            \
  }                                                                        \
  return t;                                                                \
}                                                                          \
                                                                           \
/* Scales all elements of a vector by a float value. */                    \
Vector ## NAME ## scale( float scale, const Vector ## NAME ## & v )        \
{                                                                          \
  ULONG len = v.length();                                                  \
  if ( len == 0 ) len++;                                                   \
  Vector## NAME                                                            \
    vRet( len );                                                           \
                                                                           \
  for( ULONG i = 0; i < len; i++ ) {                                       \
    vRet[i] = (TYPE)(scale * v[i]);                                        \
  }                                                                        \
  return vRet;                                                             \
}                                                                          \
                                                                           \
ostream& operator<<( ostream& os, const Vector## NAME ##& v )              \
{                                                                          \
  ULONG len = v.length();                                                  \
  os << "Vector<" << TYPEid( TYPE ).name();                                \
  os << ">( " << len << " )\n{";                                           \
                                                                           \
  if ( v.isEmpty() ) {                                                     \
    os << "\n};\n";                                                        \
  } else {                                                                 \
   os << "\n\t";                                                           \
    for( ULONG i = 0; i < len - 1; i++ ) {                                 \
      os << v[i] << ", ";                                                  \
    }                                                                      \
    os << v[i] << "\n};\n";                                                \
  }                                                                        \
  return os;                                                               \
}                                                                          \
                                                                           \
BOOL operator!=( const Vector## NAME ##& v1, const Vector## NAME ##& v2 )  \
{                                                                          \
  if ( &v1 == &v2 )                                                        \
    return FALSE;                                                          \
                                                                           \
  if ( v1.length() != v2.length() )                                        \
    return TRUE;                                                           \
                                                                           \
  for ( ULONG i = 0; i < v1.length(); i++ )                                \
    if ( v1[i] != v2[i] )                                                  \
      return TRUE;                                                         \
                                                                           \
  return FALSE;                                                            \
}                                                                          \
                                                                           \
BOOL operator==( const Vector## NAME ##& v1, const Vector## NAME ##& v2 )  \
{                                                                          \
  return ( ! ( v1 != v2 ) );                                               \
}                                                                          \
                                                                            

#endif
                                                                            
                                                                            

---