MeVis/Foundation/Sources/MLLinearAlgebra/mlIntegerVector.h

Go to the documentation of this file.

// **InsertLicense** code 
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
#ifndef __mlIntegerVector_H
#define __mlIntegerVector_H

// ML-includes
#ifndef __mlLinearAlgebra_H
#include "mlLinearAlgebra.h"
#endif


ML_START_NAMESPACE

  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  typedef int VectorDimIdxType;

  //-------------------------------------------------------------------------
  //-------------------------------------------------------------------------
  template <typename CompIntType, VectorDimIdxType NumDim> 
  class TVectorNDBase 
  {
    public:

    typedef CompIntType ComponentType;

    enum { NumberOfDimensions = NumDim };

    ComponentType array[NumberOfDimensions];

    protected:
    
    TVectorNDBase(){};
  };

  //-------------------------------------------------------------------------

  //-------------------------------------------------------------------------
  template<class TVectorBase> 
  class TVector : public TVectorBase 
  {
  public:

    typedef typename TVectorBase::ComponentType ComponentType;

    typedef TVectorBase ParentClass;

    enum { NumberOfDimensions = ParentClass::NumberOfDimensions };


    //------------------------------------------------------

    //------------------------------------------------------
    inline TVector() : ParentClass()
    {
      ML_TRACE_IN_TIME_CRITICAL( "TVector( )" );
      memset(this->array, 0, static_cast<size_t>(NumberOfDimensions)*sizeof(ComponentType));
    }
  
    inline explicit TVector(const ComponentType i) : ParentClass()
    {
      ML_TRACE_IN_TIME_CRITICAL( "TVector(const ComponentType i)" );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d]=i; }
    }
  
    inline TVector(const TVector<TVectorBase> &v2) : ParentClass()
    {
      ML_TRACE_IN_TIME_CRITICAL( "TVector(const TVector<TVectorBase> &v2)" );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d]=v2.array[d]; }
    }
  
    template <typename TVectorBase2>
    inline explicit TVector(const TVector<TVectorBase2> &v2) : ParentClass()
    {
      ML_TRACE_IN_TIME_CRITICAL( "TVector(const TVector<T2, TVectorBase > &v2)" );
      VectorDimIdxType numDims = NumberOfDimensions;
      if (v2.NumberOfDimensions < numDims){ numDims = v2.NumberOfDimensions; }
      VectorDimIdxType d=0;
      for (; d < numDims; ++d){
        this->array[d] = static_cast<ComponentType>(v2.array[d]);
      }
      for (; d < NumberOfDimensions; ++d){
        this->array[d] = 0;
      }
    }
    
    inline explicit TVector(const ComponentType xp, const TVector &p) : ParentClass()
    {
      ML_TRACE_IN_TIME_CRITICAL( "TVector(const ComponentType xp, const TVector &p)" );
      this->array[0] = xp;
      for (VectorDimIdxType d=1; d < NumberOfDimensions; ++d){ this->array[d] = p.array[d]; }
    }

    inline explicit TVector(const MLint num, const ComponentType* const arr, const ComponentType deflt);
  
    inline void copy(const MLint num, ComponentType* const arr) const;

    inline void set(const ComponentType v=0)
    { 
      ML_TRACE_IN_TIME_CRITICAL("TVector::set(const ComponentType v=0)");
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d]=v; } 
    }

    inline void set(const TVector &v)
    { 
      ML_TRACE_IN_TIME_CRITICAL("TVector::set(const TVector &v)");
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] = v.array[d]; }
    }


    //------------------------------------------------------

    //------------------------------------------------------

    inline TVector<TVectorBase>  operator+ (const TVector &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator + " );
      return TVector<TVectorBase>(*this) += b;
    }
    inline TVector<TVectorBase> &operator+= (const TVector<TVectorBase> &b)       
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator += " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] += b.array[d]; }
      return *this;
    }
    inline TVector<TVectorBase>  operator- (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator - " );
      return TVector<TVectorBase>(*this) -= b;
    }
    inline TVector<TVectorBase> &operator-= (const TVector<TVectorBase> &b)       
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator -= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] -= b.array[d]; }
      return *this;
    }
    inline TVector<TVectorBase>  operator* (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator * " );
      return TVector<TVectorBase>(*this) *= b;
    }
    inline TVector<TVectorBase> &operator*= (const TVector<TVectorBase> &b)       
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator *= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] *= b.array[d]; }
      return *this;
    }
    inline TVector<TVectorBase>  operator+ (const ComponentType b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator + " );
      TVector<TVectorBase> retVec(*this);
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ retVec.array[d] += b; }
      return retVec;
    }
    inline TVector<TVectorBase>  operator- (const ComponentType b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator - " );
      TVector<TVectorBase> retVec(*this);
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ retVec.array[d] -= b; }
      return retVec;
    }
    inline TVector<TVectorBase>  operator* (const ComponentType b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator * " );
      TVector<TVectorBase> retVec(*this);
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ retVec.array[d] *= b; }
      return retVec;
    }
    inline TVector<TVectorBase>  operator/ (const TVector<TVectorBase> &b) const 
    {
      ML_TRACE_IN( "TVector::operator / " );
      return TVector<TVectorBase>(*this) /= b;
    }
    inline TVector<TVectorBase> &operator/= (const TVector<TVectorBase> &b) 
    {
      ML_TRACE_IN( "TVector::operator /= " );
      ML_TRY
      {
        for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ 
          ML_CHECK_THROW(b.array[d]); 
          this->array[d] /= b.array[d];
        }
      }
      ML_CATCH_RETHROW;
      return *this;
    }
    inline bool operator== (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator == " );
      bool retFlag = true;
      for (VectorDimIdxType d=0; retFlag && (d < NumberOfDimensions); ++d){ retFlag &= (this->array[d] == b.array[d]); }
      return retFlag;
    }
    inline bool operator!= (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator != " );
      return !(*this == b);
    }

    inline bool operator< (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator < " );
      bool retFlag = true;
      for (VectorDimIdxType d=0; retFlag && (d < NumberOfDimensions); ++d){ retFlag &= (this->array[d] < b.array[d]); }
      return retFlag;
    }
    inline bool operator<= (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator <= " );
      bool retFlag = true;
      for (VectorDimIdxType d=0; retFlag && (d < NumberOfDimensions); ++d){ retFlag &= (this->array[d] <= b.array[d]); }
      return retFlag;
    }
    inline bool operator> (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator > " );
      bool retFlag = true;
      for (VectorDimIdxType d=0; retFlag && (d < NumberOfDimensions); ++d){ retFlag &= (this->array[d] > b.array[d]); }
      return retFlag;
    }
    inline bool operator>= (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator >= " );
      bool retFlag = true;
      for (VectorDimIdxType d=0; retFlag && (d < NumberOfDimensions); ++d){ retFlag &= (this->array[d] >= b.array[d]); }
      return retFlag;
    }

    inline TVector<TVectorBase>  operator& (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator & " );
      return TVector<TVectorBase>(*this) &= b;
    }
    inline TVector<TVectorBase>  operator| (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator | " );
      return TVector<TVectorBase>(*this) |= b;
    }
    inline TVector<TVectorBase>  operator^  (const TVector<TVectorBase> &b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator ^ " );
      return TVector<TVectorBase>(*this) ^= b;
    }

    inline TVector<TVectorBase> &operator &= (const TVector<TVectorBase> &b)       
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator &= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] &= b.array[d]; }
      return *this; 
    }
    inline TVector<TVectorBase> &operator |= (const TVector<TVectorBase> &b)       
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator |= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] |= b.array[d]; }
      return *this; 
    }
    inline TVector<TVectorBase> &operator ^= (const TVector<TVectorBase> &b)       
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator ^= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] ^= b.array[d]; }
      return *this; 
    }

    inline TVector<TVectorBase>  operator& (const ComponentType b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator & " );
      return TVector<TVectorBase>(*this) &= b;
    }
    inline TVector<TVectorBase>  operator| (const ComponentType b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator | " );
      return TVector<TVectorBase>(*this) |= b;
    }
    inline TVector<TVectorBase>  operator^ (const ComponentType b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator ^ " );
      return TVector<TVectorBase>(*this) ^= b;
    }

    inline TVector<TVectorBase> &operator&= (const ComponentType b)                 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator &= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] &= b; }
      return *this; 
    }
    inline TVector<TVectorBase> &operator|= (const ComponentType b)                 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator |= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] |= b; }
      return *this; 
    }
    inline TVector<TVectorBase> &operator^= (const ComponentType b)                 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator ^= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] ^= b; }
      return *this; 
    }

    inline TVector<TVectorBase>  operator>> (const int b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator >> " );
      return TVector<TVectorBase>(*this) >>= b;
    }
    inline TVector<TVectorBase>  operator<< (const int b) const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator << " );
      return TVector<TVectorBase>(*this) <<= b;
    }

    inline TVector<TVectorBase> &operator>>= (const int b)                
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator >>= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] >>= b; }
      return *this; 
    }
    inline TVector<TVectorBase> &operator<<= (const int b)                
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator <<= " );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] <<= b; }
      return *this; 
    }

    inline TVector<TVectorBase>  operator- () const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::operator - " );
      TVector<TVectorBase> retVec(*this);
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ retVec.array[d] = -retVec.array[d]; }
      return retVec;
    }

    // Note: No tracing! No try, No catch! Do nothing here which could degrade performance!
    inline ComponentType operator[](const size_t i) const { return this->array[i]; }

    // Note: No tracing! No try, No catch! Do nothing here which could degrade performance!
    inline ComponentType &operator[](const size_t i)      { return this->array[i]; }

    inline MLint getMaxIdx() const 
    {
      ML_TRACE_IN_TIME_CRITICAL( "TVector::getMaxIdx()" );
      VectorDimIdxType idx = NumberOfDimensions-1; 
      ComponentType      val = this->array[idx];
      for (VectorDimIdxType d=NumberOfDimensions-2; d >=0; d--){ 
        if (this->array[d] >= val){ idx=d; val=this->array[d]; } 
      }
      return idx;
    }

    inline ComponentType getMax() const 
    {
      ML_TRACE_IN_TIME_CRITICAL( "TVector::getMax()" );
      return this->array[getMaxIdx()];
    }

    inline MLint getMinIdx() const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::getMinIdx()" );
      VectorDimIdxType idx = NumberOfDimensions-1; 
      ComponentType      val = this->array[idx];
      for (VectorDimIdxType d=NumberOfDimensions-2; d >= 0; d--){ 
        if (this->array[d] <= val){ idx=d; val=this->array[d]; }
      }
      return idx;
    }

    inline ComponentType getMin() const 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::getMin()" );
      return this->array[getMinIdx()];
    }

    inline TVector<TVectorBase> getStrides(const ComponentType offset=1) const;

    inline TVector<TVectorBase> getVectorPosition(ComponentType offsetPos) const;

    inline MLint getExtDimension() const;

    inline bool hasNegativeComp() const 
    {
      ML_TRACE_IN_TIME_CRITICAL( "TVector::hasNegativeComp()" );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ if (this->array[d]<0){ return true; } }
      return false; 
    }

    inline bool allBiggerZero() const
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::allBiggerZero()" );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ if (this->array[d]<=0){ return false; } }
      return true; 
    }


    //------------------------------------------------------

    //------------------------------------------------------
    // Methods:
    inline TVector<TVectorBase> divCeil(const TVector<TVectorBase> &b) const { return TVector<TVectorBase>::divCeil(*this, b); }
    inline TVector<TVectorBase> compMin(const TVector<TVectorBase> &b) const { return TVector<TVectorBase>::compMin(*this, b); }
    inline TVector<TVectorBase> compMax(const TVector<TVectorBase> &b) const { return TVector<TVectorBase>::compMax(*this, b); }
    inline TVector<TVectorBase> compMod(const TVector<TVectorBase> &b) const { return TVector<TVectorBase>::compMod(*this, b); }
    inline TVector<TVectorBase> compAbs()                              const { return TVector<TVectorBase>::compAbs(*this);    }

    inline ComponentType          compMul()                              const { return TVector<TVectorBase>::compMul(*this);    }
    inline ComponentType          compSum()                              const { return TVector<TVectorBase>::compSum(*this);    }

    inline ComponentType          dot(const TVector<TVectorBase> &b)     const { return TVector<TVectorBase>::dot(*this, b);     }

    static TVector<TVectorBase> divCeil(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b);
    static TVector<TVectorBase> compMin(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b);
    static TVector<TVectorBase> compMax(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b);
    static TVector<TVectorBase> compMod(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b);
    static TVector<TVectorBase> compAbs(const TVector<TVectorBase> &a);

    inline static ComponentType   compMul(const TVector<TVectorBase> &a) 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::compMul()" );
      ComponentType retVal = a.array[0];
      for (VectorDimIdxType d=1; d < NumberOfDimensions; ++d){ retVal *= a.array[d]; }
      return retVal;
    }
    inline static ComponentType   compSum(const TVector<TVectorBase> &a) 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::compSum()" );
      ComponentType retVal = a.array[0];
      for (VectorDimIdxType d=1; d < NumberOfDimensions; ++d){ retVal += a.array[d]; }
      return retVal;
    }


    inline static ComponentType dot(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b) 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::dot()" );
      ComponentType retVal = a.array[0]*b.array[0];
      for (VectorDimIdxType d=1; d < NumberOfDimensions; ++d){ retVal += a.array[d]*b.array[d]; }
      return retVal;
    }

    inline void fillSmallerComps(const ComponentType threshold=0, const ComponentType fillVal=0) 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::fillSmallerComps()" );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ if (this->array[d] < threshold){ this->array[d] = fillVal; } }
    }

    inline void fillGreaterComps(const ComponentType threshold=0, const ComponentType fillVal=0) 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::fillGreaterComps()" );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ if (this->array[d] > threshold){ this->array[d] = fillVal; } }
    }

    inline void fillEqualComps(const ComponentType threshold=0, const ComponentType fillVal=0) 
    { 
      ML_TRACE_IN_TIME_CRITICAL( "TVector::fillEqualComps()" );
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ if (this->array[d] == threshold){ this->array[d] = fillVal; } }
    }

    std::string print(const std::string &openStr="",
                      const std::string &sepStr=" ",
                      const std::string &termStr="",
                      const MLint16 numDigits=-1) const;

  };

