Vectors.h

Go to the documentation of this file.

#ifndef   geo_Vectors_H__
#define   geo_Vectors_H__

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

#include <cmath>

namespace meow{

template<class Scalar>
class Vector2D {
private:
  Scalar x_, y_;
public:
  Vector2D(): x_(0), y_(0) {
  }

  Vector2D(Vector2D const& v): x_(v.x_), y_(v.y_) {
  }

  Vector2D(Scalar const& s): x_(s), y_(s) {
  }

  Vector2D(Scalar const& sx, Scalar const& sy): x_(sx), y_(sy) {
  }

  Vector2D(Vector<Scalar> const& v): x_(v(0)), y_(v(1)) {
  }

  Vector2D(Vector<Scalar> const& v, size_t i): x_(v(i)), y_(v(i + 1)) {
  }

  ~Vector2D() {
  }

  Vector2D& copyFrom(Vector2D const& v) {
    return xy(v.x(), v.y());
  }

  Scalar const& x() const {
    return x_;
  }

  Scalar& xGet() {
    return x_;
  }

  Scalar& yGet() {
    return y_;
  }

  Scalar const& y() const {
    return y_;
  }

  Scalar const& x(Scalar const& s) {
    x_ = s;
    return x();
  }

  Scalar const& y(Scalar const& s) {
    y_ = s;
    return y();
  }

  Vector2D& xy(Scalar const& sx, Scalar const& sy){
    x(sx);
    y(sy);
    return *this;
  }

  Vector2D positive() const {
    return *this;
  }

  Vector2D negative() const {
    return Vector2D(-x(), -y());
  }

  Vector2D right()const{
    return Vector2D(-y(), x());
  }

  Vector2D add(Vector2D const& v) const {
    return Vector2D(x() + v.x(), y() + v.y());
  }

  Vector2D& added(Vector2D const& v) {
    return xy(x() + v.x(), y() + v.y());
  }

  Vector2D sub(Vector2D const& v) const {
    return Vector2D(x() - v.x(), y() - v.y());
  }

  Vector2D& subed(Vector2D const& v) {
    return xy(x() - v.x(), y() - v.y());
  }

  Vector2D mul(Scalar const& s) const {
    return Vector2D(x() * s, y() * s);
  }

  Vector2D& muled(Scalar const& s) {
    return xy(x() * s, y() * s);
  }

  Vector2D div(Scalar const& s) const {
    return Vector2D(x() / s, y() / s);
  }

  Vector2D& dived(Scalar const& s) {
    return xy(x() / s, y() / s);
  }

  Scalar mul(Vector2D const& v) const {
    return dot(v);
  }

  Scalar dot(Vector2D const& v) const {
    return x() * v.x() + y() * v.y();
  }

  Scalar cross(Vector2D const& v) const {
    return x() * v.y() - y() * v.x();
  }

  Scalar length() const {
    return Scalar(sqrt(double(length2())));
  }

  Scalar length2() const {
    return dot(*this);
  }

  Vector2D normalize() const {
    return div(length());
  }

  Vector2D& normalized() {
    return dived(length());
  }

  Vector2D rotate(Scalar const& theta) const {
    Scalar cs(cos(-double(theta)));
    Scalar sn(sin(-double(theta)));
    Vector2D<Scalar> new_x(cs, sn);
    return Vector2D(new_x.dot(*this), new_x.cross(*this));
  }

  Vector2D& rotated(Scalar const& theta) {
    return copyFrom(rotate(theta));
  }

  Vector2D reflect(Vector2D const& v) const {
    return v.mul(v.dot(*this) * 2 / v.length2()).sub(*this);
  }

  Vector2D& reflected(Vector2D const& v) {
    return copyFrom(reflecte(v));
  }

  Matrix<Scalar> matrix() const {
    static Matrix<Scalar> ret(2, 1, Scalar(0));
    ret(0, 0, x());
    ret(1, 0, y());
    return ret;
  }

  Matrix<Scalar> matrix(Scalar const& homo) const {
    static Matrix<Scalar> ret(3, 1, Scalar(0));
    ret(0, 0, x());
    ret(1, 0, y());
    ret(2, 0, homo);
    return ret;
  }

  Scalar const& operator()(size_t n) const {
    return (n == 0 ? x() : y());
  }

  Vector2D& operator()(Scalar const& sx, Scalar const& sy) {
    return xy(sx, sy);
  }

  Vector2D operator+() const { return positive(); }
  Vector2D operator-() const { return negative(); }
  Vector2D operator~() const { return right   (); }

  Vector2D operator+(Vector2D const& v) const { return add(v); }
  Vector2D operator-(Vector2D const& v) const { return sub(v); }
  Vector2D operator*(Scalar   const& s) const { return mul(s); }
  Vector2D operator/(Scalar   const& s) const { return div(s); }
  Scalar   operator*(Vector2D const& v) const { return mul(v); }

  Vector2D& operator=(Vector2D const& v) { return copyFrom(v); }
  Vector2D& operator+=(Vector2D const& v) { return added(v); }
  Vector2D& operator-=(Vector2D const& v) { return subed(v); }
  Vector2D& operator*=(Scalar   const& s) { return muled(s); }
  Vector2D& operator/=(Scalar   const& s) { return dived(s); }
};

template<class Scalar>
class Vector3D{
private:
  Scalar x_, y_, z_;
public:
  Vector3D(): x_(0), y_(0), z_(0) {
  }

  Vector3D(Vector3D const& v): x_(v.x_), y_(v.y_), z_(v.z_) {
  }

  Vector3D(Scalar const& s): x_(s), y_(s), z_(s) {
  }

