#if !defined( __STDVECTOR_H )
#define __STDVECTOR_H

#if( _MSC_VER >= 1000 )
	#pragma once
#endif

#include <math.h>
#include "vtkObject.h"


class vtkStdSubVector;


//!	Easy handling of three element vectors of type double
class vtkStdVector: public vtkObject
{

//***** c o n s t r u c t o r s

public:

	//! constructors initializing the three vector elements (with zeros by default)
	vtkStdVector()  { m_adData[0] = m_adData[1] = m_adData[2] = 0; }
	vtkStdVector( const double dX, const double dY, const double dZ )
	{
		m_adData[0] = dX;
		m_adData[1] = dY;
		m_adData[2] = dZ;
	}
	vtkStdVector( const vtkStdSubVector& );
	vtkStdVector( const vtkBESSArray<float>& a, const UINT uFirstElement )
	{
		Extract( a,uFirstElement );
	}
	vtkStdVector( const vtkBESSArray<double>& a, const UINT uFirstElement )
	{
		Extract( a,uFirstElement );
	}

	//! copy constructor
	vtkStdVector( const vtkStdVector& sv )
	{
		m_adData[0] = sv[0];
		m_adData[1] = sv[1];
		m_adData[2] = sv[2];
	}


//***** p u b l i c   m e t h o d s

	//! Extract copy of three element vector contained in general vector
	void Extract( const vtkBaseArray<float>& a, const UINT uFirstElement )
	{
		m_adData[0] = a[uFirstElement  ];
		m_adData[1] = a[uFirstElement+1];
		m_adData[2] = a[uFirstElement+2];
	}
	//! Extract copy of three element vector contained in general vector
	void Extract( const vtkBaseArray<double>& a, const UINT uFirstElement )
	{
		m_adData[0] = a[uFirstElement  ];
		m_adData[1] = a[uFirstElement+1];
		m_adData[2] = a[uFirstElement+2];
	}

	//! Convert the vector into a unit vector
	vtkStdVector& MakeUnitVector()
	{
		double d = 1 / SquareNorm();
		m_adData[0] *= d;
		m_adData[1] *= d;
		m_adData[2] *= d;
		return *this;
	}

	//! Access to vector elements
	double&	operator[]( const char& c )		   { assert( c < 3 );  return m_adData[c]; }
	//! Access to vector elements
	double	operator[]( const char& c ) const  { assert( c < 3 );  return m_adData[c]; }

	//! Multiplication with scalar
	vtkStdVector operator* ( const double& d ) const
	{
		return vtkStdVector( d*m_adData[0],d*m_adData[1],d*m_adData[2] );
	}
	//! Access to vector elements
	void operator*=( const double& d )
	{
		m_adData[0] *= d;
		m_adData[1] *= d;
		m_adData[2] *= d;
	}

	//! Scalar product with other standard vector or standard vector pointer
	const double operator*( const vtkStdVector& sv ) const
	{
		return m_adData[0] * sv[0] + m_adData[1] * sv[1] + m_adData[2] * sv[2];
	}

	//! Vector product with other standard vector or standard vector pointer
	vtkStdVector operator&( const vtkStdVector& sv ) const
	{
		return vtkStdVector( m_adData[1] * sv[2] - m_adData[2] * sv[1],
						   m_adData[2] * sv[0] - m_adData[0] * sv[2],
						   m_adData[0] * sv[1] - m_adData[1] * sv[0]  );
	}

	//! Addition of another standard vector or standard vector pointer
	vtkStdVector operator+ ( const vtkStdVector& sv	) const
	{
		return vtkStdVector( m_adData[0] + sv[0],m_adData[1] + sv[1],m_adData[2] + sv[2] );
	}
	//! Addition of another standard vector or standard vector pointer
	void operator+=( const vtkStdVector& sv )
	{
		m_adData[0] += sv[0];
		m_adData[1] += sv[1];
		m_adData[2] += sv[2];
	}

	//! Subtraction of another standard vector or standard vector pointer
	vtkStdVector operator-( const vtkStdVector& sv ) const
	{
		return vtkStdVector( m_adData[0] - sv[0],m_adData[1] - sv[1],m_adData[2] - sv[2] );
	}
	//! Subtraction of another standard vector or standard vector pointer
	void operator-=( const vtkStdVector& sv )
	{
		m_adData[0] -= sv[0];
		m_adData[1] -= sv[1];
		m_adData[2] -= sv[2];
	}

	//! Obtain the vector's square norm
	const double SquareNorm() const
	{
		return sqrt(   m_adData[0] * m_adData[0]
					 + m_adData[1] * m_adData[1]
					 + m_adData[2] * m_adData[2] );
	}

	// obtain vector's copy with unit length
	vtkStdVector UnitVector() const
	{
		double d = 1 / SquareNorm();
		return vtkStdVector( m_adData[0] * d, m_adData[1] * d, m_adData[2] * d );
	}


//***** p r i v a t e   m e t h o d s

private:

	//! three vector elements
	double m_adData[3];

};  // class vtkStdVector


#endif // if !defined (__STDVECTOR_H)