vector4.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: vector4.h,v 1.53 2004/07/05 20:57:29 oliver Exp $
//

#ifndef BALL_MATHS_VECTOR4_H
#define BALL_MATHS_VECTOR4_H

#ifndef BALL_COMMON_EXCEPTION_H
# include <BALL/COMMON/exception.h>
#endif

#ifndef BALL_MATHS_ANGLE_H
# include <BALL/MATHS/angle.h>
#endif

#ifdef BALL_HAS_IEEEFP_H
# include <ieeefp.h>
#endif 

namespace BALL 
{

  template <typename T>
  class TVector4;
  

  template <typename T>
  BALL_INLINE
  TVector4<T> operator + (const TVector4<T>& a, const TVector4<T>& b);

  template <typename T>
  BALL_INLINE
  TVector4<T> operator - (const TVector4<T>& a, const TVector4<T>& b);
  
  template <typename T>
  std::istream& operator >> (std::istream& s, TVector4<T>& vector);

  template <typename T>
  std::ostream& operator << (std::ostream& s, const TVector4<T>& vector);
    
  template <typename T>
  class TVector4
  {
    public:

    BALL_CREATE(TVector4<T>)

    

    TVector4();

    TVector4(const T* ptr)
    throw(Exception::NullPointer);

      explicit TVector4(const T& value);

    TVector4(const T& x, const T& y, const T& z, const T& h = (T)1);

    TVector4(const TVector4& vector);

    virtual ~TVector4();

    virtual void clear()
    {
      x = y = z = h = (T)0;
    }


  
    void set(const T* ptr)
      throw(Exception::NullPointer);

    void set(const T& rx, const T& ry, const T& rz, const T& rh = (T)1);

    void set(const TVector4& vector);

    TVector4& operator = (const T* ptr)
    throw(Exception::NullPointer);

    TVector4& operator = (const TVector4& vector);

    TVector4& operator = (T value);

    void get(T* ptr) const
      throw(Exception::NullPointer);

    void get(T& rx, T& ry, T& rz, T& rh) const;

    void get(TVector4& vector) const;

    void swap(TVector4& vector);



    T getLength() const;

    T getSquareLength() const;

    TVector4& normalize()
      throw(Exception::DivisionByZero);

    static const TVector4& getZero();

    static const TVector4& getUnit();

    void set(const T& value = (T)1);

    T& operator [] (Position position)
      throw(Exception::IndexOverflow);

    const T& operator [] (Position position) const
      throw(Exception::IndexOverflow);



    TVector4 operator + () const;

    TVector4 operator - () const;

    TVector4& operator += (const TVector4& vector);

    TVector4& operator -= (const TVector4& vector);

    TVector4 operator * (const T& scalar);

    TVector4& operator *= (const T& scalar);

    TVector4 operator / (const T& scalar)
      throw(Exception::DivisionByZero);

    TVector4& operator /= (const T& scalar)
      throw(Exception::DivisionByZero);

    T operator * (const TVector4& vector) const;

    T getDistance(const TVector4& vector) const;

    T getSquareDistance(const TVector4& vector) const
      ;


      
    bool operator == (const TVector4& vector) const
      ;

    bool operator != (const TVector4& vector) const
      ;

    bool isOrthogonalTo(const TVector4& vector) const
      ;



    bool isValid() const
      ;

    void dump(std::ostream& s = std::cout, Size depth = 0) const
      ;



    T x;

    T y;

    T z;

    T h;

  };
  
  template <typename T>
  TVector4<T>::TVector4()
    
    : x(0),
      y(0),
      z(0),
      h(0)
  {
  }

  template <typename T>
  TVector4<T>::TVector4(const T* ptr)
    throw(Exception::NullPointer)
  {
    if (ptr == 0)
    {
      throw Exception::NullPointer(__FILE__, __LINE__);
    }
    
    x = *ptr++;
    y = *ptr++;
    z = *ptr++;
    h = *ptr;
  }


  template <typename T>
  TVector4<T>::TVector4(const T& value)
    
    : x(value),
      y(value),
      z(value),
      h(value)
  {
  }                                                                                                                                                                                

  template <typename T>
  TVector4<T>::TVector4(const T& x, const T& y, const T& z, const T& h)
    
    : x(x),
      y(y),
      z(z),
      h(h)
  {
  }

  template <typename T>
  TVector4<T>::TVector4(const TVector4<T>& v)
    
    : x(v.x),
      y(v.y),
      z(v.z),
      h(v.h)
  {
  }

  template <typename T>
  TVector4<T>::~TVector4()
    
  {
  }

  template <typename T>
  BALL_INLINE 
  void TVector4<T>::set(const T* ptr)
    throw(Exception::NullPointer)
  {
    if (ptr == 0)
    {
      throw Exception::NullPointer(__FILE__, __LINE__);
    }
    x = *ptr++;
    y = *ptr++;
    z = *ptr++;
    h = *ptr;
  }

