#ifndef   math_Vector_H__
#define   math_Vector_H__

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

#include <vector>

#include <cmath>

namespace meow {

/*!
 * @brief \b vector
 *
 * @author cat_leopard
 */
template<class Scalar>
class Vector {
private:
  Matrix<Scalar> matrix_;
public:
  /*!
   * @brief constructor
   *
   * With \b dimension=0, which means \b invalid.
   */
  Vector(){
  }
  
  /*!
   * @brief constructor
   *
   * Copy from another vector
   *
   * @param [in] v another vector
   */
  Vector(Vector const& v) {
    matrix_.copyFrom(v.matrix_);
  }
  
  /*!
   * @brief constructor
   *
   * From matrix's first column
   *
   * @param [in] m matrix
   */
  Vector(Matrix<Scalar> const& m) {
    matrix_.copyFrom(m.col(0));
  }
  
  /*!
   * @brief constructor
   *
   * From matrix's \a i-th column
   *
   * @param [in] m matrix
   * @param [in] i i-th
   */
  Vector(Matrix<Scalar> const& m, size_t i) {
    matrix_.copyFrom(m.col(i));
  }
  
  /*!
   * @brief constructor
   *
   * Copy from another std::vector
   *
   * @param [in] v vector
   */
  Vector(std::vector<Scalar> const& v) {
    matrix_.size(v.size(), 1, Scalar(0));
    for (size_t i = 0, I = v.size(); i < I; i++) {
      matrix_.entry(i, 0, v[i]);
    }
  }
  
  /*!
   * @brief constructor
   * 
   * setup dimension and inital value
   *
   * @param [in] d dimension
   * @param [in] e inital value
   */
  Vector(size_t d, Scalar const& e) {
    matrix_.reset(d, 1, e);
  }

  //! @brief destructor
  ~Vector(){
  }

  //! @brief copy from ...
  Vector& copyFrom(Vector const& v) {
    matrix_.copyFrom(v.matrix_);
    return *this;
  }

  //! @brief reference from ...
  Vector& referenceFrom(Vector const& v) {
    matrix_.referenceFrom(v.matrix_);
    return *this;
  }

  //! @brief Return a \a dimension x 1 matrix form of it
  Matrix<Scalar> const& matrix() const {
    return matrix_;
  }

  //! @brief return dimension
  size_t dimension() const {
    return matrix_.rows();
  }
  
  /*!
   * @brief resize the dimension
   *
   * @param [in] d new dimension
   * @param [in] s inital entry
   * @return new dimension
   */
  size_t dimension(size_t d, Scalar const& s) {
    matrix_.rows(d, s);
    return dimension();
  }
  
  /*!
   * @brief Return whether \c dimension>0 is true or not
   * @return \c true/false
   */
  bool valid() const {
    return (dimension() > 0);
  }
  
  //! @brief return \a i -th entry
  Scalar entry(size_t i) const {
    return matrix_.entry(i, 0);
  }
  
  /*!
   * @brief change \a i -th entry
   *
   * @param [in] i i-th
   * @param [in] s new value
   */
  Scalar entry(size_t i, Scalar const& s) {
    matrix_.entry(i, 0, s);
    return entry(i);
  }
  
  /*!
   * @brief change \a i -th to \a j -th entries
   *
   * @param [in] i i-th
   * @param [in] j j-th
   * @param [in] s new value
   */
  void entries(size_t i, size_t j, Scalar const& s) {
    for (size_t it = i; it <= j; it++) {
      matrix_.entry(it, 0, s);
    }
  }
  
  //! @brief subvector form i-th to j-th
  Vector subVector(size_t i, size_t j) {
    return Vector(matrix_.subMatrix(i, 0, j, 0));
  }

  //! @brief return +\a (*this)
  Vector positive() const {
    return *this;
  }
  
  //! @brief return -\a (*this)
  Vector negative() const {
    return Vector(matrix_.negative());
  }

  //! @brief return \a (*this)+v
  Vector add(Vector const& v) const {
    return Vector(matrix_.add(v.matrix_));
  }
  
  //! @brief return \a (*this)-v
  Vector sub(Vector const& v) const {
    return Vector(matrix_.sub(v.matrix_));
  }

  //! @brief return \a (*this)*s , where s is a scalar
  Vector mul(Scalar const& s) const {
    return Vector(matrix_.mul(s));
  }
  
  //! @brief return \a (*this)/s , where s is a scalar
  Vector div(Scalar const& s) const {
    return Vector(matrix_.div(s));
  }

  //! @brief dot
  Scalar dot(Vector const& v) const {
    return matrix_.transpose().mul(v.matrix_).entry(0, 0);
  }

  //! @brief sqrt of \a length2
  Scalar length() const {
    return Scalar(sqrt((double)length2()));
  }
  
  //! @brief same as \a (*this).dot(*this)
  Scalar length2() const {
    return dot(*this);
  }
  
  //! @brief return a normalize form of itself
  Vector normalize() const {
    return div(length());
  }
  
  //! @brief Let itself be normalize form
  Vector& normalized() {
    copyFrom(normalize());
    return *this;
  }

  //! @brief same as copyFrom
  Vector& operator=(Vector const& v) {
    return copyFrom(v);
  }
  
  //! @brief same as entry(i)
  Scalar operator()(size_t i) const {
    return entry(i);
  }
  
  //! @brief same as positive()
  Vector operator+() const {
    return positive();
  }
  
  //! @brief same as negative()
  Vector operator-() const {
    return negative();
  }
  
  //! @brief same as add(v)
  Vector operator+(Vector const& v) const {
    return add(v);
  }
  
  //! @brief same as sub(v)
  Vector operator-(Vector const& v) const {
    return sub(v);
  }
  
  //! @brief same as dot(v)
  Scalar operator*(Vector const& v) const {
    return dot(v);
  }
  
  //! @brief same as mul(s)
  Vector operator*(Scalar const& s) const {
    return mul(s);
  }
  
  //! @brief same as div(s)
  Vector operator/(Scalar const& s) const {
    return div(s);
  }
};

}

#endif // math_Vector_H__