MeVis/Foundation/Sources/MLLinearAlgebra/mlFloatingPointVector.h

Go to the documentation of this file.

// **InsertLicense** code
//=====================================================================================

//=====================================================================================
#ifndef __mlFloatingPointVector_H
#define __mlFloatingPointVector_H

//------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#ifndef __mlLinearAlgebraSystem_H
#include "mlLinearAlgebraSystem.h"
#endif

//------------------------------------------------------------------------
//------------------------------------------------------------------------
typedef double (*ML_LA_FROM_DOUBLE_TO_DOUBLE)(double);

//------------------------------------------------------------------------
// Put all stuff in a specific ML_LA_NAMESPACE namespace to avoid
// collisions with other libraries.
//------------------------------------------------------------------------
ML_LA_START_NAMESPACE

template <class DT, size_t size>
class FloatingPointVectorDataContainerBase
{
protected:
  DT _buffer[size];
};


//------------------------------------------------------------------------
//------------------------------------------------------------------------
template <class T, size_t size, class DataContainer = FloatingPointVectorDataContainerBase<T, size> >
class FloatingPointVector : public DataContainer
{

public:

  typedef T ComponentType;

  enum { Size = size };

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

  //----------------------------------------------------------------------
  explicit FloatingPointVector(T value=T(0));

  FloatingPointVector<T, size, DataContainer>& operator=(T value);


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

  //----------------------------------------------------------------------
  bool operator==(const FloatingPointVector<T, size, DataContainer>& buffer) const;

  bool operator!=(const FloatingPointVector<T, size, DataContainer>& buffer) const;

  bool operator <(const FloatingPointVector<T, size, DataContainer>& buffer) const;


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

  //----------------------------------------------------------------------
  const T& operator[](const size_t i) const;

  T& operator[](const size_t i);


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

  //----------------------------------------------------------------------
  size_t getSize() const;

  T norm2() const;

  T norm2(const FloatingPointVector<T, size, DataContainer>& weight) const;

  T dot(const FloatingPointVector<T, size, DataContainer>& buffer) const;

  T normalize();

  T length() const;

  inline T distance(const FloatingPointVector<T, size, DataContainer>& buffer) const
  {
    return (*this - buffer).length();
  }

  inline T distanceSquared(const FloatingPointVector<T, size, DataContainer>& buffer) const
  {
    return (*this - buffer).lengthSquared();
  }



#ifdef ML_DEPRECATED




  inline ML_DEPRECATED T Normalize() { return normalize(); }

  inline ML_DEPRECATED T Length() const { return length(); }

  inline ML_DEPRECATED T Distance(const FloatingPointVector<T, size, DataContainer>& buffer) const
  {
    return distance(buffer);
  }
  inline ML_DEPRECATED T DistanceSquared(const FloatingPointVector<T, size, DataContainer>& buffer) const
  {
    return distanceSquared(buffer);
  }
  inline ML_DEPRECATED T Dot(const FloatingPointVector<T, size, DataContainer>& b) const
  {
    ML_TRACE_IN_TIME_CRITICAL("Dot(const FloatingPointVector<T, size, DataContainer>& b)");

    return dot(b);
  }
  inline ML_DEPRECATED T length2() const { return lengthSquared(); }
  inline ML_DEPRECATED T LengthSquared() const { return lengthSquared(); }

  inline ML_DEPRECATED FloatingPointVector<T, 3, DataContainer> Cross(const FloatingPointVector<T, 3, DataContainer>& b) const
  {
    ML_TRACE_IN_TIME_CRITICAL("Cross(const FloatingPointVector<T, 3, DataContainer>& b)");

    return cross(b);
  }
#endif // ML_DEPRECATED

  T lengthSquared() const;

  T compSum() const;

  T compMul() const;

  T compMaxAbs() const;

  void compMin(FloatingPointVector<T, size, DataContainer> buffer);

  void compMax(FloatingPointVector<T, size, DataContainer> buffer);

  void compAbs();

  void compDiv(const FloatingPointVector<T, size, DataContainer>& d);

  void compSqr();

  void compSqrt();

  void clampMin(const FloatingPointVector<T, size, DataContainer>& lower);

  void clampMax(const FloatingPointVector<T, size, DataContainer>& upper);

  void clamp(const FloatingPointVector<T, size, DataContainer>& lower,
             const FloatingPointVector<T, size, DataContainer>& upper);

  void compRound();

  void compFloor();

  void compCeil();