ML_END_NAMESPACE


//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std {

  template <class TVectorBase>
  inline ostream& operator<<(ostream& s, const ML_NAMESPACE::TVector<TVectorBase> &v){
    s << "(";
    for (ML_NAMESPACE::VectorDimIdxType d=0; d < ML_NAMESPACE::TVector<TVectorBase>::NumberOfDimensions-1; ++d){ s << v.array[d] << ","; }
    s << v.array[ML_NAMESPACE::TVector<TVectorBase>::NumberOfDimensions-1];
    s << ")";
    return s;
  };

}



ML_START_NAMESPACE


  //------------------------------------------------------
  //            TVector<TVectorBase>       
  //------------------------------------------------------
  // Constructor which initializes the vector components by copying them from
  // arr[0] ,..., arr[num-1]. All other elements are initialized to
  // the value deflt.
  template <class TVectorBase>
  inline TVector<TVectorBase>::TVector(const MLint num, const ComponentType* const arr, const ComponentType deflt) : ParentClass()
  {
    ML_TRACE_IN( "TVector<TVectorBase>::TVector" );
    ML_TRY
    {      
      ML_CHECK_THROW(arr);
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ this->array[d] = (num>d ? arr[d] : deflt); }
    }
    ML_CATCH_RETHROW;
  }

  // Copy the first num elements from internal array into arr
  // starting with array[0] to arr[0] to array[num-1] to arr[num-1], respectively.
  // All other components are left unchanged.
  // arr must have at least num entries and at most NumberOfDimensions elements are copied.
  template <class TVectorBase>
  inline void TVector<TVectorBase>::copy(const MLint num, ComponentType* const arr) const
  {
    ML_TRACE_IN( "TVector<TVectorBase>::copy" );
    ML_TRY
    {
      ML_CHECK_THROW(arr);
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ if (num>d){ arr[d] = this->array[d]; } }
    }
    ML_CATCH_RETHROW;
  }

  // Interprets vector as image extent and returns a stride vector.
  // The smallest stride (the x stride) is set to offset, i.e. an
  // image voxel is assumed to have size = offset.
  // So stride.x = offset, stride.y = offset*x, stride.z = offset*x*y, ...,
  // stride.u=offset*x*y*z*c*t.
  template <class TVectorBase>
  inline TVector<TVectorBase> TVector<TVectorBase>::getStrides(const ComponentType offset) const
  {
    ML_TRACE_IN_TIME_CRITICAL( "TVector<TVectorBase>::getStrides" );
    TVector<TVectorBase> stride;
    stride.array[0] = offset;
    for (VectorDimIdxType d=1; d < NumberOfDimensions; ++d){ stride.array[d] = stride.array[d-1] * this->array[d-1]; }
    return stride;
  }

  // Interprets the vector as a stride vector of an image and returns the offset
  // position offsetPos from the image origin to the coordinate specified by
  // the vector. For offsetPos, an image with extents given by *this and the return
  // value rv then holds:
  // \code offsetPos = rv.x*x + rv.y*y + ... + rv.u*u \endcode )
  template <class TVectorBase>
  inline TVector<TVectorBase> TVector<TVectorBase>::getVectorPosition(ComponentType offsetPos) const
  {
    ML_TRACE_IN_TIME_CRITICAL( "TVector<TVectorBase>::getVectorPosition" );
      
    TVector<TVectorBase> vectorPos;
    
    ML_TRY
    {
      for (VectorDimIdxType d=NumberOfDimensions-1; d>=1; d--){ 
        ML_CHECK_THROW(this->array[d]);
        vectorPos.array[d] = offsetPos / this->array[d];
        offsetPos = offsetPos % this->array[d];
      }
      ML_CHECK_THROW(this->array[0]);
      vectorPos.array[0] = offsetPos / this->array[0];
    }
    ML_CATCH_RETHROW;
    
    return vectorPos;
  }

  // Returns the highest vector component which is not 1. Useful to get the real dimension of an image.
  template <class TVectorBase>
  inline MLint TVector<TVectorBase>::getExtDimension() const
  {
    ML_TRACE_IN_TIME_CRITICAL( "TVector<TVectorBase>::getExtDimension()" );
      
    VectorDimIdxType dimen = 1;
    for (VectorDimIdxType d=NumberOfDimensions-1; d >=1; d--){ 
      if (1 != this->array[d]){ 
        dimen = d+1;
        break;
      }
    }
    return dimen;
  }

  // Return the componentwise division of the vector this by vector b with rounding up.
  // Division by zero caused by zero components of b must be avoided by caller.
  template <class TVectorBase>
  inline TVector<TVectorBase> TVector<TVectorBase>::divCeil(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TVector<TVectorBase>::divCeil" );
      
    TVector<TVectorBase> c;
    
    ML_TRY
    {
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ 
        ML_CHECK_THROW(b.array[d]);
        c.array[d] = static_cast<ComponentType>(ceil(static_cast<MLdouble>(a.array[d])/b.array[d]));
      }
    }
    ML_CATCH_RETHROW;    
    return c;
  }


  // Return the componentwise minimum of TVector<TVectorBase>s this and b.
  template <class TVectorBase>
  inline TVector<TVectorBase> TVector<TVectorBase>::compMin(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TVector<TVectorBase>::compMin" );
      
    TVector<TVectorBase> c(b);
    for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ 
      if (a.array[d] < c.array[d]){ c.array[d] = a.array[d]; }
    }
    return c;
  }

  // Return the componentwise maximum of vectors this and b.
  template <class TVectorBase>
  inline TVector<TVectorBase> TVector<TVectorBase>::compMax(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TVector<TVectorBase>::compMax" );
      
    TVector<TVectorBase> c(b);
    for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ 
      if (a.array[d] > c.array[d]){ c.array[d] = a.array[d]; }
    }
    return c;
  }

  // Return the rest dividing vector this a by b componentwise.
  // Division by zero caused by zero components of b must be avoided by caller and will 
  // be handled as fatal error exception otherwise.
  template <class TVectorBase>
  inline TVector<TVectorBase> TVector<TVectorBase>::compMod(const TVector<TVectorBase> &a, const TVector<TVectorBase> &b)
  {
    ML_TRACE_IN_TIME_CRITICAL( "TVector<TVectorBase>::compMod" );
      
    TVector<TVectorBase> c;
    ML_TRY
    {
      for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ 
        ML_CHECK_THROW(b.array[d]);
        c.array[d] = a.array[d] % b.array[d];
      }
    }
    ML_CATCH_RETHROW;
    return c;
  }

  // Return a vector with all components of a replaced by their absolute values.
  template <class TVectorBase>
  inline TVector<TVectorBase> TVector<TVectorBase>::compAbs(const TVector<TVectorBase> &a) 
  {
    ML_TRACE_IN_TIME_CRITICAL( "TVector<TVectorBase>::compAbs" );
      
    TVector<TVectorBase> c(a);
    for (VectorDimIdxType d=0; d < NumberOfDimensions; ++d){ 
      if (c.array[d]<0){ c.array[d] = -c.array[d]; }
    }
    return c;
  }

  // Returns the string openStr + v.x + sepStr + ... + v.t + sepStr + v.u + termStr.
  // numDigits is the number of digits to be used as print parameter.
  // If numDigits is <=0 then no space specification is used.
  template <class TVectorBase>
  inline std::string TVector<TVectorBase>::print(const std::string &openStr,
                                                 const std::string &sepStr,
                                                 const std::string &termStr,
                                                 const MLint16      numDigits) const
  {
    ML_TRACE_IN( "TVector<TVectorBase>::print" );

    std::string result = openStr;
    ML_TRY
    {
      // 512 chars are sufficient, because MLint64 or even in future MLint 
      // as 128 bit version does not use more than 2^128 digits which are 
      // about 10^43.
      char buf [512]="";
      char frmt[100]="";

      // Create a format string with or without space specifications 
      // dependent on numDigits.
      if (numDigits>=0){
        MLsnprintf(frmt, 99, "%%%dI64Ld", numDigits);
      }
      else{
        MLsnprintf(frmt, 99, "%%I64Ld");
      }

      // Print all vector components with platform independent MLsnprintf, 
      // because MLint64 prints are needed and 64 bit integer print is 
      // platform dependent.
      for (VectorDimIdxType d=0; d < NumberOfDimensions-1; ++d){ 
        MLsnprintf(buf, 511, frmt, this->array[d]); 
        result += buf + sepStr;
      }
      MLsnprintf(buf, 511, frmt, this->array[NumberOfDimensions-1]); 
      result += buf + termStr;
    }
    ML_CATCH_RETHROW;
    return result;
  }

ML_END_NAMESPACE

#endif //of __mlIntegerVector_H