#ifndef VECTOR_H

#define VECTOR_H

#include <cmath>

#include <algorithm>

#include "real.h"

class Vector {

public:

	union {

		struct { Real x, y; };

		struct { Real coords[2]; };

	};

	explicit Vector(const Real &x = Real(), const Real &y = Real()): x(x), y(y) { }

	const Real& operator[] (int i) const { return coords[i]; }

	Real& operator[] (int i) { return coords[i]; }

	bool operator<(const Vector &a) const { return less(x, a.x) || (!less(a.x, x) && less(y, a.y)); }

	bool operator==(const Vector &a) const { return equal(x, a.x) && equal(y, a.y); }

	bool operator!=(const Vector &a) const { return !(*this == a); }

	Vector operator-() const { return Vector(-x, -y); }

	Vector operator+(const Vector &a) const { return Vector(x + a.x, y + a.y); }

	Vector operator-(const Vector &a) const { return Vector(x - a.x, y - a.y); }

	Vector operator*(const Real &a) const { return Vector(x*a, y*a); }

	Vector operator/(const Real &a) const { return *this * (Real(1)/a); }

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

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

	Vector& operator*=(const Real &a) { x *= a; y *= a; return *this; }

	Vector& operator/=(const Real &a) { return *this *= (Real(1)/a); }

	friend inline Vector operator*(const Real &a, const Vector &b) { return b*a; }

	friend inline Real dot(const Vector &a, const Vector &b) { return a.x*b.x + a.y*b.y; }

	bool iszero() const { return *this == Vector(); }

	void reset() { *this = Vector(); }

	Real lensqr() const { return dot(*this, *this); }

	Real len() const { return sqrt(lensqr()); }

	Vector norm() const { Real l = len(); return equal(l, 0) ? Vector() : *this/l; }

	Vector perp() const { return Vector(-y, x); }

	Vector scale(const Vector &a) const { return Vector(x*a.x, y*a.y); }

	Vector rotate(const Real &angle) const {

		Vector a = from_angle(angle);

		return Vector(x*a.x - y*a.y, x*a.y + y*a.x);

	}

	static Vector from_angle(Real angle)

		{ return Vector(cos(angle), sin(angle)); }

};

class RealPair {

public:

	Real a0, a1;

	RealPair(const Real &a0, const Real &a1):

		a0(a0), a1(a1) { }

	explicit RealPair(const Real &a = Real()):

		RealPair(a, a) { }

	Real dist() const { return a1 - a0; }

	void reset() { a0 = a1 = Real(); }

};

class Range: public RealPair {

public:

	using RealPair::RealPair;

	Real size() const { return dist(); }

	bool isempty() const { return !less(a0, a1); }

	Range& expand(const Real &a) {

		if (a < a0) a0 = a;

		if (a1 < a) a1 = a;

		return *this;

	}

	Range get_expanded(const Real &a) const

		{ return Range(std::min(a, a0), std::max(a1, a)); }

};

class VectorPair {

public:

	Real x0, y0, x1, y1;

	VectorPair(const Real &x0, const Real &y0, const Real &x1, const Real &y1):

		x0(x0), y0(y0), x1(x1), y1(y1) { }

	explicit VectorPair(const Real &x = Real(), const Real &y = Real()):

		VectorPair(x, y, x, y) { }

	VectorPair(const Vector &p0, const Vector &p1):

		VectorPair(p0.x, p0.y, p1.x, p1.y) { }

	explicit VectorPair(const Vector &p):

		VectorPair(p, p) { }

	VectorPair(const RealPair &x, const RealPair &y):

		VectorPair(x.a0, y.a0, x.a1, y.a1) { }

	Vector& p0() { return *(Vector*)&x0; };

	Vector& p1() { return *(Vector*)&x1; };

	const Vector& p0() const { return *(const Vector*)&x0; };

	const Vector& p1() const { return *(const Vector*)&x1; };

	Vector dist() const { return p1() - p0(); }

	Real dist_x() const { return x1 - x0; }

	Real dist_y() const { return y1 - y0; }

	void reset() { p0().reset(); p1().reset(); }

};

class Rect: public VectorPair {

public:

	using VectorPair::VectorPair;

	Vector size() const { return dist(); }

	Real width() const { return dist_x(); }

	Real height() const { return dist_y(); }

	bool isempty() const { return !less(x0, x1) || !less(y0, y1); }

	Rect& expand(const Real &x, const Real &y) {

		if (x0 < x) x0 = x;

		if (y0 < y) y0 = y;

		if (x1 < x) x1 = x;

		if (y1 < y) y1 = y;

		return *this;

	}

	Rect& expand(const Vector &p)

		{ return expand(p.x, p.y); }

	Rect get_expanded(const Real &x, const Real &y) const

		{ return Rect(std::min(x0, x), std::min(y0, y), std::max(x1, x), std::max(y1, y)); }

	Rect get_expanded(const Vector &p) const

		{ return get_expanded(p.x, p.y); }

};

#endif