  inline FloatingPointVector<T, 3, DataContainer> cross(const FloatingPointVector<T, 3, DataContainer> &b) const
  {
    FloatingPointVector<T, 3, DataContainer> r;
    r[0] = this->_buffer[1]*b._buffer[2] - this->_buffer[2]*b._buffer[1];
    r[1] = this->_buffer[2]*b._buffer[0] - this->_buffer[0]*b._buffer[2];
    r[2] = this->_buffer[0]*b._buffer[1] - this->_buffer[1]*b._buffer[0];
    return r;
  }

  void apply(ML_LA_FROM_DOUBLE_TO_DOUBLE f);

  std::ostream& writeOut(std::ostream& os) const;

  std::istream& readIn(std::istream& is);

}; // end of class *FloatingPointVector*


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

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer>& operator+=(FloatingPointVector<T, size, DataContainer>& op1, const FloatingPointVector<T, size, DataContainer>& buffer)
{
  for (size_t i=0; i<size; ++i){ op1[i] += buffer[i]; }
  return op1;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer>& operator-=(FloatingPointVector<T, size, DataContainer>& op1, const FloatingPointVector<T, size, DataContainer>& buffer)
{
  for (size_t i=0; i<size; ++i){ op1[i] -= buffer[i]; }
  return op1;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
//template <class T, size_t size, class DataContainer>
//inline FloatingPointVector<T, size, DataContainer>& operator*=(FloatingPointVector<T, size, DataContainer>& op1, T value)
//{
//  for (size_t i=0; i<size; ++i){ op1[i] *= value; }
//  return op1;
//}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer>& operator*=(FloatingPointVector<T, size, DataContainer>& op1, MLdouble value)
{
  for (size_t i=0; i<size; ++i){ op1[i] *= static_cast<T>(value); }
  return op1;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer>& operator*=(FloatingPointVector<T, size, DataContainer>& op1, const FloatingPointVector<T, size, DataContainer>& op2)
{
  for (size_t i=0; i<size; ++i){ op1[i] *= op2[i]; }
  return op1;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer>& operator/=(FloatingPointVector<T, size, DataContainer>& op1, MLdouble value)
{
  // The desired optimization by multiplying by 1.0/value we cannot do since some
  // people simply use this class also for integer types although that's not really ok.
  // We don't want to force bad errors for those people; so we spend the time here...
  for (size_t i=0; i<size; ++i){ op1[i] /= static_cast<T>(value); }
  return op1;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer>& operator/=(FloatingPointVector<T, size, DataContainer>& op1, const FloatingPointVector<T, size, DataContainer>& op2)
{
  // The desired optimization by multiplying by 1.0/value we cannot do since some
  // people simply use this class also for integer types although that's not really ok.
  // We don't want to force bad errors for those people; so we spend the time here...
  for (size_t i=0; i<size; ++i){ op1[i] /= op2[i]; }
  return op1;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline bool operator!(const FloatingPointVector<T, size, DataContainer>& a)
{
  bool v = !a[0];
  for (size_t c=1; c<size; c++){ v &= !a[c]; }
  return v;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> operator+(      FloatingPointVector<T, size, DataContainer>  lhs,
                                                              const FloatingPointVector<T, size, DataContainer>& rhs)
{
  return lhs += rhs;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> operator-(      FloatingPointVector<T, size, DataContainer>  lhs,
                                                              const FloatingPointVector<T, size, DataContainer>& rhs)
{
  return lhs -= rhs;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> operator+(const FloatingPointVector<T, size, DataContainer>& buffer)
{
  return FloatingPointVector<T, size, DataContainer>(buffer);
}


//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> operator-(const FloatingPointVector<T, size, DataContainer>& buffer)
{
  FloatingPointVector<T, size, DataContainer> buf(buffer);
  for (size_t i=0; i<size; ++i){ buf[i] *= -1; }
  return buf;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T operator*(const FloatingPointVector<T, size, DataContainer>& a, const FloatingPointVector<T, size, DataContainer>& b)
{
  return a.dot(b);
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> operator*(FloatingPointVector<T, size, DataContainer> lhs, MLdouble rhs)
{
  return lhs *= static_cast<T>(rhs);
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> operator*(MLdouble lhs, FloatingPointVector<T, size, DataContainer> rhs)
{
  return rhs *= static_cast<T>(lhs);
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> operator/(FloatingPointVector<T, size, DataContainer> lhs, MLdouble rhs)
{
  return lhs /= static_cast<T>(rhs);
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compMin(      FloatingPointVector<T, size, DataContainer>  buffer1,
                                                            const FloatingPointVector<T, size, DataContainer>& buffer2)
{
  buffer1.compMin(buffer2);
  return buffer1;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compMax(      FloatingPointVector<T, size, DataContainer>  buffer1,
                                                            const FloatingPointVector<T, size, DataContainer>& buffer2)
{
  buffer1.compMax(buffer2);
  return buffer1;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compAbs(FloatingPointVector<T, size, DataContainer> a)
{
  a.compAbs();
  return a;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compSqr(FloatingPointVector<T, size, DataContainer> a)
{
  a.compSqr();
  return a;
}


//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compSqrt(FloatingPointVector<T, size, DataContainer> a)
{
  a.compSqrt();
  return a;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compDiv(      FloatingPointVector<T, size, DataContainer>  a,
                                                            const FloatingPointVector<T, size, DataContainer> &d)
{
  a.compDiv(d);
  return a;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> clampMin(      FloatingPointVector<T, size, DataContainer>  a,
                                                             const FloatingPointVector<T, size, DataContainer> &m)
{
  a.clampMin(m);
  return a;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> clampMax(      FloatingPointVector<T, size, DataContainer>  a,
                                                             const FloatingPointVector<T, size, DataContainer> &m)
{
  a.clampMax(m);
  return a;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> clamp(FloatingPointVector<T, size, DataContainer> a,
                                                          const FloatingPointVector<T, size, DataContainer> &lower,
                                                          const FloatingPointVector<T, size, DataContainer> &upper)
{
  a.clampMax(upper);
  a.clampMin(lower);
  return a;
}

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T compMul(const FloatingPointVector<T, size, DataContainer> &a)
{
  return a.compMul();
}

ML_LA_END_NAMESPACE

//-----------------------------------------------------------------------------------
// Some IO stream operators are implemented in this namespace by this library.
//-----------------------------------------------------------------------------------
namespace std {

  //-----------------------------------------------------------------------------------
  //-----------------------------------------------------------------------------------
  template <class T, size_t size, class DataContainer>
  inline ostream& operator<<(ostream& os, const ML_LA_NAMESPACE::FloatingPointVector<T, size, DataContainer>& v)
  {
    return v.writeOut(os);
  }

  //-----------------------------------------------------------------------------------
  //-----------------------------------------------------------------------------------
  template <class T, size_t size, class DataContainer>
  inline istream& operator>>(istream& is, ML_LA_NAMESPACE::FloatingPointVector<T, size, DataContainer>& v)
  {
    return v.readIn(is);
  }

}

ML_LA_START_NAMESPACE

//-----------------------------------------------------------------------------------
//
//                              IMPLEMENTATION.
//
//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------------
//                     Constructors and assignment operators.
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
// Default and value constructor. Default is the initialization of all
// components with value whose default is 0.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer>::FloatingPointVector(T value)
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] = value; }
}

//-----------------------------------------------------------------------------------
// Assignment of scalar value to all components.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer>& FloatingPointVector<T, size, DataContainer>::operator=(T value)
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] = value; }
  return *this;
}


//----------------------------------------------------------------------
//                           Comparison.
//----------------------------------------------------------------------
//-----------------------------------------------------------------------------------
// Returns true if *this and buffer are component wise equal, otherwise false.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline bool FloatingPointVector<T, size, DataContainer>::operator==(const FloatingPointVector<T, size, DataContainer>& buffer) const
{
  for (size_t i=0; i<size; ++i){
    // Use the numerically better method (although slower to compare) floats to ensure that
    // insignificant differences after least significant mantissa bit are not considered as
    // difference.
    if (MLValuesDifferWOM(this->_buffer[i], buffer._buffer[i])){ return false; }
  }
  return true;
}

//-----------------------------------------------------------------------------------
// Returns true if any components of *this and buffer are not equal, otherwise false.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline bool FloatingPointVector<T, size, DataContainer>::operator!=(const FloatingPointVector<T, size, DataContainer>& buffer) const
{
  for (size_t i=0; i<size; ++i){
    // Use the numerically better method (although slower to compare) floats to ensure that
    // insignificant differences after least significant mantissa bit are not considered as
    // difference.
    if (MLValuesDifferWOM(this->_buffer[i], buffer._buffer[i])){ return true; }
  }
  return false;
}

//-----------------------------------------------------------------------------------
// Defines an artificial order for use in sort algorithms (lexicographical
// order). Starting from the first component(i.e. index 0) all components
// from *this are compared with the corresponding one in buffer:
// If the components of *this is smaller than the corresponding on in
// buffer then true is returned, if the comparison is bigger then
// false is returned and on equality the components for the next index are
// compared. If all components are equal then false is returned.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline bool FloatingPointVector<T, size, DataContainer>::operator<(const FloatingPointVector<T, size, DataContainer>& buffer) const
{
  for (size_t i=0; i<size; ++i) {
    if (MLValuesDifferWOM(this->_buffer[i], buffer._buffer[i])){ return (this->_buffer[i]<buffer._buffer[i]); }
  }
  return false;
}





//-----------------------------------------------------------------------------------
//                   Value access and indexing operators.
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
// Constant indexing operators. The caller must guarantee that is in [0, size-1].
// It is legal to consider all elements as a subsequent array in memory for
// pointer addressing of all elements.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline const T& FloatingPointVector<T, size, DataContainer>::operator[](const size_t i) const
{
  return this->_buffer[i];
}

//-----------------------------------------------------------------------------------
// Indexing operator. The caller must guarantee that is in [0, size-1].
// It is legal to consider all elements as a subsequent array in memory for
// pointer addressing of all elements.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T& FloatingPointVector<T, size, DataContainer>::operator[](const size_t i)
{
  return this->_buffer[i];
}








//----------------------------------------------------------------------
//                     Other operations.
//----------------------------------------------------------------------
//-----------------------------------------------------------------------------------
// Return number of elements of value buffer.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline size_t FloatingPointVector<T, size, DataContainer>::getSize() const
{
  return size;
}

//-----------------------------------------------------------------------------------
// Return euclidean norm (the vector length), i.e. square root of sum
// of squares of all components.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::norm2() const
{
  T norm = 0;
  for (size_t i=0; i<size; ++i){ norm += this->_buffer[i]*this->_buffer[i]; }
#ifdef WIN32
  return static_cast<T>(sqrt(norm));
#else
  return static_cast<T>(::sqrt(norm));
#endif
}

//-----------------------------------------------------------------------------------
// Return weighted euclidean norm, i.e. square root of sum of squares of all
// components multiplied with corresponding squared component of weight.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::norm2(const FloatingPointVector<T, size, DataContainer>& weight) const
{
  T norm = 0;
  for (size_t i=0; i<size; ++i){
    norm += this->_buffer[i]*this->_buffer[i] * weight._buffer[i]*weight._buffer[i];
  }
#ifdef WIN32
  return sqrt(norm);
#else
  return ::sqrt(norm);
#endif
}


//-----------------------------------------------------------------------------------
// Return dot product, i.e. sum of all components multiplied with corresponding
// components of buffer.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::dot(const FloatingPointVector<T, size, DataContainer>& buffer) const
{
  T sum = 0;
  for (size_t i=0; i<size; ++i){ sum += this->_buffer[i]*buffer._buffer[i]; }
  return sum;
}

//-----------------------------------------------------------------------------------
// Normalizes buffer and returns euclidean length of vector before normalization,
// i.e.norm2. On zero vector length the vector is left unchanged.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::normalize()
{
  T norm = norm2();

  if (!MLValueIs0WOM(norm)) {
    T inv_norm = static_cast<T>(1.0/norm);
    for (size_t i=0; i<size; ++i){ this->_buffer[i] *= inv_norm; }
  }

  return norm;
}

//-----------------------------------------------------------------------------------
// Return the length of the vector, i.e. norm2().
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::length() const
{
  return norm2();
}

//-----------------------------------------------------------------------------------
// Returns squared length of vector.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::lengthSquared() const
{
  return dot(*this);
}

//-----------------------------------------------------------------------------------
// Return sum of all components.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::compSum() const
{
  T retVal=this->_buffer[0];
  for (size_t i=1; i<size; ++i){ retVal += this->_buffer[i]; }
  return retVal;
}

//-----------------------------------------------------------------------------------
// Return product of all vector components.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::compMul() const
{
  T retVal=this->_buffer[0];
  for (size_t i=1; i<size; ++i){ retVal *= this->_buffer[i]; }
  return retVal;
}

//-----------------------------------------------------------------------------------
// Return maximum of absolute component values.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::compMaxAbs() const
{
  size_t i = 0;
  T m = static_cast<T>(  MLAbs(this->_buffer[i++]));
  T n = 0;
  for (; i<size; ++i){ m = (n = static_cast<T>(  MLAbs(this->_buffer[i]))  ) > m ? n : m; }
  return m;
}

//-----------------------------------------------------------------------------------
// Sets the component wise minimum of *this and buffer in *this.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compMin(FloatingPointVector<T, size, DataContainer> buffer)
{
  for (size_t i=0; i<size; ++i){
    this->_buffer[i] = this->_buffer[i] < buffer._buffer[i] ? this->_buffer[i] : buffer._buffer[i];
  }
}

//-----------------------------------------------------------------------------------
// Sets the component wise maximum of *this and buffer in *this.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compMax(FloatingPointVector<T, size, DataContainer> buffer)
{
  for (size_t i=0; i<size; ++i){
    this->_buffer[i] = this->_buffer[i] < buffer._buffer[i] ? buffer._buffer[i] :this->_buffer[i];
  }
}

//-----------------------------------------------------------------------------------
// Kill negative signs from all components.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compAbs()
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] = static_cast<T>(  MLAbs(this->_buffer[i])); }
}

//-----------------------------------------------------------------------------------
// Divide each vector component by the corresponding one of d.
// Divisions by zero are not handled; the caller must avoid them.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compDiv(const FloatingPointVector<T, size, DataContainer>& d)
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] /= d._buffer[i]; }
}

//-----------------------------------------------------------------------------------
// Calculate and set the square of all components.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compSqr()
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] *= this->_buffer[i]; }
}

//-----------------------------------------------------------------------------------
// Calculate and set square root of all components.
// Negative values have to be avoided by caller.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compSqrt()
{
  for (size_t i=0; i<size; ++i){
#ifdef WIN32
    this->_buffer[i] = static_cast<T>(  sqrt(this->_buffer[i]));
#else
    this->_buffer[i] = static_cast<T>(::sqrt(this->_buffer[i]));
#endif
  }
}

//-----------------------------------------------------------------------------------
// Calculate and set all components clamped to lower, i.e. if any component is
// smaller than the corresponding one in lower then it is set to the one from lower.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::clampMin(const FloatingPointVector<T, size, DataContainer>& lower)
{
  compMax(lower);
}

//-----------------------------------------------------------------------------------
// Calculate and set all components clamped to upper, i.e. if any component is
// greater than the corresponding one in upper then it is set to the one from upper.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::clampMax(const FloatingPointVector<T, size, DataContainer>& upper)
{
  compMin(upper);
}

//-----------------------------------------------------------------------------------
// Calculate and set all components of *this so that they are between minimum
// min and maximum max. This is done by applying clampMin(lower) first
// and then clampMax(upper). Note that components can become smaller than
// lower if a component in upper is smaller than their corresponding one in
// in lower.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::clamp(const FloatingPointVector<T, size, DataContainer>& lower,
                                                                const FloatingPointVector<T, size, DataContainer>& upper)
{
  // Make copy to avoid self modification if lower or upper is equal to *this.
  FloatingPointVector<T, size, DataContainer> buf(*this);
  buf.clampMin(lower);
  buf.clampMax(upper);
  *this = buf;
}

//-----------------------------------------------------------------------------------
// Round all components of this vector using floor(component + 0.5).
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compRound()
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] = floor(this->_buffer[i] + 0.5); }
}

//-----------------------------------------------------------------------------------
// Round all components of this vector using floor(component).
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compFloor()
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] = floor(this->_buffer[i]); }
}

