vector3.h

Go to the documentation of this file.

/**********************************************************************
vector3.h - Handle 3D coordinates.

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 by Geoffrey R. Hutchison
Some portions Copyright (C) 2006 by Benoit Jacob

This file is part of the Open Babel project.
For more information, see <http://openbabel.org/>

This program 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 version 2 of the License.

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.
***********************************************************************/

#ifndef OB_VECTOR_H
#define OB_VECTOR_H

#include <ostream>
#include <math.h>
#include <iostream>

#include <openbabel/babelconfig.h>

#ifndef RAD_TO_DEG
#define RAD_TO_DEG (180.0/M_PI)
#endif

#ifndef DEG_TO_RAD
#define DEG_TO_RAD (M_PI/180.0)
#endif

namespace OpenBabel
{

 class matrix3x3; // declared in math/matrix3x3.h

 // class introduction in vector3.cpp
 class OBAPI vector3
 {
 private :
 double _vx, _vy, _vz ;

 public :
 vector3 (const double inX=0.0, const double inY=0.0, const double inZ=0.0):
 _vx(inX), _vy(inY), _vz(inZ)
 {}
 vector3 (double inV[3]):
 _vx(inV[0]), _vy(inV[1]), _vz(inV[2])
 {}
 vector3 (const vector3& v):
 _vx(v._vx), _vy(v._vy), _vz(v._vz)
 { }

 ~vector3() { }

 typedef double* iterator;

 typedef const double* const_iterator;

 typedef std::ptrdiff_t difference_type;

 iterator begin() { return &_vx; }

 iterator end() { return &_vx + 3; }

 const_iterator begin() const { return &_vx; }

 const_iterator end() const { return &_vx + 3; }

 void Set(const double inX, const double inY, const double inZ)
 {
 _vx = inX;
 _vy = inY;
 _vz = inZ;
 }
 void Set(const double *c)
 {
 _vx = c[0];
 _vy = c[1];
 _vz = c[2];
 }
 void SetX(const double inX)
 {
 _vx = inX;
 }
 void SetY(const double inY)
 {
 _vy = inY;
 }
 void SetZ(const double inZ)
 {
 _vz = inZ;
 }
 double GetX() const
 {
 return _vx;
 }
 double GetY() const
 {
 return _vy;
 }
 double GetZ() const
 {
 return _vz;
 }
 void Get(double *c)
 {
 c[0]=_vx;
 c[1]=_vy;
 c[2]=_vz;
 }
 double operator[] ( unsigned int i) const;

 vector3& operator= ( const vector3& v)
 {
 _vx = v._vx;
 _vy = v._vy;
 _vz = v._vz;
 return *this;
 }

 const double *AsArray() const
 {
 return &_vx;
 }

 vector3& operator+= ( const vector3& v)
 {
 _vx += v._vx;
 _vy += v._vy;
 _vz += v._vz;
 return *this;
 };
 vector3& operator-= ( const vector3& v)
 {
 _vx -= v._vx;
 _vy -= v._vy;
 _vz -= v._vz;
 return *this;
 };
 vector3& operator+= ( const double* f)
 {
 _vx += f[0];
 _vy += f[1];
 _vz += f[2];
 return *this;
 };
 vector3& operator-= ( const double* f)
 {
 _vx -= f[0];
 _vy -= f[1];
 _vz -= f[2];
 return *this;
 };
 vector3& operator*= ( const double& c)
 {
 _vx *= c;
 _vy *= c;
 _vz *= c;
 return *this;
 };

 vector3& operator/= ( const double& c)
 {
 double inv = 1.0 / c;
 return( (*this) *= inv );
 };
 vector3& operator*= ( const matrix3x3 &);

 void randomUnitVector();

 // Member Functions

 vector3& normalize () ;

 bool CanBeNormalized () const;

 inline double length_2 () const
 {
 return _vx*_vx + _vy*_vy + _vz*_vz;
 };
 double length () const
 {
 return sqrt( length_2() );
 };
 const double & x () const
 {
 return _vx ;
 } ;
 const double & y () const
 {
 return _vy ;
 } ;
 const double & z () const
 {
 return _vz ;
 } ;
 double & x ()
 {
 return _vx ;
 } ;
 double & y ()
 {
 return _vy ;
 } ;
 double & z ()
 {
 return _vz ;
 } ;

 // @{
 int operator== ( const vector3& ) const;
 int operator!= ( const vector3& other ) const
 {
 return ! ( (*this) == other );
 }
 bool IsApprox( const vector3 & other, const double & precision ) const;


 double distSq(const vector3 &vv) const
 {
 double dx = x() - vv.x();
 double dy = y() - vv.y();
 double dz = z() - vv.z();
 return( dx*dx + dy*dy + dz*dz );
 }

 bool createOrthoVector(vector3 &v) const;

 };

 OBAPI std::ostream& operator<< ( std::ostream&, const vector3& );

 // Sum, Difference, Scalar Product
 inline OBAPI vector3 operator+ ( const vector3& v1, const vector3& v2)
 {
 return vector3(v1.x()+v2.x(), v1.y()+v2.y(), v1.z()+v2.z());
 }
 inline OBAPI vector3 operator- ( const vector3& v1, const vector3& v2)
 {
 return vector3(v1.x()-v2.x(), v1.y()-v2.y(), v1.z()-v2.z());
 }
 inline OBAPI vector3 operator- ( const vector3& v)
 {
 return vector3(-v.x(), -v.y(), -v.z());
 }
 inline OBAPI vector3 operator* ( const double& c, const vector3& v)
 {
 return vector3( c*v.x(), c*v.y(), c*v.z());
 }
 inline OBAPI vector3 operator* ( const vector3& v, const double& c)
 {
 return vector3( c*v.x(), c*v.y(), c*v.z());
 }
 inline OBAPI vector3 operator/ ( const vector3& v, const double& c)
 {
 return vector3( v.x()/c, v.y()/c, v.z()/c);
 }
 // @removed@ misleading operation
 // friend vector3 operator* ( const vector3 &,const vector3 &);

 //vector and matrix ops
 // @removed@ misleading operation; matrix multiplication is not commutitative
 // friend vector3 operator *(const vector3 &v,const matrix3x3 &m);

 OBAPI vector3 operator *(const matrix3x3 &m, const vector3 &v);

 inline OBAPI double dot ( const vector3& v1, const vector3& v2 )
 {
 return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z() ;
 }
 OBAPI vector3 cross ( const vector3&, const vector3& );

 OBAPI double vectorAngle ( const vector3& v1, const vector3& v2 );

 OBAPI double CalcTorsionAngle(const vector3 &a, const vector3 &b,
 const vector3 &c, const vector3 &d);

 OBAPI double Point2PlaneSigned(vector3 a, vector3 b, vector3 c, vector3 d);
 OBAPI double Point2Plane(vector3 a, vector3 b, vector3 c, vector3 d);
 OBAPI double Point2PlaneAngle(const vector3 a, const vector3 b, const vector3 c, const vector3 d);

 OBAPI double Point2Line(const vector3& a, const vector3& b, const vector3& c);

 // The global constant vector3 objects
 extern OBAPI const vector3 VZero;
 extern OBAPI const vector3 VX;
 extern OBAPI const vector3 VY;
 extern OBAPI const vector3 VZ;

}

#endif // OB_VECTOR_H