source: molecuilder/src/vector.hpp@ 1f591b

#ifndef VECTOR_HPP_
#define VECTOR_HPP_

using namespace std;

/*********************************************** includes ***********************************/

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_multimin.h>

#include "defs.hpp"

/********************************************** declarations *******************************/

/** Single vector.
 * basically, just a x[3] but with helpful functions
 */
class Vector {
protected:
  // this struct is used to indicate calls to the Baseconstructor from inside vectors.
  struct Baseconstructor{};
  public:

  Vector();
  Vector(const double x1, const double x2, const double x3);
  Vector(const Vector& src);
  virtual ~Vector();

  virtual double Distance(const Vector &y) const;
  virtual double DistanceSquared(const Vector &y) const;
  virtual double DistanceToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const;
  virtual double PeriodicDistance(const Vector &y, const double * const cell_size) const;
  virtual double PeriodicDistanceSquared(const Vector &y, const double * const cell_size) const;
  virtual double ScalarProduct(const Vector &y) const;
  virtual double Norm() const;
  virtual double NormSquared() const;
  virtual double Angle(const Vector &y) const;
  virtual bool IsZero() const;
  virtual bool IsOne() const;
  virtual bool IsNormalTo(const Vector &normal) const;
  virtual bool IsEqualTo(const Vector &a) const;

  virtual void AddVector(const Vector &y);
  virtual void SubtractVector(const Vector &y);
  virtual void CopyVector(const Vector &y);
  virtual void VectorProduct(const Vector &y);
  virtual void ProjectOntoPlane(const Vector &y);
  virtual void ProjectIt(const Vector &y);
  virtual Vector Projection(const Vector &y) const;
  virtual void Zero();
  virtual void One(const double one);
  virtual void Init(const double x1, const double x2, const double x3);
  virtual void Normalize();
  virtual void Translate(const Vector &x);
  virtual void Mirror(const Vector &x);
  virtual void Scale(const double ** const factor);
  virtual void Scale(const double * const factor);
  virtual void Scale(const double factor);
  virtual void MatrixMultiplication(const double * const M);
  virtual bool InverseMatrixMultiplication(const double * const M);
  virtual void KeepPeriodic(const double * const matrix);
  virtual void LinearCombinationOfVectors(const Vector &x1, const Vector &x2, const Vector &x3, const double * const factors);
  virtual bool GetOneNormalVector(const Vector &x1);
  virtual bool MakeNormalTo(const Vector &y1);
  //bool SolveSystem(Vector * x1, Vector * x2, Vector * y, const double alpha, const double beta, const double c);
  virtual bool IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const;
  virtual void WrapPeriodically(const double * const M, const double * const Minv);

  // Accessors ussually come in pairs... and sometimes even more than that
  virtual double& operator[](size_t i);
  virtual const double& operator[](size_t i) const;
  virtual double& at(size_t i);
  virtual const double& at(size_t i) const;

  // Assignment operator
  virtual Vector &operator=(const Vector& src);

  // Access to internal structure
  virtual double* get();

  // operators for mathematical operations
  bool operator==(const Vector& b) const;
  const Vector& operator+=(const Vector& b);
  const Vector& operator-=(const Vector& b);
  Vector const operator+(const Vector& b) const;
  Vector const operator-(const Vector& b) const;

private:
  double x[NDIM];

};

ostream & operator << (ostream& ost, const Vector &m);
const Vector& operator*=(Vector& a, const double m);
Vector const operator*(const Vector& a, const double m);
Vector const operator*(const double m, const Vector& a);

#endif /*VECTOR_HPP_*/