#ifndef POINT_T_H
#define POINT_T_H

#include <cmath>

template <class T>
struct point_t
{
	point_t(T a=0, T b=0, T c=0);
	point_t(const point_t<T>&P);
	~point_t();

	point_t<T>& operator += (const point_t<T>&P);
	point_t<T>& operator -= (const point_t<T>&P);
	point_t<T> operator + (const point_t<T>&P) const;
	point_t<T> operator - (const point_t<T>&P) const;
	T operator * (const point_t<T>&P) const;
	point_t<T>& neg();
	point_t<T> operator - () const;
	point_t<T>& operator *= (T d);
	point_t<T>& operator /= (T d);
	point_t<T>& operator += (T d);
	point_t<T>& operator -= (T d);
	point_t<T> operator * (T d) const;
	point_t<T> operator / (T d) const;
	point_t<T> operator + (T d) const;
	point_t<T> operator - (T d) const;
	point_t<T> cross(const point_t<T>&P) const;

	T mag() const;
	T mag2() const;
	point_t<T>&  make_unit();
	point_t<T> ret_unit() const;

	T x, y, z;
};

typedef point_t<long double> point3ld;
typedef point_t<double> point3d;
typedef point_t<float> point3f;

template <class T>
point_t<T> operator * (T d, const point_t<T>& P);
template <class T>
point_t<T> operator / (T d, const point_t<T>& P);
template <class T>
point_t<T> operator + (T d, const point_t<T>& P);
template <class T>
point_t<T> operator - (T d, const point_t<T>& P);

template <class T>
inline point_t<T>::point_t(T a, T b, T c)
{
	x=a;
	y=b;
	z=c;
}

template <class T>
inline point_t<T>::point_t(const point_t<T>&P)
{
	x=P.x;
	y=P.y;
	z=P.z;
}

template <class T>
inline point_t<T>::~point_t() {}

template <class T>
inline point_t<T>& point_t<T>::operator += (const point_t<T>&P)
{
	x += P.x;
	y += P.y;
	z += P.z;
	return *this;
}

template <class T>
inline point_t<T>& point_t<T>::operator -= (const point_t<T>&P)
{
	x -= P.x;
	y -= P.y;
	z -= P.z;
	return *this;
}

template <class T>
inline point_t<T> point_t<T>::operator + (const point_t<T>&P) const
{
	return point_t(*this) += P;
}

template <class T>
inline point_t<T> point_t<T>::operator - (const point_t<T>&P) const
{
	return point_t(*this) -= P;
}

template <class T>
inline T point_t<T>::operator * (const point_t<T>&P) const
{
	return x * P.x + y * P.y + z * P.z;
}

template <class T>
inline point_t<T>& point_t<T>::neg()
{
	x = -x;
	y = -y;
	z = -z;
	return *this;
}

template <class T>
inline point_t<T> point_t<T>::operator - () const
{
	return point_t(*this).neg();
}

template <class T>
inline point_t<T>& point_t<T>::operator *= (T d)
{
	x *= d;
	y *= d;
	z *= d;
	return *this;
}

template <class T>
inline point_t<T>& point_t<T>::operator /= (T d)
{
	x /= d;
	y /= d;
	z /= d;
	return *this;
}

template <class T>
inline point_t<T>& point_t<T>::operator += (T d)
{
	x += d;
	y += d;
	z += d;
	return *this;
}

template <class T>
inline point_t<T>& point_t<T>::operator -= (T d)
{
	x -= d;
	y -= d;
	z -= d;
	return *this;
}

template <class T>
inline point_t<T> point_t<T>::operator + (T d) const
{
	return point_t<T>(*this) += d;
}

template <class T>
inline point_t<T> point_t<T>::operator - (T d) const
{
	return point_t<T>(*this) -= d;
}

template <class T>
inline point_t<T> point_t<T>::operator * (T d) const
{
	return point_t<T>(*this) *= d;
}

template <class T>
inline point_t<T> point_t<T>::operator / (T d) const
{
	return point_t<T>(*this) /= d;
}

template <class T>
inline point_t<T> operator * (T d, const point_t<T>& P)
{
	return point_t<T>(P) *= d;
}

template <class T>
inline point_t<T> operator / (T d, const point_t<T>& P)
{
	return point_t<T>(P) /= d;
}

template <class T>
inline point_t<T> operator + (T d, const point_t<T>& P)
{
	return point_t<T>(P) += d;
}

template <class T>
inline point_t<T> operator - (T d, const point_t<T>& P)
{
	return point_t<T>(P) -= d;
}

template <class T>
T point_t_dist2(const point_t<T>&A, const point_t<T>&B)
{
	T x = A.x - B.x;
	T y = A.y - B.y;
	T z = A.z - B.z;
	return x*x + y*y + z*z;
}

template <class T>
inline point_t<T> point_t<T>::cross(const point_t<T>&P) const
{
	point_t<T> ret;
	ret.x = y * P.z - z * P.y;
	ret.y = z * P.x - x * P.z;
	ret.z = x * P.y - y * P.x;
	return ret;
}

template <class T>
inline T point_t<T>::mag() const
{
	return sqrt(mag2());
}

template <class T>
inline T point_t<T>::mag2() const
{
	return *this * *this;
}

template <class T>
inline point_t<T>& point_t<T>::make_unit()
{
	return *this /= mag();
}

template <class T>
inline point_t<T> point_t<T>::ret_unit() const
{
	return point_t(*this).make_unit();
}

#endif