/* vector.h                                              -*-C++-*-
 *   by Will Wagner <wwagner@io.com>
 *   last updated 14 Sep 1997, 22:25:45 wwagner
 *
 * This file contains the pov_vector template class, which is a
 * derivative of the STL vector class.
 *
 * Changes
 *   04 Aug 1997
 *     - Added this comment block.
 *
 *   14 Sep 1997
 *     - Added the operator== and operator< routines, since they are
 *     not actually members of the base class (we need them in
 *     Parser::expr_parse).
 *
 * Things to do
 *
 */

#ifndef __INC_POV_VECTOR_H__
#define __INC_POV_VECTOR_H__

#include <g++/vector.h>
#include <g++/algo.h>
#include <g++/function.h>

template <class T>
class pov_vector : public vector<T>
{
  public:
    pov_vector(void) : vector<T>() { };
    pov_vector(int i, T v) : vector<T>(i, v) { };

    /* The vector-scalar routines */

    inline pov_vector<T> operator*(T num) const
    {
	pov_vector<T> nv;
	transform(this->begin(), this->end(), nv.begin(),
		  bind2nd(times<T>(), num));
	return nv;
    };

    inline pov_vector<T> operator/(T num) const
    {
	pov_vector<T> nv;
	transform(this->begin(), this->end(), nv.begin(),
		  bind2nd(divides<T>(), (num ? num : 1)));
	return nv;
    };

    inline const pov_vector<T>& operator*=(T num)
    {
	transform(this->begin(), this->end(), this->begin(),
		  bind2nd(times<T>(), num));
	return *this;
    };

    inline const pov_vector<T>& operator/=(T num)
    {
	transform(this->begin(), this->end(), this->begin(),
		  bind2nd(divides<T>(), (num ? num : 1)));
	return *this;
    };

    /* The vector-vector routines */

    inline pov_vector<T> operator+(const pov_vector<T>& second) const
    {
	pov_vector<T> nv = *this;
	transform(this->begin(), this->end(), second.begin(), nv.begin(),
		  plus<T>());
	return nv;
    };

    inline pov_vector<T> operator-(const pov_vector<T>& second) const
    {
	pov_vector<T> nv = *this;
	transform(this->begin(), this->end(), second.begin(), nv.begin(),
		  minus<T>());
	return nv;
    };

    inline pov_vector<T> operator*(const pov_vector<T>& second) const
    {
	pov_vector<T> nv = *this;
	transform(this->begin(), this->end(), second.begin(), nv.begin(),
		  times<T>());
	return nv;
    };

    inline pov_vector<T> operator/(const pov_vector<T>& second) const
    {
	pov_vector<T> nv = *this;
	transform(this->begin(), this->end(), second.begin(), nv.begin(),
		  divides<T>());
	return nv;
    };

    inline const pov_vector<T>& operator+=(const pov_vector<T>& second)
    {
	transform(this->begin(), this->end(), second.begin(), this->begin(),
		  plus<T>());
	return *this;
    };

    inline const pov_vector<T>& operator-=(const pov_vector<T>& second)
    {
	transform(this->begin(), this->end(), second.begin(), this->begin(),
		  minus<T>());
	return *this;
    };

    inline const pov_vector<T>& operator*=(const pov_vector<T>& second)
    {
	transform(this->begin(), this->end(), second.begin(), this->begin(),
		  times<T>());
	return *this;
    };

    inline const pov_vector<T>& operator/=(const pov_vector<T>& second)
    {
	transform(this->begin(), this->end(), second.begin(), this->begin(),
		  divides<T>());
	return *this;
    };

    inline pov_vector<T> Cross(pov_vector<T>& second)
    {
	pov_vector<T> tmp = *this;
	tmp[0] = (*this)[1] * second[2] - (*this)[2] * second[1];
	tmp[1] = (*this)[2] * second[0] - (*this)[0] * second[2];
	tmp[2] = (*this)[0] * second[1] - (*this)[1] * second[0];
	return tmp;
    };

    inline T Dot(const pov_vector<T>& second) const
    {
       	pov_vector<T> tmp = *this * second;
	return accumulate(tmp.begin(), tmp.end(), 0.0);
    };

    inline T Length(void)
    {
	return sqrt(this->SumSquares());
    };

    inline T SumSquares(void)
    {
	return this->Dot(*this);
    };

    inline const pov_vector<T>& Normalize(void)
    {
	*this /= this->Length();
	return *this;
    };

    inline pov_vector<T> Normalized(void)
    {
	pov_vector<T> nv = *this;
	nv.Normalize();
	return nv;
    };

    inline const pov_vector<T>& Half(const pov_vector<T>& second)
    {
	*this += second;
	*this *= 0.5;
	return *this;
    };

    inline pov_vector<T> Halved(const pov_vector<T>& second)
    {
	pov_vector<T> nv = *this;
	nv += second;
	nv *= 0.5;
	return nv;
    };
};

template <class T>
inline pov_vector<T> operator*(T num, const pov_vector<T>& v)
{
    return v * num;
};

/* The comparison routines */
template <class T>
inline bool operator==(const pov_vector<T>& i, const pov_vector<T>& j)
{ return operator==((const vector<T>&)i, (const vector<T>&)j); };

template <class T>
inline bool operator<(const pov_vector<T>& i, const pov_vector<T>& j)
{ return operator<((const vector<T>&)i, (const vector<T>&)j); };


#endif /* __INC_POV_VECTOR_H__ */