---

Vector3.h

Go to the documentation of this file.

//
//    Title     : Vector3.h
//    Project     : OSCAR Version 2.0
//    Created     : 9/21/1994
//      Author          : Chetan Kapoor
//      Platforms       : All
//      Copyright       : Copyright© The University of Texas at Austin, 2002. All rights reserved.
//
//          This software and documentation constitute an unpublished work
//          and contain valuable trade secrets and proprietary information
//          belonging to the University. None of the foregoing material may be
//          copied or duplicated or disclosed without the express, written
//          permission of University. THE UNIVERSITY EXPRESSLY DISCLAIMS ANY
//          AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION,
//          INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//          PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY
//          THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE.
//          NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF
//          THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall the
//          University be liable for incidental, special, indirect, direct or
//          consequential damages or loss of profits, interruption of business,
//          or related expenses which may arise from use of software or documentation,
//          including but not limited to those resulting from defects in software
//          and/or documentation, or loss or inaccuracy of data of any kind.
//
//    Purpose     :
//
//-----------------------------------------------------------------------------
//
//    $Revisions$
//      Jacy Legault -Added cross operator 4/10/98
//      Troy Harden  -Added + and - operators 6-7-99
//      Ethan Swint - Added Norm2 to return square of norm 1/29/03
//
//    $Log: Vector3.h,v $
//    Revision 1.30  2007/07/09 19:31:42  kapoorc
//    Changed abort() calls to exit(EXIT_FAILURE). Exit calls clear up global memory vs. abort that do not. also, abort() is not supported in WINCE
//
//    Revision 1.29  2005/11/04 19:07:18  chetan
//    Undoing my removal of static TLS
//
//    Revision 1.27  2005/05/17 20:09:15  edjung
//    Revised STATIC_THREAD_LOCAL macros and updated all libraries to use them
//
//    Revision 1.26  2005/04/26 22:23:28  edjung
//    -Cleaned up some header includes by removing TSS_T.h
//
//    Revision 1.25  2005/03/21 17:26:28  aspencer
//    Changed the "Distance" and "DistanceSqr" functions from taking non-const Vector3's to const Vector3's.
//
//    Revision 1.24  2005/03/18 22:16:09  chetan
//    Enabled W4 level warnings and fixed warnings
//
//    Revision 1.23  2005/03/14 22:04:28  pmarch
//    Added to namespace OSCAR and removed "RR" from front of class names.
//
//    Revision 1.22  2005/02/23 14:33:08  aspencer
//    Added "Distance" and "Distance Sqr" functions
//
//    Revision 1.21  2005/02/03 22:51:49  edjung
//    Made changes to add Thread Local Storage using ACE
//    Also some loop unrolling
//
//    Revision 1.20  2005/01/20 18:23:22  chetan
//    Code change for speed optimization. eliminated copying
//
//    Revision 1.19  2005/01/06 22:51:02  chetan
//    Fixed TLS and added default constructors
//
//    Revision 1.18  2005/01/06 20:46:48  chetan
//    Added Thread Local Storage to static variables
//
//    Revision 1.17  2005/01/05 22:25:00  josh
//    Added more efficient functions of vector addition, subtraction, multiplication, and division.
//
//    Revision 1.16  2005/01/05 19:10:10  josh
//    Changed the assignment operators to take a reference instead of a value.
//
//    Revision 1.15  2004/06/08 23:00:03  chetan
//    Performance improvements and better error handling
//
//    Revision 1.14  2004/06/07 22:50:58  chetan
//    Added quite a few efficient methods for operator+,-,*,/+=,*=,/=,-=, etc. Added Dot product, opeator=, operator==, etc.
//
//    Revision 1.13  2004/05/26 20:01:54  pmarch
//    Added /defgroup and /ingroup tags.
//
//    Revision 1.12  2004/01/26 20:54:32  pmarch
//    Fixed documentation errors as reported by Doxygen.
//
//    Revision 1.11  2003/10/28 21:55:47  eswint
//    - Reinstated Vector3::operator-(Vector3) that returns Vector3
//
//    Revision 1.10  2003/10/28 21:48:01  eswint
//    - Reinstated operator+(Vector3) that returns Vector3
//
//    Revision 1.9  2003/10/06 09:16:06  edjung
//    -Changed destructor to virtual to fix memory leak
//
//    Revision 1.8  2003/09/09 17:13:05  eswint
//    - Changed #include "Math/..." to #include "..."
//
//    Revision 1.7  2003/09/02 20:50:02  eswint
//    - Made construction from double* explicit
//
//    Revision 1.6  2003/08/26 22:23:58  eswint
//    - Added const methods for X(), Y(), and Z().  The GetX(),GetY(),GetZ() methods are deprecated.
//
//    Revision 1.5  2003/08/25 17:27:59  eswint
//    - Removed duplicate data member
//    - Removed duplicate mathematical operators and constructors
//
//    Revision 1.4  2003/08/22 20:06:38  eswint
//    - Changed Vector3 to inherit from FixedSizeArray
//
//    Revision 1.3  2003/08/19 18:22:45  eswint
//    -Cleaned up commenting
//
//    Revision 1.2  2003/08/19 18:09:28  eswint
//    - Added Orthog method to VectorNumeric to orthogonalize function parameter against calling object
//    - Moved Norm, Normalize, and Unit from Vector3 to VectorNumeric
//
//    Revision 1.1  2003/08/18 15:23:22  eswint
//    Initial Commit
//
//
#ifndef Vector3_hpp
#define Vector3_hpp

