base/Vector4

Go to the documentation of this file.

/****************************************************************************
  Copyright (C)1996 David Jung <opensim@pobox.com>

  This program/file is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details. (http://www.gnu.org)
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
  $Id: Vector4 1029 2004-02-11 20:45:54Z jungd $
  $Revision: 1.3 $
  $Date: 2004-02-11 15:45:54 -0500 (Wed, 11 Feb 2004) $
  $Author: jungd $
 
****************************************************************************/

#ifndef _BASE_VECTOR4_
#define _BASE_VECTOR4_

#include <iostream>

#include <base/base>

#include <base/Vector3>


namespace base {


class Vector4 
{

public:
  Vector4() { x=y=z=w=Real(0); }
  Vector4(Real xc, Real yc, Real zc, Real wc=Real(1)) { x=xc; y=yc; z=zc; w=wc; }
  Vector4(const Vector3& v, Real w=Real(1)) { x=v.x; y=v.y; z=v.z; this->w=w; }
  Vector4(const Vector4& v) { this->operator=(v); }
  ~Vector4() {}
  
  enum Coords { X=1, Y=2, Z=3, W=4, Coords3D=5 };

  void setZero() throw()
  { x=y=z=w=Real(0); }

  Real& e(Int i) throw()
  { return (i==1)?x:(i==2)?y:(i==3)?z:w; }

  const Real& e(Int i) const throw()
  { return (i==1)?x:(i==2)?y:(i==3)?z:w; }

  Real& operator[](Int i) throw()
  { return (i==1)?x:(i==2)?y:(i==3)?z:w; }

  const Real& operator[](Int i) const throw()
  { return (i==1)?x:(i==2)?y:(i==3)?z:w; }

  Real& at(Int i) throw(std::out_of_range)
  {
    if ((i < 1) || (i > 4))
      throw std::out_of_range(Exception("vector index out of bounds"));

    return (i==1)?x:(i==2)?y:(i==3)?z:w;
  }

  const Real& at(Int i) const throw(std::out_of_range) 
  {
    if ((i < 1) || (i > 4))
      throw std::out_of_range(Exception("vector index out of bounds"));

    return (i==1)?x:(i==2)?y:(i==3)?z:w;
  }


  Vector4& operator=(const Vector4& src) throw()
  { 
    if (&src != this) {
      x=src.x; y=src.y; z=src.z; w=src.w;
    }
    return *this;
  }


  bool operator==(const Vector4& v) const throw()
  {
    if (&v == this) return true;

    return ((x==v.x)&&(y==v.y)&&(z==v.z)&&(w==v.w));
  }


  bool equals(const Vector4& v) const throw()
  {
    if (&v == this) return true;

    return (base::equals(x,v.x) && base::equals(y,v.y) && base::equals(z,v.z) && base::equals(w,v.w));
  }


  Real norm() const throw()
  { return (x*x+y*y+z*z+w*w); }

  Real magnitude() const throw()
  { return sqrt(norm()); }

  Real length() const throw()
  { return magnitude(); }


  Vector4& negate() throw()
  { x=-x; y=-y; z=-z; w=-w; return *this; }

  Vector4& operator+=(const Vector4& v2) throw()
  { x+=v2.x; y+=v2.y; z+=v2.z; w+=v2.w; return *this; }

  Vector4& operator-=(const Vector4& v2) throw()
  { x-=v2.x; y-=v2.y; z-=v2.z; w-=v2.w; return *this; }

  Vector4& operator*=(const Real& s) throw()
  { x*=s; y*=s; z*=s; w*=s; return *this; }

  Vector4& operator/=(const Real& s)
  { x/=s; y/=s; z/=s; w/=s; return *this; }

  Real* c_array() { return &x; }

  // this is too dangerous
  //operator Vector3() const;  ///< convert to 3D subvector
  Vector3 toVector3() const { return Vector3(x,y,z); }

  Real x,y,z,w;

};


// Operations

inline Vector4 operator+(const Vector4& v1, const Vector4& v2) throw() // Addition
{ Vector4 r(v1); return r+=v2; }

inline Vector4 operator-(const Vector4& v1, const Vector4& v2) throw() // Subtraction
{ Vector4 r(v1); return r-=v2; }

inline Vector4 operator-(const Vector4& v1) throw() // Negation
{ Vector4 r(v1); return r.negate(); }

inline Vector4 operator*(const Vector4& v1, const Real& s) throw() // Scalar multiplication
{ Vector4 r(v1); return r*=s; }

inline Vector4 operator*(const Real& s, const Vector4& v1) throw() // Scalar multiplication
{ Vector4 r(v1); return r*=s; }

inline Vector4 operator/(const Vector4& v1, const Real& s) // Scalar division
{ Vector4 r(v1); return r/= s; }

inline std::ostream& operator<<(std::ostream& out, const Vector4& v) // Output
{ return out << "(" << v.x << "," << v.y << "," << v.z << "," << v.w << ")"; }


} // base

#endif

---