mlFloatingPointVector.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_FLOATING_POINT_VECTOR_H
#define ML_FLOATING_POINT_VECTOR_H

 
//------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "mlLinearAlgebraSystem.h"
 
#include <mlTypeDefs.h>
#include <mlTypeDefTraits.h>
#include <iostream>
 
//------------------------------------------------------------------------
//------------------------------------------------------------------------
typedef double (*ML_LA_FROM_DOUBLE_TO_DOUBLE)(double);
 
//------------------------------------------------------------------------
// Put all code 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();
  }

  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, 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 do not 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 do not 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> vec)
{
  vec.compAbs();
  return vec;
}
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compSqr(FloatingPointVector<T, size, DataContainer> vec)
{
  vec.compSqr();
  return vec;
}
 
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compSqrt(FloatingPointVector<T, size, DataContainer> vec)
{
  vec.compSqrt();
  return vec;
}
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> compDiv(      FloatingPointVector<T, size, DataContainer>  vec,
                                                            const FloatingPointVector<T, size, DataContainer> &d)
{
  vec.compDiv(d);
  return vec;
}
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> clampMin(      FloatingPointVector<T, size, DataContainer>  vec,
                                                             const FloatingPointVector<T, size, DataContainer> &m)
{
  vec.clampMin(m);
  return vec;
}
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> clampMax(      FloatingPointVector<T, size, DataContainer>  vec,
                                                             const FloatingPointVector<T, size, DataContainer> &m)
{
  vec.clampMax(m);
  return vec;
}
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline FloatingPointVector<T, size, DataContainer> clamp(FloatingPointVector<T, size, DataContainer> vec,
                                                          const FloatingPointVector<T, size, DataContainer> &lower,
                                                          const FloatingPointVector<T, size, DataContainer> &upper)
{
  vec.clampMax(upper);
  vec.clampMin(lower);
  return vec;
}
 
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T compMul(const FloatingPointVector<T, size, DataContainer> &vec)
{
  return vec.compMul();
}

 
ML_LA_END_NAMESPACE
 
//-----------------------------------------------------------------------------------
// Some I/O 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 a \p 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 whether *this and buffer are component-wise equal.
//-----------------------------------------------------------------------------------
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 whether any components of *this and \p buffer are not equal.
//-----------------------------------------------------------------------------------
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 are smaller than the corresponding on in
// buffer, then \c true is returned. If the comparison is greater, then
// \c false is returned. On equality, the components for the next index are
// compared. If all components are equal, then \c 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.
//----------------------------------------------------------------------
//-----------------------------------------------------------------------------------
// Returns the 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;
}
 
//-----------------------------------------------------------------------------------
// Returns the 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
}
 
//-----------------------------------------------------------------------------------
// Returns the 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
}
 
 
//-----------------------------------------------------------------------------------
// Returns the 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 the 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;
}
 
//-----------------------------------------------------------------------------------
// Returns 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 the squared length of vector.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline T FloatingPointVector<T, size, DataContainer>::lengthSquared() const
{
  return dot(*this);
}
 
//-----------------------------------------------------------------------------------
// Returns the 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;
}
 
//-----------------------------------------------------------------------------------
// Returns the 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;
}
 
//-----------------------------------------------------------------------------------
// Returns the 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 \p 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 \p 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];
  }
}
 
//-----------------------------------------------------------------------------------
// Removes 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])); }
}
 
//-----------------------------------------------------------------------------------
// Divides each vector component by the corresponding one of \p 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]; }
}
 
//-----------------------------------------------------------------------------------
// Calculates and sets 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]; }
}
 
//-----------------------------------------------------------------------------------
// Calculates and sets the 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
  }
}
 
//-----------------------------------------------------------------------------------
// Calculates and sets all components clamped to \p lower, i.e., if any component is
// smaller than the corresponding one in \p lower, then it is set to the one from \p lower.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::clampMin(const FloatingPointVector<T, size, DataContainer>& lower)
{
  compMax(lower);
}
 
//-----------------------------------------------------------------------------------
// Calculates and sets all components clamped to \p upper, i.e., if any component is
// greater than the corresponding one in \p upper, then it is set to the one from \p upper.
//-----------------------------------------------------------------------------------
template <class T, size_t size, class DataContainer>
inline void FloatingPointVector<T, size, DataContainer>::clampMax(const FloatingPointVector<T, size, DataContainer>& upper)
{
  compMin(upper);
}
 
//-----------------------------------------------------------------------------------
// Calculates and sets all components of *this so that they are between minimum
// \p lower and maximum \p upper. This is done by applying clampMin(lower) first
// and then clampMax(upper). Note that components can become smaller than
// \p lower if a component in \p upper is smaller than their corresponding one in
// in \p 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;
}
 
//-----------------------------------------------------------------------------------
// Rounds 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] = std::floor(this->_buffer[i] + static_cast<T>(0.5)); }
}
 
//-----------------------------------------------------------------------------------
// Rounds 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] = std::floor(this->_buffer[i]); }
}
 
//-----------------------------------------------------------------------------------
// Rounds 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] = std::ceil(this->_buffer[i]); }
}
 
//-----------------------------------------------------------------------------------
// Applies function \p f to each component starting from 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]); }
}
 
//-----------------------------------------------------------------------------------
// Writes all components to ostream \p 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;
}
 
//-----------------------------------------------------------------------------------
// Reads all components from istream \p 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;
}
 
ML_LA_END_NAMESPACE
 
 
#endif