#include "FixedSizeMatrix.h"
#include "Vector.h"

namespace OSCAR {

  class Vector3 : public FixedSizeArray<Vector, 3>
  {
  public:

    Vector3();

    Vector3(double x, double y, double z);

    explicit Vector3(double *array);

    Vector3(const Vector& arg);

    virtual ~Vector3();

    double& X() {
      return element[0];
    }

    const double& X() const {
      return element[0];
    }

    double& Y() {
      return element[1];
    }

    const double& Y() const {
      return element[1];
    }

    double& Z() {
      return element[2];
    }

    const double& Z() const {
      return element[2];
    }

    double GetX() const {
      return element[0];
    }

    double GetY() const {
      return element[1];
    }

    double GetZ() const {
      return element[2];
    }

    double Distance(const Vector3& vec) const {
        return sqrt(DistanceSqr(vec));
    }

    double DistanceSqr(const Vector3& vec) const {
        return (element[0]-vec.at(0))*(element[0]-vec.at(0))+(element[1]-vec.at(1))*(element[1]-vec.at(1))+(element[2]-vec.at(2))*(element[2]-vec.at(2));
    }

    void X(double x) {
      element[0] = x;
    }

    void Y(double y) {
      element[1] = y;
    }

    void Z(double z) {
      element[2] = z;
    }


    bool operator==(const Vector3& rhs) const
    {
      if(at(0) != rhs.at(0) || at(1) != rhs.at(1) || at(2) != rhs.at(2)){
        return false;
      }
      return true;
    }

    Vector3 Cross(const Vector3& v2) const;

    void Null(){
      at(0) = at(1) = at(2) = 0.0;
    }

    double Dot(const Vector3& rhs) const
    {
      return at(0)*rhs.at(0) + at(1)*rhs.at(1)+ at(2)*rhs.at(2);
    }

    Matrix Cross();

    Vector3& operator=(const Vector3& rhs) {
      at(0) = rhs.at(0);
      at(1) = rhs.at(1);
      at(2) = rhs.at(2);
      return *this;
    }


    Vector3& operator=(const Vector& rhs) {
      if(rhs.GetSize() != GetSize()){
        DisplayError(arraySizeMismatch);
                exit(EXIT_FAILURE);      
          }
      at(0) = rhs.at(0);
      at(1) = rhs.at(1);
      at(2) = rhs.at(2);
      return *this;
    }

    Vector3& operator=(double rhs) {
      at(0) = at(1) = at(2) = rhs;
      return *this;
    }

    Vector3& operator+=(const Vector3& rhs){
      at(0) += rhs.at(0);
      at(1) += rhs.at(1);
      at(2) += rhs.at(2);
      return *this;
    }

    Vector3& operator-=(const Vector3& rhs){
      at(0) -= rhs.at(0);
      at(1) -= rhs.at(1);
      at(2) -= rhs.at(2);
      return *this;
    }

    Vector3& operator*=(const Vector3& rhs){
      at(0) *= rhs.at(0);
      at(1) *= rhs.at(1);
      at(2) *= rhs.at(2);
      return *this;
    }

    Vector3& operator+=(double rhs) {
      at(0) += rhs;
      at(1) += rhs;
      at(2) += rhs;
      return *this;
    }

    Vector3& operator-=(double rhs) {
      at(0) -= rhs;
      at(1) -= rhs;
      at(2) -= rhs;
      return *this;
    }

    Vector3& operator*=(double rhs) {
      at(0) *= rhs;
      at(1) *= rhs;
      at(2) *= rhs;
      return *this;
    }

    Vector3& operator/=(double rhs) {
      if(rhs == 0.0){
        DisplayError(divideByZero);
                exit(EXIT_FAILURE);      
          }
      at(0) /= rhs;
      at(1) /= rhs;
      at(2) /= rhs;
      return *this;
    }


    Vector3 operator+(const Vector3& rhs) const {
      //static TLS Vector3 result;
      STATIC_THREAD_LOCAL(Vector3, p_result);
      /* result = *this;
      result += rhs; */
      // instead of the above, do this
      p_result->at(0) = this->at(0) + rhs.at(0);
      p_result->at(1) = this->at(1) + rhs.at(1);
      p_result->at(2) = this->at(2) + rhs.at(2);

      return *p_result;
    }

