VectorLarge.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2002 Ralf Deiterding
// Brandenburgische Universitaet Cottbus
//
// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@amroc.net

#ifndef AMROC_VECTORLARGE_H
#define AMROC_VECTORLARGE_H

#include "generic.h" 
#include <iostream>
#include <cassert>
#include <cstring>
#include <cmath>

template <class DataType, int size>
class Vector {
  typedef Vector<DataType,size> TVector;

public:
  typedef DataType InternalDataType;

  Vector() {}
  Vector(const TVector& x) { 
    std::memcpy((void *) data_, (void *) x.data_, sizeof(TVector));
  }
  Vector(const DataType& v) { 
    for (register int n=0; n<size; n++)
      data_[n] = v; 
  }

  ~Vector() {}
  
  inline DataType * data() { return data_; }
  inline const DataType * data() const { return data_; }
  inline int length() const { return size; }
  static int Length() { return size; }

  inline DataType operator()(int i) const {
#ifdef DEBUG_PRINT
    assert((i >= 0) && (i < size)); 
#endif
    return data_[i];
  }
  inline DataType& operator()(int i) { 
#ifdef DEBUG_PRINT
    assert((i >= 0) && (i < size)); 
#endif
    return data_[i];
  }

  inline DataType operator[](int i) const {
#ifdef DEBUG_PRINT
    assert((i >= 0) && (i < size)); 
#endif
    return data_[i];
  }
  inline DataType& operator[](int i) { 
#ifdef DEBUG_PRINT
    assert((i >= 0) && (i < size)); 
#endif
    return data_[i];
  }

  inline TVector& operator=(const TVector& x) { 
    std::memcpy((void *) data_, (void *) x.data_, sizeof(TVector));
    return *this; 
  }
  inline TVector& operator=(const DataType& v) { 
    for (register int n=0; n<size; n++)
      data_[n] = v; 
    return *this; 
  }

#define Vector_Vector_Operator(ope,op)                          \
   inline TVector& operator ope (const TVector &x)              \
     {                                                          \
       for (register int n=0; n<size; n++)                      \
         data_[n] ope x.data_[n];                               \
       return(*this);                                           \
     }                                                          \
   inline TVector operator op (const TVector &x) const          \
     {                                                          \
       TVector ret(*this);                                      \
       for (register int n=0; n<size; n++)                      \
         ret.data_[n] ope x.data_[n];                           \
       return(ret);                                             \
     }
   Vector_Vector_Operator(+=,+)
   Vector_Vector_Operator(-=,-)
   Vector_Vector_Operator(*=,*)
   Vector_Vector_Operator(/=,/)
#undef Vector_Vector_Operator

#define Vector_Scalar_Operator(ope,op)                          \
   inline TVector& operator ope (const DataType &v)             \
     {                                                          \
       for (register int n=0; n<size; n++)                      \
         data_[n] ope v;                                        \
       return(*this);                                           \
     }                                                          \
   inline TVector operator op (const DataType &v) const         \
     {                                                          \
       TVector ret(*this);                                      \
       for (register int n=0; n<size; n++)                      \
         ret.data_[n] ope v;                                    \
       return(ret);                                             \
     }
   Vector_Scalar_Operator(+=,+)
   Vector_Scalar_Operator(-=,-)
   Vector_Scalar_Operator(*=,*)
   Vector_Scalar_Operator(/=,/)
#undef Vector_Scalar_Operator

   /* Define the negation operator */
   inline TVector operator - () const
     { 
       TVector ret;
       for (register int n=0; n<size; n++)
         ret.data_[n] = -data_[n];
       return(ret);
     }

#define Vector_Vector_RelOperator(op)                           \
   inline int operator op (const TVector &x) const              \
     {                                                          \
       bool ret = (data_[0] op x.data_[0]);                     \
       for (register int n=1; n<size; n++)                      \
         ret = ret && (data_[n] op x.data_[n]);                 \
       return(ret);                                             \
     }                     

   Vector_Vector_RelOperator(==)
   Vector_Vector_RelOperator(!=)
#undef Vector_Vector_RelOperator

#define Vector_Vector_RelOperator(op)                           \
   inline int operator op (const TVector &x) const              \
     {                                                          \
       bool ret = (data_[0] op x.data_[0]);                     \
       for (register int n=1; n<size; n++)                      \
         ret = ret || (data_[n] op x.data_[n]);                 \
       return(ret);                                             \
     }                     

   Vector_Vector_RelOperator(>)
   Vector_Vector_RelOperator(<)
   Vector_Vector_RelOperator(>=)
   Vector_Vector_RelOperator(<=)
#undef Vector_Vector_RelOperator

#define Vector_Scalar_RelOperator(op)                          \
   inline int operator op (const DataType &v) const            \
     {                                                         \
       bool ret = (data_[0] op v);                             \
       for (register int n=1; n<size; n++)                     \
         ret = ret && (data_[n] op v);                         \
       return(ret);                                            \
     }                     