//-----------------------------------------------------------------------------------
// Round all components of this vector to integer using ceil(component).
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::compCeil()
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] = ceil(this->_buffer[i]); }
}

//-----------------------------------------------------------------------------------
// Apply function f to each component starting form index 0 to index size-1.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::apply(ML_LA_FROM_DOUBLE_TO_DOUBLE f)
{
  for (size_t i=0; i<size; ++i){ this->_buffer[i] = f(this->_buffer[i]); }
}

//-----------------------------------------------------------------------------------
// Write all components to ostream os starting from index 0 to size-1.
// Each buffer elements is followed separated by a space symbols " ".
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline std::ostream& FloatingPointVector<T, size, DataContainer>::writeOut(std::ostream& os) const
{
  for (size_t i=0; i<size; ++i){ os << this->_buffer[i] << " "; }
  return os;
}

//-----------------------------------------------------------------------------------
// Read all components from istream is starting starting from index 0 to size-1.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline std::istream& FloatingPointVector<T, size, DataContainer>::readIn(std::istream& is)
{
  for (size_t i=0; i<size; ++i){ is >> this->_buffer[i]; }
  return is;
}

#ifdef ML_DEPRECATED




#define ScalarVectorTemplate FloatingPointVector

#if defined(WIN32) && defined(ML_WARN_DEPRECATED)
#pragma deprecated("ScalarVectorTemplate")
#endif

#endif // ML_DEPRECATED

ML_LA_END_NAMESPACE


#endif // __mlFloatingPointVector_H