Vector.h

Go to the documentation of this file.

#ifndef   math_Vector_H__
#define   math_Vector_H__

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

#include <vector>

#include <cmath>

namespace meow {

template<class Scalar>
class Vector {
private:
  Matrix<Scalar> matrix_;
public:
  Vector(){
  }
  
  Vector(Vector const& v) {
    matrix_.copyFrom(v.matrix_);
  }
  
  Vector(Matrix<Scalar> const& m) {
    matrix_.copyFrom(m.col(0));
  }
  
  Vector(Matrix<Scalar> const& m, size_t i) {
    matrix_.copyFrom(m.col(i));
  }
  
  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]);
    }
  }
  
  Vector(size_t d, Scalar const& e) {
    matrix_.reset(d, 1, e);
  }

  ~Vector(){
  }

  Vector& copyFrom(Vector const& v) {
    matrix_.copyFrom(v.matrix_);
    return *this;
  }

  Vector& referenceFrom(Vector const& v) {
    matrix_.referenceFrom(v.matrix_);
    return *this;
  }

  Matrix<Scalar> const& matrix() const {
    return matrix_;
  }

  size_t dimension() const {
    return matrix_.rows();
  }
  
  size_t dimension(size_t d, Scalar const& s) {
    matrix_.rows(d, s);
    return dimension();
  }
  
  bool valid() const {
    return (dimension() > 0);
  }
  
  Scalar entry(size_t i) const {
    return matrix_.entry(i, 0);
  }
  
  Scalar entry(size_t i, Scalar const& s) {
    matrix_.entry(i, 0, s);
    return entry(i);
  }
  
  void entries(size_t i, size_t j, Scalar const& s) {
    for (size_t it = i; it <= j; it++) {
      matrix_.entry(it, 0, s);
    }
  }
  
  Vector subVector(size_t i, size_t j) {
    return Vector(matrix_.subMatrix(i, 0, j, 0));
  }

  Vector positive() const {
    return *this;
  }
  
  Vector negative() const {
    return Vector(matrix_.negative());
  }

  Vector add(Vector const& v) const {
    return Vector(matrix_.add(v.matrix_));
  }
  
  Vector sub(Vector const& v) const {
    return Vector(matrix_.sub(v.matrix_));
  }

  Vector mul(Scalar const& s) const {
    return Vector(matrix_.mul(s));
  }
  
  Vector div(Scalar const& s) const {
    return Vector(matrix_.div(s));
  }

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

  Scalar length() const {
    return Scalar(sqrt((double)length2()));
  }
  
  Scalar length2() const {
    return dot(*this);
  }
  
  Vector normalize() const {
    return div(length());
  }
  
  Vector& normalized() {
    copyFrom(normalize());
    return *this;
  }

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

}

#endif // math_Vector_H__