#ifndef SINGLEVECTOR_HPP_
#define SINGLEVECTOR_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 "vector.hpp"

#include "defs.hpp"

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

/** Single vector.
 * basically, just a x[3] but with helpful functions
 */
class SingleVector : public Vector {
public:

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

  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 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();

private:
  double x[NDIM];

};

#endif /*SINGLEVECTOR_HPP_*/