//	Vector.h

//	This class defines a three-dimensional vector, with appropriate
//	operators.  (* is cross product.)

#ifndef VECTOR_H
#define VECTOR_H

#ifndef real
#define real double
#endif

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

class Vector {
   public:
	real x,y,z;				// vector components
	
	Vector() { x=y=z=0; }			// constructor
	Vector(const real pX, const real pY, const real pZ)
	: x(pX), y(pY), z(pZ) {}

	// vector arithmatic

	Vector operator+(const Vector pV) const
	{ Vector out( x+pV.x, y+pV.y, z+pV.z ); return out; }

	Vector operator-(const Vector pV) const
	{ Vector out( x-pV.x, y-pV.y, z-pV.z ); return out; }

	Vector& operator+=(const Vector pV)
	{ x+=pV.x; y+=pV.y; z+=pV.z; return *this; }

	Vector& operator-=(const Vector pV)
	{ x-=pV.x; y-=pV.y; z-=pV.z; return *this; }

	real Dot(const Vector pV) const			// dot product
	{ return x*pV.x + y*pV.y + z*pV.z; }

	Vector operator*(const Vector pV) const		// cross product
	{ Vector out( y*pV.z-z*pV.y, z*pV.x-x*pV.z, x*pV.y-y*pV.x ); 
	  return out; }

	Vector Cross( const Vector pV ) const
	{ return *this * pV; }

	friend real Dot( const Vector p1, const Vector p2 )
	{ return p1.Dot(p2); }

	friend Vector Cross( const Vector p1, const Vector p2 )
	{ return p1 * p2; }

	Vector operator*(const real pR) const		// * a scalar
	{ Vector out( x*pR, y*pR, z*pR ); return out; }

	friend Vector operator*(const real pR, const Vector pV)
	{ Vector out( pV.x*pR, pV.y*pR, pV.z*pR ); return out; }

	Vector& operator*=(const real pR)
	{ x*=pR; y*=pR; z*=pR; return *this; }

	// magnitude

	real LenSqr(void) const
	{ return x*x+y*y+z*z; }

	real Length(void) const
	{ return sqrt(LenSqr()); }

	// projection (component of *this parallel to pV)
	// Note: component perpendicular to pV is:  *this - Proj(pV)

	Vector Proj(const Vector pV)
	{ Vector out( pV * (this->Dot(pV) / pV.LenSqr()) ); return out; }

	// cosine of the angle between two vectors:
	real CosAng( const Vector pV)
	{ return this->Dot(pV) / (Length() * pV.Length()); }

	// comparison
	int operator==( const Vector pV) const
	{ return x==pV.x && y==pV.y && z==pV.z; }

	int operator!=( const Vector pV) const
	{ return x!=pV.x || y!=pV.y || z!=pV.z; }

	// input/output

	friend ostream& operator<<(ostream& pStr, const Vector& pV)
	{ return (pStr << '(' << pV.x << ',' << pV.y << ',' << pV.z << ')'); }

	friend istream& operator>>(istream pStr, Vector& pV)
	{ return (pStr >> pV.x >> pV.y >> pV.z); }
};

#endif