   Vector_Scalar_RelOperator(==)
   Vector_Scalar_RelOperator(!=)
#undef Vector_Scalar_RelOperator

#define Vector_Scalar_RelOperator(op)                          \
   inline int operator op (const DataType &v) const            \
     {                                                         \
       bool ret = (data_[0] op v);                             \
       for (register int n=1; n<size; n++)                     \
         ret = ret || (data_[n] op v);                         \
       return(ret);                                            \
     }                     

   Vector_Scalar_RelOperator(>)
   Vector_Scalar_RelOperator(<)
   Vector_Scalar_RelOperator(>=)
   Vector_Scalar_RelOperator(<=)
#undef Vector_Scalar_RelOperator

   /* Define elementwise minimum and maximum functions for Vectors */
   inline void min(const TVector &x) { 
     for (register int n=0; n<size; n++)                             
       data_[n] = (data_[n] < x.data_[n]) ? data_[n] : x.data_[n]; 
   }
   inline void max(const TVector &x) {
     for (register int n=0; n<size; n++)                             
       data_[n] = (data_[n] > x.data_[n]) ? data_[n] : x.data_[n]; 
   }

   /* Define minimum and maximum of components */
   inline DataType mincomp() const { 
     DataType min = data_[0];
     for (register int n=1; n<size; n++)                             
       if (data_[n] < min) min = data_[n]; 
     return min;
   }
   inline DataType maxcomp() const { 
     DataType max = data_[0];
     for (register int n=1; n<size; n++)                             
       if (data_[n] > max) max = data_[n]; 
     return max;
   }

   inline double abs() const {
     DataType s = data_[0]*data_[0];
     for (register int n=1; n<size; n++)     
       s += data_[n]*data_[n]; 
     return (std::sqrt(static_cast<double>(s)));
   }

   inline TVector getmin(const TVector &x) const
     { TVector ret(*this); ret.min(x); return(ret); }
   inline TVector getmax(const TVector &x) const
     { TVector ret(*this); ret.max(x); return(ret); }

public:
   DataType data_[size];
};


template <class DataType, int size>
inline std::ostream&  operator << (std::ostream& os, const Vector<DataType,size> &v) {
  os << "(" << v.data_[0];
  for (register int n=1; n<size; n++)     
    os << "," << v.data_[n]; 
  os << ")";
  return os;
}


#define Global_Vector_Scalar_Operator(op)                                  \
template <class DataType, int size>                                        \
inline Vector<DataType,size> operator op (const DataType &v,               \
   const Vector<DataType,size> &x)                                         \
   { return(x op v); }

Global_Vector_Scalar_Operator(+)
Global_Vector_Scalar_Operator(-)
Global_Vector_Scalar_Operator(*)
Global_Vector_Scalar_Operator(/)
#undef Global_Vector_Scalar_Operator


#define Global_Vector_Function(fct)                                       \
template <class DataType, int size>                                       \
inline Vector<DataType,size> fct(const Vector<DataType,size> &x)          \
   {                                                                      \
     Vector<DataType,size> ret;                                           \
     for (register int n=0; n<size; n++)                                  \
       ret[n] = std::fct(x[n]);                                           \
     return(ret);                                                         \
   }

Global_Vector_Function(fabs)
Global_Vector_Function(sqrt)
#undef Global_Vector_Function


  template <class DataType, int size>
inline Vector<DataType,size> Min(const Vector<DataType,size> &x, 
                                 const Vector<DataType,size> &y) 
  { Vector<DataType,size> ret(x); ret.min(y); return(ret); }

template <class DataType, int size>
inline Vector<DataType,size> Max(const Vector<DataType,size> &x, 
                                 const Vector<DataType,size> &y) 
  { Vector<DataType,size> ret(x); ret.max(y); return(ret); }

template <class DataType, int size>
inline double Abs(const Vector<DataType,size> &x) 
  { return (x.abs()); }

template <class DataType, int size>
inline DataType mincomp(const Vector<DataType,size> &x) 
  { return(x.mincomp()); }

template <class DataType, int size>
inline DataType maxcomp(const Vector<DataType,size> &x) 
  { return(x.maxcomp()); }


#define Vector_Vector_Functions(NameTo,NameFrom,ope)                      \
  template <class DataType, class VectorType, int size>                   \
  inline void NameTo (Vector<DataType,size> &x, const VectorType &y)      \
    {                                                                     \
      for (register int n=0; n<size; n++)                                 \
        x(n) ope y(n);                                                    \
    }                                                                     \
  template <class DataType, class VectorType, int size>                   \
  inline void NameFrom (VectorType &x, const Vector<DataType,size> &y)    \
    {                                                                     \
      for (register int n=0; n<size; n++)                                 \
        x(n) ope y(n);                                                    \
    }

   Vector_Vector_Functions(equals_to,equals_from,=)
   Vector_Vector_Functions(plus_to,plus_from,+=)
   Vector_Vector_Functions(minus_to,minus_from,-=)
   Vector_Vector_Functions(multiply_to,multiply_from,*=)
   Vector_Vector_Functions(divide_to,divide_from,/=)
#undef Vector_Vector_Functions


#endif

---