#include "Vector2D.h"

#include "../math/utility.h"
#include "../math/Matrix.h"

#include <cmath>

namespace meow{
  template<class Scalar>
  inline
  Vector2D<Scalar>::Vector2D():
  _x(0),
  _y(0){
  }
  
  
  template<class Scalar>
  inline
  Vector2D<Scalar>::Vector2D(Vector2D const& __v):
  _x(__v._x),
  _y(__v._y){
  }
  
  
  template<class Scalar>
  inline
  Vector2D<Scalar>::Vector2D(Scalar const& __x, Scalar const& __y):
  _x(__x),
  _y(__y){
  }
  
  
  template<class Scalar>
  inline
  Vector2D<Scalar>::~Vector2D(){
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::copy(Vector2D const& __v){
    _x = __v.x();
    _y = __v.y();
    return *this;
  }
  
  template<class Scalar>
  inline Scalar const&
  Vector2D<Scalar>::x() const{
    return _x;
  }
  
  
  template<class Scalar>
  inline Scalar const&
  Vector2D<Scalar>::y() const{
    return _y;
  }
  
  
  template<class Scalar>
  inline Scalar const&
  Vector2D<Scalar>::x(Scalar const& __s){
    _x = __s;
    return x();
  }
  
  
  template<class Scalar>
  inline Scalar const&
  Vector2D<Scalar>::y(Scalar const& __s){
    _y = __s;
    return y();
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::xy(Scalar const& __x, Scalar const& __y){
    _x = __x;
    _y = __y;
    return *this;
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::positive() const{
    return *this;
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::negative() const{
    return Vector2D<Scalar>(-x(), -y());
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::right() const{
    return Vector2D<Scalar>(-y(), x());
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::add(Vector2D const& __v) const{
    return Vector2D<Scalar>(x() + __v.x(), y() + __v.y());
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::sub(Vector2D const& __v) const{
    return Vector2D<Scalar>(x() - __v.x(), y() - __v.y());
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::mul(Scalar const& __s) const{
    return Vector2D<Scalar>(x() * __s, y() * __s);
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::div(Scalar const& __s) const{
    return Vector2D<Scalar>(x() / __s, y() / __s);
  }
  
  
  template<class Scalar>
  inline Scalar
  Vector2D<Scalar>::dot(Vector2D const& __v) const{
    return (x() * __v.x() + y() * __v.y());
  }
  
  
  template<class Scalar>
  inline Scalar
  Vector2D<Scalar>::cross(Vector2D const& __v) const{
    return (x() * __v.y() - y() * __v.x());
  }
  
  
  template<class Scalar>
  inline Scalar
  Vector2D<Scalar>::length() const{
    return Scalar(sqrt(double(length2())));
  }
  
  
  template<class Scalar>
  inline Scalar
  Vector2D<Scalar>::length2() const{
    return squ(x()) + squ(y());
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::normalize(){
    return copy(normalized());
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::normalized() const{
    return div(length());
  }
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::rotate(Scalar const& __theta){
    return copy(rotated(__theta));
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::rotated(Scalar const& __theta) const{
    Scalar cs(cos(-double(__theta)));
    Scalar sn(sin(-double(__theta)));
    Vector2D<Scalar> new_x(cs, sn);
    return Vector2D<Scalar>(new_x.dot(*this), new_x.cross(*this));
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::reflect(Vector2D const& __v){
    return copy(reflected(__v));
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::reflected(Vector2D const& __v) const{
    return __v.mul(__v.dot(*this) * 2 / __v.length2()).sub(*this);
  }
  
  
  template<class Scalar>
  inline Matrix<Scalar>
  Vector2D<Scalar>::matrix() const{
    Matrix<Scalar> ret(2, 0, Scalar(0));
    ret(0, 0) = x();
    ret(1, 0) = y();
    return ret;
  }
  
  
  template<class Scalar>
  inline Matrix<Scalar>
  Vector2D<Scalar>::matrix(Scalar const& __homo) const{
    Matrix<Scalar> ret(3, 0, Scalar(0));
    ret(0, 0) = x();
    ret(1, 0) = y();
    ret(2, 0) = __homo;
    return ret;
  }
  
  
  template<class Scalar>
  inline Scalar const&
  Vector2D<Scalar>::operator()(size_t n) const{
    return (n == 0 ? x() : y());
  }
  
  
  template<class Scalar>
  inline Scalar&
  Vector2D<Scalar>::operator()(size_t n){
    return (n == 0 ? _x : _y);
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::operator()(Scalar const& __x, Scalar const& __y){
    x(__x);
    y(__y);
    return *this;
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::operator+() const{
    return positive();
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::operator-() const{
    return negative();
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::operator~() const{
    return right();
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::operator+(Vector2D const& __v) const{
    return add(__v);
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::operator-(Vector2D const& __v) const{
    return sub(__v);
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::operator*(Scalar const& __s) const{
    return mul(__s);
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>
  Vector2D<Scalar>::operator/(Scalar const& __s) const{
    return div(__s);
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::operator+=(Vector2D const& __v){
    return copy(add(__v));
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::operator-=(Vector2D const& __v){
    return copy(sub(__v));
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::operator*=(Scalar const& __s){
    return copy(mul(__s));
  }
  
  
  template<class Scalar>
  inline Vector2D<Scalar>&
  Vector2D<Scalar>::operator/=(Scalar const& __s){
    return copy(div(__s));
  }
}