    void Add(const Vector3& rhs, Vector3& result) const {
      /* result = *this;
      result += rhs; */
      // instead of the above, do this
      result.at(0) = this->at(0) + rhs.at(0);
      result.at(1) = this->at(1) + rhs.at(1);
      result.at(2) = this->at(2) + rhs.at(2);
    }

    Vector3 operator-(const Vector3& rhs) const {
      //static TLS Vector3 result;
      STATIC_THREAD_LOCAL(Vector3, p_result);
      /* result = *this;
      result -= rhs;  */
      // instead of the above, do this
      p_result->at(0) = this->at(0) - rhs.at(0);
      p_result->at(1) = this->at(1) - rhs.at(1);
      p_result->at(2) = this->at(2) - rhs.at(2);

      return *p_result;
    }

    void Subtract(const Vector3& rhs, Vector3& result) const {
      /* result = *this;
      result -= rhs; */
      // instead of the above, do this
      result.at(0) = this->at(0) - rhs.at(0);
      result.at(1) = this->at(1) - rhs.at(1);
      result.at(2) = this->at(2) - rhs.at(2);
    }

    Vector3 operator*(const Vector3& rhs) const {
      //static TLS Vector3 result;
      STATIC_THREAD_LOCAL(Vector3, p_result);
      /*result = *this;
      result *= rhs;  */
      // instead of the above, do this
    
      p_result->at(0) = this->at(0) * rhs.at(0);
      p_result->at(1) = this->at(1) * rhs.at(1);
      p_result->at(2) = this->at(2) * rhs.at(2);

      return *p_result;
    }

    void Multiply(const Vector3& rhs, Vector3& result) const {
      /* result = *this;
      result *= rhs;  */
      // instead of the above, do this
      result.at(0) = this->at(0) * rhs.at(0);
      result.at(1) = this->at(1) * rhs.at(1);
      result.at(2) = this->at(2) * rhs.at(2);
    }

    Vector3 operator*(double rhs) const {
      //static TLS Vector3 result;
      STATIC_THREAD_LOCAL(Vector3, p_result);
    /*    result = *this;
      result *= rhs; */
      // instead of the above, do this
      p_result->at(0) = this->at(0) * rhs;
      p_result->at(1) = this->at(1) * rhs;
      p_result->at(2) = this->at(2) * rhs;
      return *p_result;
    }

    void Multiply(double rhs, Vector3& result) const {
      /* result = *this;
      result *= rhs; */
      // instead of the above, do this
      result.at(0) = this->at(0) * rhs;
      result.at(1) = this->at(1) * rhs;
      result.at(2) = this->at(2) * rhs;
    }

    Vector3 operator+(double rhs) const {
      //static TLS Vector3 result;
      STATIC_THREAD_LOCAL(Vector3, p_result);
      /* result = *this;
      result += rhs; */
      // instead of the above, do this
      p_result->at(0) = this->at(0) + rhs;
      p_result->at(1) = this->at(1) + rhs;
      p_result->at(2) = this->at(2) + rhs;

      return *p_result;
    }

    void Add(double rhs, Vector3& result) const {
      /*result = *this;
      result += rhs; */
      // instead of the above, do this
      result.at(0) = this->at(0) + rhs;
      result.at(1) = this->at(1) + rhs;
      result.at(2) = this->at(2) + rhs;
    }

    Vector3 operator-(double rhs) const {
      //static TLS Vector3 result;
      STATIC_THREAD_LOCAL(Vector3, p_result);
      /*    result = *this;
      result -= rhs;  */
      // instead of the above, do this
      p_result->at(0) = this->at(0) - rhs;
      p_result->at(1) = this->at(1) - rhs;
      p_result->at(2) = this->at(2) - rhs;

      return *p_result;
    }

    void Subtract(double rhs, Vector3& result) const {
      /*    result = *this;
      result -= rhs;  */
      // instead of the above, do this
      result.at(0) = this->at(0) - rhs;
      result.at(1) = this->at(1) - rhs;
      result.at(2) = this->at(2) - rhs;
    }

    Vector3 operator/(double rhs) const {
      //static TLS Vector3 result;
      STATIC_THREAD_LOCAL(Vector3, p_result);
      /*result = *this;
      result /= rhs;  */
      // instead of the above, do this
      if(rhs == 0.0){
        DisplayError(divideByZero);
        return Vector3();
      }
      p_result->at(0) = this->at(0)/ rhs;
      p_result->at(1) = this->at(1)/rhs;
      p_result->at(2) = this->at(2)/rhs;
      return *p_result;
    }

    bool Divide(double rhs, Vector3& result) const {
      /*    result = *this;
      result /= rhs;  */
      // instead of the above, do this
      if(rhs == 0.0){
        DisplayError(divideByZero);
        return false;
      }
      result.at(0) = this->at(0)/ rhs;
      result.at(1) = this->at(1)/rhs;
      result.at(2) = this->at(2)/rhs;
      return true;
    }

  protected:

    void init(const double* array = 0);
  };


  #include "Vector3.ipp"

  typedef Vector3   Vector3D;
}
#endif  // Vector3_hpp

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations