VVector.hh

Go to the documentation of this file.

/* -*- Mode: CC; indent-tabs-mode: nil; c-basic-offset: 5 -*- */

/* 
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Created by Daniel Aarno on Tue Nov 25 2003.
Copyright (c) 2004 by Daniel Aarno - <macbishop@users.sf.net>
M. Sc. in Electrical Engineering - http://www.e.kth.se/~e98_aar

All Rights Reserved
ATTRIBUTION ASSURANCE LICENSE (adapted from the original BSD license)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the conditions below are met.
These conditions require a modest attribution to  (the
"Author"), who hopes that its promotional value may help justify the
thousands of dollars in otherwise billable time invested in writing
this and other freely available, open-source software.

1. Redistributions of source code, in whole or part and with or without
modification (the "Code"), must prominently display this GPG-signed
text in verifiable form.
2. Redistributions of the Code in binary form must be accompanied by
this GPG-signed text in any documentation and, each time the resulting
executable program or a program dependent thereon is launched, a
prominent display (e.g., splash screen or banner text) of the Author's
attribution information, which includes:
(a) Name ("Daniel Aarno"),
(b) Professional identification ("M. Sc. in Electrical Engineering"), and
(c) URL ("http://www.e.kth.se/~e98_aar").
3. Neither the name nor any trademark of the Author may be used to
endorse or promote products derived from this software without specific
prior written permission.
4. Users are entirely responsible, to the exclusion of the Author and
any other persons, for compliance with (1) regulations set by owners or
administrators of employed equipment, (2) licensing terms of any other
software, and (3) local regulations regarding use, including those
regarding import, export, and use of encryption software.

THIS FREE SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL THE AUTHOR OR ANY CONTRIBUTOR BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
EFFECTS OF UNAUTHORIZED OR MALICIOUS NETWORK ACCESS;
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (GNU/Linux)

iD8DBQFB+7jgi6ECThHTSIkRAuJFAKCXjyB/7HxUEKqvIXry38bquCySZQCfUNbk
XEaqordUUTUdgKj87lhewM8=
=tkIO
-----END PGP SIGNATURE-----
*/

#ifndef _VVECTOR_
#define _VVECTOR_

#ifndef VVECTOR_ENABLE_INLINE
#define VVECTOR_SHOULD_UNDEF_INLINE
#endif
#define VVECTOR_ENABLE_INLINE
#include "vvector.h"
#ifdef VVECTOR_SHOULD_UNDEF_INLINE
#undef VVECTOR_ENABLE_INLINE
#undef VVECTOR_SHOULD_UNDEF_INLINE
#endif

#include <iostream>

class VVector {
private:
     d3 m_vval;

public:
     //======================================================================
     //                          Constructors
     //======================================================================

     VVector() {}

     explicit VVector(bool zero_) { 
          if(zero_)
               zero();
     }
     
     explicit VVector(double val) { 
          set(val, val, val);
     }

     explicit VVector(const f3 fv) { 
          m_vval[0] = fv[0]; 
          m_vval[1] = fv[1]; 
          m_vval[2] = fv[2]; 
     }

     explicit VVector(const d3 dv) { 
          m_vval[0] = dv[0]; 
          m_vval[1] = dv[1]; 
          m_vval[2] = dv[2]; 
     }

     VVector(double x, double y, double z) {
          set(x,y,z);
     }

     //======================================================================
     //                     Access functions
     //======================================================================

     const double operator[](int i) const {
          return (i >= 0 && i < 3 ? m_vval[i] : getDummy());
     }

     double& operator[](int i) {
          return (i >= 0 && i < 3 ? m_vval[i] : getDummy());
     }
  
     double& x() { return this->operator[](0); }
     double& y() { return this->operator[](1); }
     double& z() { return this->operator[](2); }

     const double x() const { return this->operator[](0); }
     const double y() const { return this->operator[](1); }
     const double z() const { return this->operator[](2); }

     //======================================================================
     //             Arithmetic and conversion operators
     //======================================================================

     operator const double*() const { return m_vval; }

     const VVector operator+(const VVector &rhs) const { 
          VVector ret;
          VPlusd(ret.m_vval, m_vval, rhs.m_vval); 
          return ret;
     }

     const VVector operator-(const VVector &rhs) const { 
          VVector ret;
          VMinusd(ret.m_vval, m_vval, rhs.m_vval); 
          return ret;
     }

     double operator*(const VVector &rhs) const { 
          return VDotd(m_vval, rhs.m_vval); 
     }

     const VVector operator*(double scalar) const { 
          VVector ret;
          VScalarMultiplyd(ret.m_vval, scalar, m_vval); 
          return ret;
     }

     const VVector operator/(double scalar) const { 
          VVector ret;
          VScalarMultiplyd(ret.m_vval, 1.0/scalar, m_vval); 
          return ret;
     }

     VVector& operator+=(const VVector &rhs) {
          VPlusd(m_vval, m_vval, rhs.m_vval);
          return *this;
     }

     VVector& operator-=(const VVector &rhs) {
          VMinusd(m_vval, m_vval, rhs.m_vval);
          return *this;
     }

     VVector& operator*=(double scalar) {
          VScalarMultiplyd(m_vval, scalar, m_vval);
          return *this;
     }

     VVector& operator/=(double scalar) {
          VScalarMultiplyd(m_vval, 1.0/scalar, m_vval);
          return *this;
     }

     //======================================================================
     //                       Vector arithmetic
     //======================================================================

     const VVector crossproduct(const VVector &with) const {
          d3 result;
          VCrossd(result, m_vval, with.m_vval);
          VVector ret(result);
          return ret;
     }
  
     const VVector projection(const VVector &onto) const {
          d3 result;
          VProjd(result, m_vval, onto.m_vval);
          VVector ret(result);
          return ret;
     }
  
     const VVector perpendicular(const VVector &to) const {
          d3 result;
          VPerpd(result, m_vval, to.m_vval);
          VVector ret(result);
          return ret;
     }
  
     const VVector rotX(double angleRad) const {
          d3 result;
          VRotXd(result, m_vval, angleRad);
          VVector ret(result);
          return ret;
     }
  
     const VVector rotY(double angleRad) const {
          d3 result;
          VRotYd(result, m_vval, angleRad);
          VVector ret(result);
          return ret;
     }
  
     const VVector rotZ(double angleRad) const {
          d3 result;
          VRotZd(result, m_vval, angleRad);
          VVector ret(result);
          return ret;
     }
  
     const VVector rotN(const VVector &n, double angleRad) const {
          d3 result;
          VRotNd(result, m_vval, n, angleRad);
          VVector ret(result);
          return ret;
     }

     const double length() const {
          return VLengthd(m_vval);
     }
  
     void normalize() {
          VNormalized(m_vval);
     }

     void set(double x, double y, double z) {        
          m_vval[0] = x; 
          m_vval[1] = y; 
          m_vval[2] = z;
     }

     //Set value of the vector to (0,0,0)
     void zero() { set(0,0,0); }
  
     //======================================================================
     //                           Helper functions
     //======================================================================
private:
     static double& getDummy() 
     { 
          static double dummy = 0; 
#ifndef NDEBUG
          std::cerr << "WARNING VVector.hh:" << __LINE__ 
                    << " Dummy value accessed" << std::endl;
#endif
          return dummy;
     }
  
     //======================================================================
     //                              Friends
     //======================================================================
     friend std::ostream& operator<<(std::ostream &o, const VVector &v);
}; //< class VVector


//======================================================================
//                          Gloabl functions
//======================================================================

//Inline helps prevent multiple definitions and speeds things up
inline std::ostream& operator<<(std::ostream &o, const VVector &v)
{
     o << '[' << v.m_vval[0] << ", " << v.m_vval[1] 
       << ", " << v.m_vval[2] << ']';
     return o;
}

inline const VVector operator*(double scalar, const VVector &rhs) { 
     return rhs * scalar;
}

#endif

---