  template <typename T>
  BALL_INLINE 
  void TVector4<T>::set(const T& rx, const T& ry, const T& rz, const T& rh)
    
  {
    x = rx;
    y = ry;
    z = rz;
    h = rh;
  }

  template <typename T>
  BALL_INLINE 
  void TVector4<T>::set(const TVector4<T>& v)
    
  {
    x = v.x;
    y = v.y;
    z = v.z;
    h = v.h;
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T>& TVector4<T>::operator = (const T* ptr)
    throw(Exception::NullPointer)
  {
    if (ptr == 0)
    {
      throw Exception::NullPointer(__FILE__, __LINE__);
    }
    x = *ptr++;
    y = *ptr++;
    z = *ptr++;
    h = *ptr;

    return *this;
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T>& TVector4<T>::operator = (const TVector4<T>& v)
    
  {
    x = v.x;
    y = v.y;
    z = v.z;
    h = v.h;

    return *this;
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T>& TVector4<T>::operator = (T value)
    
  {
    x = value;
    y = value;
    z = value;
    h = value;

    return *this;
  }

  template <typename T>
  BALL_INLINE 
  void TVector4<T>::get(T* ptr) const
    throw(Exception::NullPointer)
  {
    if (ptr == 0)
    {
      throw Exception::NullPointer(__FILE__, __LINE__);
    }
    *ptr++ = x;
    *ptr++ = y;
    *ptr++ = z;
    *ptr   = h;
  }

  template <typename T>
  BALL_INLINE 
  void TVector4<T>::get(T& rx, T& ry, T& rz, T& rh) const
    
  {
    rx = x;
    ry = y;
    rz = z;
    rh = h;
  }

  template <typename T>
  BALL_INLINE 
  void TVector4<T>::get(TVector4<T>& v) const
    
  {
    v.x = x;
    v.y = y;
    v.z = z;
    v.h = h;
  }

  template <typename T>
  void TVector4<T>::swap(TVector4<T>& v)
    
  {
    T temp = x;
    x = v.x;
    v.x = temp;

    temp = y;
    y = v.y;
    v.y = temp;

    temp = z;
    z = v.z;
    v.z = temp;

    temp = h;
    h = v.h;
    v.h = temp;
  }

  template <typename T>
  BALL_INLINE 
  T TVector4<T>::getLength() const
    
  {
    return (T)sqrt(x * x + y * y + z * z + h * h);
  }

  template <typename T>
  BALL_INLINE 
  T TVector4<T>::getSquareLength() const
    
  {
    return (T)(x * x + y * y + z * z + h * h);
  }

  template <typename T>

  BALL_INLINE
  TVector4<T>& TVector4<T>::normalize()
    throw(Exception::DivisionByZero)
  {
    T len = (T)sqrt(x * x + y * y + z * z + h * h);

    if (Maths::isZero(len))
    {
      throw Exception::DivisionByZero(__FILE__, __LINE__);    
    }
    
    x /= len;
    y /= len;
    z /= len;
    h /= len;

    return *this;
  }

  template <typename T>
  BALL_INLINE 
  const TVector4<T>& TVector4<T>::getZero()
    
  {
    static const TVector4<T> null4(0, 0, 0, 0);
    return null4;
  }

  template <typename T>
  BALL_INLINE 
  const TVector4<T>& TVector4<T>::getUnit()
    
  {
    static const TVector4<T> unit_vector(1, 1, 1, 1);
    return unit_vector;
  }

  template <typename T>
  BALL_INLINE 
  void TVector4<T>::set(const T& value)
    
  {
    x = y = z = h = value;
  }

  template <typename T>
  BALL_INLINE 
  T& TVector4<T>::operator [] (Position pos)
    throw(Exception::IndexOverflow)
  {
    if (pos > 3)
    {
      throw Exception::IndexOverflow(__FILE__, __LINE__);
    }
    switch (pos) 
    {
      case 0: return x;
      case 1: return y;
      case 2: return z;
      case 3:
      default:
        return h;
    }
  }

  template <typename T>
  BALL_INLINE 
  const T& TVector4<T>::operator [] (Position pos) const
    throw(Exception::IndexOverflow)
  {
    if (pos > 3)
    {
      throw Exception::IndexOverflow(__FILE__, __LINE__);
    }
    switch (pos) 
    {
      case 0: return x;
      case 1: return y;
      case 2: return z;
      case 3:
      default:
        return h;
    }
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T> TVector4<T>::operator + () const
    
  {
    return *this;
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T> TVector4<T>::operator - () const
    
  {
    return TVector4<T>(-x, -y, -z, -h);
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T>& TVector4<T>::operator += (const TVector4<T>& v)
    
  {
    x += v.x;
    y += v.y;
    z += v.z;
    h += v.h;

    return *this;
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T>& TVector4<T>::operator -= (const TVector4<T> &v)
    
  {
    x -= v.x;
    y -= v.y;
    z -= v.z;
    h -= v.h;

    return *this;
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T> TVector4<T>::operator * (const T& scalar)
    
  {
    return TVector4<T>(x * scalar, y * scalar, z * scalar, h * scalar);
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T>& TVector4<T>::operator *= (const T &scalar)
    
  {
    x *= scalar;
    y *= scalar;
    z *= scalar;
    h *= scalar;

    return *this;
  }

  template <typename T>
  TVector4<T>TVector4<T>::operator / (const T &scalar)
    throw(Exception::DivisionByZero)
  {
    if (Maths::isZero(scalar))
    {
      throw Exception::DivisionByZero(__FILE__, __LINE__);
    }
    return TVector4<T>(x / scalar, y / scalar, z / scalar, h / scalar); 
  }

  template <typename T>
  TVector4<T>& TVector4<T>::operator /= (const T& scalar)
    throw(Exception::DivisionByZero)
  {
    if (Maths::isZero(scalar))
    {
      throw Exception::DivisionByZero(__FILE__, __LINE__);
    }
    x /= scalar;
    y /= scalar;
    z /= scalar;
    h /= scalar;

    return *this;
  }

  template <typename T>
  BALL_INLINE 
  T TVector4<T>::operator * (const TVector4<T>& v) const
    
  {
    return (x * v.x + y * v.y + z * v.z + h * v.h);
  }

  template <typename T>
  BALL_INLINE 
  T TVector4<T>::getDistance(const TVector4<T> &v) const
    
  {
    T da = x - v.x;
    T db = y - v.y;
    T dc = z - v.z;
    T dd = h - v.h;
    
    return (T)sqrt(da * da + db * db + dc * dc + dd * dd); 
  }

  template <typename T>
  BALL_INLINE 
  T TVector4<T>::getSquareDistance(const TVector4<T> &v) const
    
  {
    T da = x - v.x;
    T db = y - v.y;
    T dc = z - v.z;
    T dd = h - v.h;
    
    return (da * da + db * db + dc * dc + dd * dd); 
  }

  template <typename T>
  BALL_INLINE 
  bool TVector4<T>::operator == (const TVector4<T>& v) const
    
  {
    return (Maths::isEqual(x, v.x) && Maths::isEqual(y, v.y) 
                  && Maths::isEqual(z, v.z) && Maths::isEqual(h, v.h));
  }

  template <typename T>
  BALL_INLINE 
  bool TVector4<T>::operator != (const TVector4<T>& v) const
    
  {
    return (Maths::isNotEqual(x, v.x) || Maths::isNotEqual(y, v.y)
                  || Maths::isNotEqual(z, v.z) || Maths::isNotEqual(h, v.h));
  }

  template <typename T>
  BALL_INLINE 
  bool TVector4<T>::isOrthogonalTo(const TVector4<T>& v) const
    
  {
    return Maths::isZero(*this * v);
  }

  template <typename T>
  BALL_INLINE 
  bool TVector4<T>::isValid() const
    
  {
    return true;
  }

  template <typename T>
  void TVector4<T>::dump(std::ostream& s, Size depth) const
    
  {
    BALL_DUMP_STREAM_PREFIX(s);

    BALL_DUMP_HEADER(s, this, this);

    BALL_DUMP_DEPTH(s, depth);
    s << "x= " << x 
      << ", y = " << y
      << ", z = " << z
      << ", h = " << h << std::endl;

    BALL_DUMP_STREAM_SUFFIX(s);
  }

  typedef TVector4<float> Vector4;

  template <typename T>
  BALL_INLINE 
  TVector4<T> operator + (const TVector4<T>& a, const TVector4<T>& b)
    
  {
    return TVector4<T>(a.x + b.x, a.y + b.y, a.z + b.z, a.h + b.h);
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T> operator - (const TVector4<T>& a, const TVector4<T>& b)
    
  {
    return TVector4<T>(a.x - b.x, a.y - b.y, a.z - b.z, a.h - b.h);
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T> operator * (const T& scalar, const TVector4<T>& v)
    
  {
    return TVector4<T>(scalar * v.x, scalar * v.y, scalar * v.z, scalar * v.h);
  }

  template <typename T>
  BALL_INLINE 
  TVector4<T> operator * (const TVector4<T>& v, const T& scalar)
    
  {
    return TVector4<T>(scalar * v.x, scalar * v.y, scalar * v.z, scalar * v.h);
  }


  template <typename T>
  std::istream& operator >> (std::istream& s, TVector4<T>& v)
    
  {
    char c;
    s >> c >> v.x >> v.y >> v.z >> v.h >>c;  
    return s;
  }

  template <typename T>
  std::ostream& operator << (std::ostream& s, const TVector4<T>& v)
    
  {
    s << '(' <<v.x << ' ' << v.y << ' ' << v.z << ' ' << v.h << ')';
    
    return s;
  }
} // namespace BALL

#endif // BALL_MATHS_VECTOR4_H