Vector.h

Go to the documentation of this file.

#ifndef   math_Vector_H__
#define   math_Vector_H__

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

#include <vector>

#include <cmath>

namespace meow {

template<class Scalar>
class Vector {
public:
  typedef typename Matrix<Scalar>::EntryRefK ScalarRefK;
  typedef typename Matrix<Scalar>::EntryRef  ScalarRef ;
private:
  Matrix<Scalar> matrix_;
public:
  Vector() {
  }

  Vector(Vector const& v): matrix_(v.matrix_) {
  }

  Vector(Matrix<Scalar> const& m): matrix_(m.col(0)) {
  }

  Vector(std::vector<Scalar> const& v): matrix_(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_(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> 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 scalar(size_t i) const {
    return matrix_.entry(i, 0);
  }

  Scalar scalar(size_t i, Scalar const& s) {
    matrix_.entry(i, 0, s);
    return scalar(i);
  }

  ScalarRef scalarGet(size_t i) {
    return matrix_.entryGet(i);
  }

  void scalars(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 scalar(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);
  }
};

} // meow

#endif // math_Vector_H__