  Vector3D(Scalar const& sx,
           Scalar const& sy,
           Scalar const& sz): x_(sx), y_(sy), z_(sz) {
  }

  Vector3D(Vector<Scalar> const& v): x_(v(0)), y_(v(1)), z_(v(2)) {
  }

  Vector3D(Vector<Scalar> const& v, size_t i): x_(v(i)), y_(v(i+1)), z_(v(i+2)){
  }

  ~Vector3D(){
  }

  Vector3D& copyFrom(Vector3D const& v){
    return xyz(v.x(), v.y(), v.z());
  }

  Scalar const& x() const{
    return x_;
  }

  Scalar const& y() const{
    return y_;
  }

  Scalar const& z() const{
    return z_;
  }

  Scalar& xGet() {
    return x_;
  }

  Scalar& yGet() {
    return y_;
  }

  Scalar& zGet() {
    return z_;
  }

  Scalar const& x(Scalar const& s) {
    x_ = s;
    return x();
  }

  Scalar const& y(Scalar const& s) {
    y_ = s;
    return y();
  }

  Scalar const& z(Scalar const& s) {
    z_ = s;
    return z();
  }

  Vector3D& xyz(Scalar const& sx, Scalar const& sy, Scalar const& sz) {
    x(sx);
    y(sy);
    z(sz);
    return *this;
  }

  Vector3D positive() const {
    return *this;
  }

  Vector3D negative() const {
    return Vector3D(-x(), -y(), -z());
  }

  Vector3D add(Vector3D const& v) const {
    return Vector3D(x() + v.x(), y() + v.y(), z() + v.z());
  }

  Vector3D& added(Vector3D const& v) {
    return xyz(x() + v.x(), y() + v.y(), z() + v.z());
  }

  Vector3D sub(Vector3D const& v) const {
    return Vector3D(x() - v.x(), y() - v.y(), z() - v.z());
  }

  Vector3D& subed(Vector3D const& v) {
    return xyz(x() - v.x(), y() - v.y(), z() - v.z());
  }

  Vector3D mul(Scalar const& s) const {
    return Vector3D(x() * s, y() * s, z() * s);
  }

  Vector3D& muled(Scalar const& s) {
    return xyz(x() * s, y() * s, z() * s);
  }

  Vector3D div(Scalar const& s) const {
    return Vector3D(x() / s, y() / s, z() / s);
  }

  Vector3D& dived(Scalar const& s) {
    return xyz(x() / s, y() / s, z() / s);
  }

  Scalar mul(Vector3D const& v) const {
    return dot(v);
  }

  Scalar dot(Vector3D const& v) const {
    return x() * v.x() + y() * v.y() + z() * v.z();
  }

  Vector3D cross(Vector3D const& v) const {
    return Vector3D(y() * v.z() - z() * v.y(),
                    z() * v.x() - x() * v.z(),
                    x() * v.y() - y() * v.x());
  }

  Vector3D& crossed(Vector3D const& v) {
    return copyFrom(cross(v));
  }

  Scalar length() const {
    return Scalar(sqrt(double(length2())));
  }

  Scalar length2() const {
    return dot(*this);
  }

  Vector3D normalize() const {
    return div(length());
  }

  Vector3D& normalized() {
    return dived(length());
  }

  Vector3D rotate(Vector3D const& axis, double theta) const {
    Vector3D a(axis.normalize());
    Vector3D xx(sub(a)        .mul(cos(theta)));
    Vector3D yy(a.cross(*this).mul(sin(theta)));
    return a.mul(a.dot(*this)).add(xx).add(yy);
  }

  Vector3D& rotated(Vector3D const& axis, double theta) {
    return copyFrom(rotate(axis, theta));
  }

  Vector3D reflect(Vector3D const& v) const {
    return v.mul(v.dot(*this) * 2 / v.length2()).sub(*this);
  }

  Vector3D& reflected(Vector3D const& v) {
    return copyFrom(reflecte(v));
  }

  Matrix<Scalar> matrix() const {
    static Matrix<Scalar> ret(3, 1, Scalar(0));
    ret(0, 0, x());
    ret(1, 0, y());
    ret(2, 0, z());
    return ret;
  }

  Matrix<Scalar> matrix(Scalar const& homo) const {
    static Matrix<Scalar> ret(4, 1, Scalar(0));
    ret(0, 0, x());
    ret(1, 0, y());
    ret(2, 0, z());
    ret(3, 0, homo);
    return ret;
  }

  Scalar const& operator()(size_t n) const {
    return (n == 0 ? x() : (n == 1 ? y() : z()));
  }

  Vector3D& operator()(Scalar const& sx, Scalar const& sy, Scalar const& sz) {
    return xyz(sx, sy, sz);
  }

  Vector3D operator+() const { return positive(); }
  Vector3D operator-() const { return negative(); }

  Vector3D operator+(Vector3D const& v) const { return add(v); }
  Vector3D operator-(Vector3D const& v) const { return sub(v); }
  Vector3D operator*(Scalar   const& s) const { return mul(s); }
  Vector3D operator/(Scalar   const& s) const { return div(s); }
  Scalar   operator*(Vector3D const& v) const { return mul(v); }

  Vector3D& operator=(Vector3D const& v) { return copyFrom(v); }
  Vector3D& operator+=(Vector3D const& v) { return added(v); }
  Vector3D& operator-=(Vector3D const& v) { return subed(v); }
  Vector3D& operator*=(Scalar   const& s) { return muled(s); }
  Vector3D& operator/=(Scalar   const& s) { return dived(s); }
};

}

#endif // geo_Vectors_H__