Changeset e7ea64 for molecuilder/src/vector.cpp

Timestamp:

Apr 15, 2010, 10:54:26 AM (16 years ago)

Author:

Tillmann Crueger <crueger@…>

Children:

32842d8

Parents:

1f591b

Message:

Changed implementation of Vector to forward operations to contained objects

File:

• molecuilder/src/vector.cpp (modified) (35 diffs)

molecuilder/src/vector.cpp

@@ -6 +6 @@
 
 
-#include "defs.hpp"
-#include "gslmatrix.hpp"
-#include "leastsquaremin.hpp"
-#include "memoryallocator.hpp"
-#include "vector.hpp"
-#include "Helpers/fast_functions.hpp"
+#include "SingleVector.hpp"
 #include "Helpers/Assert.hpp"
-#include "Plane.hpp"
-#include "Exceptions/LinearDependenceException.hpp"
-
-#include <gsl/gsl_linalg.h>
-#include <gsl/gsl_matrix.h>
-#include <gsl/gsl_permutation.h>
-#include <gsl/gsl_vector.h>
+
+#include <iostream>
+
+using namespace std;
+
 
 /************************************ Functions for class vector ************************************/
@@ -25 +18 @@
 /** Constructor of class vector.
  */
-Vector::Vector()
-{
-  x[0] = x[1] = x[2] = 0.;
-};
+Vector::Vector() :
+  rep(new SingleVector())
+{};
+
+Vector::Vector(Baseconstructor)  // used by derived objects to construct their bases
+{}
+
+Vector::Vector(Baseconstructor,const Vector* v) :
+  rep(v->clone())
+{}
+
+Vector Vector::VecFromRep(const Vector* v){
+  return Vector(Baseconstructor(),v);
+}
 
 /** Constructor of class vector.
  */
-Vector::Vector(const double x1, const double x2, const double x3)
-{
-  x[0] = x1;
-  x[1] = x2;
-  x[2] = x3;
-};
+Vector::Vector(const double x1, const double x2, const double x3) :
+  rep(new SingleVector(x1,x2,x3))
+{};
 
 /**
  * Copy constructor
  */
-Vector::Vector(const Vector& src)
-{
-  x[0] = src[0];
-  x[1] = src[1];
-  x[2] = src[2];
-}
+Vector::Vector(const Vector& src) :
+  rep(src.rep->clone())
+{}
 
 /**
@@ -53 +50 @@
  */
 Vector& Vector::operator=(const Vector& src){
+  ASSERT(isBaseClass(),"Operator used on Derived Vector object");
   // check for self assignment
   if(&src!=this){
-    x[0] = src[0];
-    x[1] = src[1];
-    x[2] = src[2];
+    rep.reset(src.rep->clone());
   }
   return *this;
@@ -72 +68 @@
 double Vector::DistanceSquared(const Vector &y) const
 {
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += (x[i]-y[i])*(x[i]-y[i]);
-  return (res);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->DistanceSquared(y);
 };
 
@@ -94 +88 @@
 double Vector::PeriodicDistance(const Vector &y, const double * const cell_size) const
 {
-  double res = Distance(y), tmp, matrix[NDIM*NDIM];
-  Vector Shiftedy, TranslationVector;
-  int N[NDIM];
-  matrix[0] = cell_size[0];
-  matrix[1] = cell_size[1];
-  matrix[2] = cell_size[3];
-  matrix[3] = cell_size[1];
-  matrix[4] = cell_size[2];
-  matrix[5] = cell_size[4];
-  matrix[6] = cell_size[3];
-  matrix[7] = cell_size[4];
-  matrix[8] = cell_size[5];
-  // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring cells
-  for (N[0]=-1;N[0]<=1;N[0]++)
-    for (N[1]=-1;N[1]<=1;N[1]++)
-      for (N[2]=-1;N[2]<=1;N[2]++) {
-        // create the translation vector
-        TranslationVector.Zero();
-        for (int i=NDIM;i--;)
-          TranslationVector.x[i] = (double)N[i];
-        TranslationVector.MatrixMultiplication(matrix);
-        // add onto the original vector to compare with
-        Shiftedy = y + TranslationVector;
-        // get distance and compare with minimum so far
-        tmp = Distance(Shiftedy);
-        if (tmp < res) res = tmp;
-      }
-  return (res);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->PeriodicDistance(y,cell_size);
 };
 
@@ -131 +99 @@
 double Vector::PeriodicDistanceSquared(const Vector &y, const double * const cell_size) const
 {
-  double res = DistanceSquared(y), tmp, matrix[NDIM*NDIM];
-  Vector Shiftedy, TranslationVector;
-  int N[NDIM];
-  matrix[0] = cell_size[0];
-  matrix[1] = cell_size[1];
-  matrix[2] = cell_size[3];
-  matrix[3] = cell_size[1];
-  matrix[4] = cell_size[2];
-  matrix[5] = cell_size[4];
-  matrix[6] = cell_size[3];
-  matrix[7] = cell_size[4];
-  matrix[8] = cell_size[5];
-  // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring cells
-  for (N[0]=-1;N[0]<=1;N[0]++)
-    for (N[1]=-1;N[1]<=1;N[1]++)
-      for (N[2]=-1;N[2]<=1;N[2]++) {
-        // create the translation vector
-        TranslationVector.Zero();
-        for (int i=NDIM;i--;)
-          TranslationVector.x[i] = (double)N[i];
-        TranslationVector.MatrixMultiplication(matrix);
-        // add onto the original vector to compare with
-        Shiftedy = y + TranslationVector;
-        // get distance and compare with minimum so far
-        tmp = DistanceSquared(Shiftedy);
-        if (tmp < res) res = tmp;
-      }
-  return (res);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->PeriodicDistanceSquared(y,cell_size);
 };
 
@@ -167 +109 @@
 void Vector::KeepPeriodic(const double * const matrix)
 {
-//  int N[NDIM];
-//  bool flag = false;
-  //vector Shifted, TranslationVector;
-  Vector TestVector;
-//  Log() << Verbose(1) << "Begin of KeepPeriodic." << endl;
-//  Log() << Verbose(2) << "Vector is: ";
-//  Output(out);
-//  Log() << Verbose(0) << endl;
-  TestVector = (*this);
-  TestVector.InverseMatrixMultiplication(matrix);
-  for(int i=NDIM;i--;) { // correct periodically
-    if (TestVector.x[i] < 0) {  // get every coefficient into the interval [0,1)
-      TestVector.x[i] += ceil(TestVector.x[i]);
-    } else {
-      TestVector.x[i] -= floor(TestVector.x[i]);
-    }
-  }
-  TestVector.MatrixMultiplication(matrix);
-  (*this) = TestVector;
-//  Log() << Verbose(2) << "New corrected vector is: ";
-//  Output(out);
-//  Log() << Verbose(0) << endl;
-//  Log() << Verbose(1) << "End of KeepPeriodic." << endl;
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->KeepPeriodic(matrix);
 };
 
@@ -198 +119 @@
 double Vector::ScalarProduct(const Vector &y) const
 {
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += x[i]*y[i];
-  return (res);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->ScalarProduct(y);
 };
 
@@ -213 +132 @@
 void Vector::VectorProduct(const Vector &y)
 {
-  Vector tmp;
-  tmp[0] = x[1]* (y[2]) - x[2]* (y[1]);
-  tmp[1] = x[2]* (y[0]) - x[0]* (y[2]);
-  tmp[2] = x[0]* (y[1]) - x[1]* (y[0]);
-  (*this) = tmp;
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->VectorProduct(y);
 };
 
@@ -227 +143 @@
 void Vector::ProjectOntoPlane(const Vector &y)
 {
-  Vector tmp = y;
-  tmp.Normalize();
-  tmp *= ScalarProduct(tmp);
-  (*this) -= tmp;
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->ProjectOntoPlane(y);
 };
 
@@ -241 +155 @@
 double Vector::DistanceToPlane(const Vector &PlaneNormal, const Vector &PlaneOffset) const
 {
-  // first create part that is orthonormal to PlaneNormal with withdraw
-  Vector temp = (*this) - PlaneOffset;
-  temp.MakeNormalTo(PlaneNormal);
-  temp *= -1.;
-  // then add connecting vector from plane to point
-  temp += (*this);
-  temp -= PlaneOffset;
-  double sign = temp.ScalarProduct(PlaneNormal);
-  if (fabs(sign) > MYEPSILON)
-    sign /= fabs(sign);
-  else
-    sign = 0.;
-
-  return (temp.Norm()*sign);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->DistanceToPlane(PlaneNormal,PlaneOffset);
 };
 
@@ -262 +164 @@
 void Vector::ProjectIt(const Vector &y)
 {
-  Vector helper = y;
-  helper.Scale(-(ScalarProduct(y)));
-  AddVector(helper);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->ProjectIt(y);
 };
 
@@ -273 +174 @@
 Vector Vector::Projection(const Vector &y) const
 {
-  Vector helper = y;
-  helper.Scale((ScalarProduct(y)/y.NormSquared()));
-
-  return helper;
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->Projection(y);
 };
 
@@ -299 +198 @@
 void Vector::Normalize()
 {
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += this->x[i]*this->x[i];
-  if (fabs(res) > MYEPSILON)
-    res = 1./sqrt(res);
-  Scale(&res);
+  double factor = Norm();
+  (*this) *= 1/factor;
 };
 
@@ -311 +206 @@
 void Vector::Zero()
 {
-  for (int i=NDIM;i--;)
-    this->x[i] = 0.;
+  rep.reset(new SingleVector());
 };
 
@@ -319 +213 @@
 void Vector::One(const double one)
 {
-  for (int i=NDIM;i--;)
-    this->x[i] = one;
-};
-
-/** Initialises all components of this vector.
- */
-void Vector::Init(const double x1, const double x2, const double x3)
-{
-  x[0] = x1;
-  x[1] = x2;
-  x[2] = x3;
+  rep.reset(new SingleVector(one,one,one));
 };
 
@@ -337 +221 @@
 bool Vector::IsZero() const
 {
-  return (fabs(x[0])+fabs(x[1])+fabs(x[2]) < MYEPSILON);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->IsZero();
 };
 
@@ -345 +230 @@
 bool Vector::IsOne() const
 {
-  return (fabs(Norm() - 1.) < MYEPSILON);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->IsOne();
 };
 
@@ -353 +239 @@
 bool Vector::IsNormalTo(const Vector &normal) const
 {
-  if (ScalarProduct(normal) < MYEPSILON)
-    return true;
-  else
-    return false;
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->IsNormalTo(normal);
 };
 
@@ -364 +248 @@
 bool Vector::IsEqualTo(const Vector &a) const
 {
-  bool status = true;
-  for (int i=0;i<NDIM;i++) {
-    if (fabs(x[i] - a[i]) > MYEPSILON)
-      status = false;
-  }
-  return status;
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->IsEqualTo(a);
 };
 
@@ -378 +258 @@
 double Vector::Angle(const Vector &y) const
 {
-  double norm1 = Norm(), norm2 = y.Norm();
-  double angle = -1;
-  if ((fabs(norm1) > MYEPSILON) && (fabs(norm2) > MYEPSILON))
-    angle = this->ScalarProduct(y)/norm1/norm2;
-  // -1-MYEPSILON occured due to numerical imprecision, catch ...
-  //Log() << Verbose(2) << "INFO: acos(-1) = " << acos(-1) << ", acos(-1+MYEPSILON) = " << acos(-1+MYEPSILON) << ", acos(-1-MYEPSILON) = " << acos(-1-MYEPSILON) << "." << endl;
-  if (angle < -1)
-    angle = -1;
-  if (angle > 1)
-    angle = 1;
-  return acos(angle);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->Angle(y);
 };
 
 
 double& Vector::operator[](size_t i){
-  ASSERT(i<=NDIM && i>=0,"Vector Index out of Range");
-  return x[i];
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return (*rep)[i];
 }
 
 const double& Vector::operator[](size_t i) const{
-  ASSERT(i<=NDIM && i>=0,"Vector Index out of Range");
-  return x[i];
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return (*rep)[i];
 }
 
@@ -411 +282 @@
 
 double* Vector::get(){
-  return x;
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->get();
 }
 
@@ -421 +293 @@
 bool Vector::operator==(const Vector& b) const
 {
-  bool status = true;
-  for (int i=0;i<NDIM;i++)
-    status = status && (fabs((*this)[i] - b[i]) < MYEPSILON);
-  return status;
+  ASSERT(isBaseClass(),"Operator used on Derived Vector object");
+  return IsEqualTo(b);
 };
 
@@ -467 +337 @@
 Vector const Vector::operator+(const Vector& b) const
 {
+  ASSERT(isBaseClass(),"Operator used on Derived Vector object");
   Vector x = *this;
   x.AddVector(b);
@@ -479 +350 @@
 Vector const Vector::operator-(const Vector& b) const
 {
+  ASSERT(isBaseClass(),"Operator used on Derived Vector object");
   Vector x = *this;
   x.SubtractVector(b);
@@ -520 +392 @@
 };
 
-/** Scales each atom coordinate by an individual \a factor.
- * \param *factor pointer to scaling factor
- */
-void Vector::Scale(const double ** const factor)
-{
-  for (int i=NDIM;i--;)
-    x[i] *= (*factor)[i];
-};
-
-void Vector::Scale(const double * const factor)
-{
-  for (int i=NDIM;i--;)
-    x[i] *= *factor;
-};
+
+void Vector::ScaleAll(const double *factor)
+{
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->ScaleAll(factor);
+};
+
+
 
 void Vector::Scale(const double factor)
 {
-  for (int i=NDIM;i--;)
-    x[i] *= factor;
-};
-
-/** Translate atom by given vector.
- * \param trans[] translation vector.
- */
-void Vector::Translate(const Vector &trans)
-{
-  for (int i=NDIM;i--;)
-    x[i] += trans[i];
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->Scale(factor);
 };
 
@@ -556 +413 @@
 void Vector::WrapPeriodically(const double * const M, const double * const Minv)
 {
-  MatrixMultiplication(Minv);
-  // truncate to [0,1] for each axis
-  for (int i=0;i<NDIM;i++) {
-    x[i] += 0.5;  // set to center of box
-    while (x[i] >= 1.)
-      x[i] -= 1.;
-    while (x[i] < 0.)
-      x[i] += 1.;
-  }
-  MatrixMultiplication(M);
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->WrapPeriodically(M,Minv);
 };
 
@@ -573 +422 @@
 void Vector::MatrixMultiplication(const double * const M)
 {
-  Vector C;
-  // do the matrix multiplication
-  C.x[0] = M[0]*x[0]+M[3]*x[1]+M[6]*x[2];
-  C.x[1] = M[1]*x[0]+M[4]*x[1]+M[7]*x[2];
-  C.x[2] = M[2]*x[0]+M[5]*x[1]+M[8]*x[2];
-  // transfer the result into this
-  for (int i=NDIM;i--;)
-    x[i] = C.x[i];
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->MatrixMultiplication(M);
 };
 
@@ -588 +431 @@
 bool Vector::InverseMatrixMultiplication(const double * const A)
 {
-  Vector C;
-  double B[NDIM*NDIM];
-  double detA = RDET3(A);
-  double detAReci;
-
-  // calculate the inverse B
-  if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
-    detAReci = 1./detA;
-    B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);    // A_11
-    B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);    // A_12
-    B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);    // A_13
-    B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);    // A_21
-    B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);    // A_22
-    B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);    // A_23
-    B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);    // A_31
-    B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
-    B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
-
-    // do the matrix multiplication
-    C.x[0] = B[0]*x[0]+B[3]*x[1]+B[6]*x[2];
-    C.x[1] = B[1]*x[0]+B[4]*x[1]+B[7]*x[2];
-    C.x[2] = B[2]*x[0]+B[5]*x[1]+B[8]*x[2];
-    // transfer the result into this
-    for (int i=NDIM;i--;)
-      x[i] = C.x[i];
-    return true;
-  } else {
-    return false;
-  }
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->InverseMatrixMultiplication(A);
 };
 
@@ -639 +455 @@
 void Vector::Mirror(const Vector &n)
 {
-  double projection;
-  projection = ScalarProduct(n)/n.NormSquared();    // remove constancy from n (keep as logical one)
-  // withdraw projected vector twice from original one
-  for (int i=NDIM;i--;)
-    x[i] -= 2.*projection*n[i];
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->Mirror(n);
 };
 
@@ -655 +468 @@
 bool Vector::MakeNormalTo(const Vector &y1)
 {
-  bool result = false;
-  double factor = y1.ScalarProduct(*this)/y1.NormSquared();
-  Vector x1 = factor * y1 ;
-  SubtractVector(x1);
-  for (int i=NDIM;i--;)
-    result = result || (fabs(x[i]) > MYEPSILON);
-
-  return result;
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->MakeNormalTo(y1);
 };
 
@@ -673 +480 @@
 bool Vector::GetOneNormalVector(const Vector &GivenVector)
 {
-  int Components[NDIM]; // contains indices of non-zero components
-  int Last = 0;   // count the number of non-zero entries in vector
-  int j;  // loop variables
-  double norm;
-
-  for (j=NDIM;j--;)
-    Components[j] = -1;
-  // find two components != 0
-  for (j=0;j<NDIM;j++)
-    if (fabs(GivenVector[j]) > MYEPSILON)
-      Components[Last++] = j;
-
-  switch(Last) {
-    case 3:  // threecomponent system
-    case 2:  // two component system
-      norm = sqrt(1./(GivenVector[Components[1]]*GivenVector[Components[1]]) + 1./(GivenVector[Components[0]]*GivenVector[Components[0]]));
-      x[Components[2]] = 0.;
-      // in skp both remaining parts shall become zero but with opposite sign and third is zero
-      x[Components[1]] = -1./GivenVector[Components[1]] / norm;
-      x[Components[0]] = 1./GivenVector[Components[0]] / norm;
-      return true;
-      break;
-    case 1: // one component system
-      // set sole non-zero component to 0, and one of the other zero component pendants to 1
-      x[(Components[0]+2)%NDIM] = 0.;
-      x[(Components[0]+1)%NDIM] = 1.;
-      x[Components[0]] = 0.;
-      return true;
-      break;
-    default:
-      return false;
-  }
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->GetOneNormalVector(GivenVector);
 };
 
@@ -712 +489 @@
 void Vector::AddVector(const Vector &y)
 {
-  for (int i=NDIM;i--;)
-    this->x[i] += y[i];
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->AddVector(y);
 }
 
@@ -721 +498 @@
 void Vector::SubtractVector(const Vector &y)
 {
-  for (int i=NDIM;i--;)
-    this->x[i] -= y[i];
-}
-
-/** Copy vector \a y componentwise.
- * \param y vector
- */
-void Vector::CopyVector(const Vector &y)
-{
-  // check for self assignment
-  if(&y!=this) {
-    for (int i=NDIM;i--;)
-      this->x[i] = y.x[i];
-  }
-}
-
-// this function is completely unused so it is deactivated until new uses arrive and a new
-// place can be found
-#if 0
-/** Solves a vectorial system consisting of two orthogonal statements and a norm statement.
- * This is linear system of equations to be solved, however of the three given (skp of this vector\
- * with either of the three hast to be zero) only two are linear independent. The third equation
- * is that the vector should be of magnitude 1 (orthonormal). This all leads to a case-based solution
- * where very often it has to be checked whether a certain value is zero or not and thus forked into
- * another case.
- * \param *x1 first vector
- * \param *x2 second vector
- * \param *y third vector
- * \param alpha first angle
- * \param beta second angle
- * \param c norm of final vector
- * \return a vector with \f$\langle x1,x2 \rangle=A\f$, \f$\langle x1,y \rangle = B\f$ and with norm \a c.
- * \bug this is not yet working properly
- */
-bool Vector::SolveSystem(Vector * x1, Vector * x2, Vector * y, const double alpha, const double beta, const double c)
-{
-  double D1,D2,D3,E1,E2,F1,F2,F3,p,q=0., A, B1, B2, C;
-  double ang; // angle on testing
-  double sign[3];
-  int i,j,k;
-  A = cos(alpha) * x1->Norm() * c;
-  B1 = cos(beta + M_PI/2.) * y->Norm() * c;
-  B2 = cos(beta) * x2->Norm() * c;
-  C = c * c;
-  Log() << Verbose(2) << "A " << A << "\tB " << B1 << "\tC " << C << endl;
-  int flag = 0;
-  if (fabs(x1->x[0]) < MYEPSILON) { // check for zero components for the later flipping and back-flipping
-    if (fabs(x1->x[1]) > MYEPSILON) {
-      flag = 1;
-    } else if (fabs(x1->x[2]) > MYEPSILON) {
-       flag = 2;
-    } else {
-      return false;
-    }
-  }
-  switch (flag) {
-    default:
-    case 0:
-      break;
-    case 2:
-      flip(x1->x[0],x1->x[1]);
-      flip(x2->x[0],x2->x[1]);
-      flip(y->x[0],y->x[1]);
-      //flip(x[0],x[1]);
-      flip(x1->x[1],x1->x[2]);
-      flip(x2->x[1],x2->x[2]);
-      flip(y->x[1],y->x[2]);
-      //flip(x[1],x[2]);
-    case 1:
-      flip(x1->x[0],x1->x[1]);
-      flip(x2->x[0],x2->x[1]);
-      flip(y->x[0],y->x[1]);
-      //flip(x[0],x[1]);
-      flip(x1->x[1],x1->x[2]);
-      flip(x2->x[1],x2->x[2]);
-      flip(y->x[1],y->x[2]);
-      //flip(x[1],x[2]);
-      break;
-  }
-  // now comes the case system
-  D1 = -y->x[0]/x1->x[0]*x1->x[1]+y->x[1];
-  D2 = -y->x[0]/x1->x[0]*x1->x[2]+y->x[2];
-  D3 = y->x[0]/x1->x[0]*A-B1;
-  Log() << Verbose(2) << "D1 " << D1 << "\tD2 " << D2 << "\tD3 " << D3 << "\n";
-  if (fabs(D1) < MYEPSILON) {
-    Log() << Verbose(2) << "D1 == 0!\n";
-    if (fabs(D2) > MYEPSILON) {
-      Log() << Verbose(3) << "D2 != 0!\n";
-      x[2] = -D3/D2;
-      E1 = A/x1->x[0] + x1->x[2]/x1->x[0]*D3/D2;
-      E2 = -x1->x[1]/x1->x[0];
-      Log() << Verbose(3) << "E1 " << E1 << "\tE2 " << E2 << "\n";
-      F1 = E1*E1 + 1.;
-      F2 = -E1*E2;
-      F3 = E1*E1 + D3*D3/(D2*D2) - C;
-      Log() << Verbose(3) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
-      if (fabs(F1) < MYEPSILON) {
-        Log() << Verbose(4) << "F1 == 0!\n";
-        Log() << Verbose(4) << "Gleichungssystem linear\n";
-        x[1] = F3/(2.*F2);
-      } else {
-        p = F2/F1;
-        q = p*p - F3/F1;
-        Log() << Verbose(4) << "p " << p << "\tq " << q << endl;
-        if (q < 0) {
-          Log() << Verbose(4) << "q < 0" << endl;
-          return false;
-        }
-        x[1] = p + sqrt(q);
-      }
-      x[0] =  A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
-    } else {
-      Log() << Verbose(2) << "Gleichungssystem unterbestimmt\n";
-      return false;
-    }
-  } else {
-    E1 = A/x1->x[0]+x1->x[1]/x1->x[0]*D3/D1;
-    E2 = x1->x[1]/x1->x[0]*D2/D1 - x1->x[2];
-    Log() << Verbose(2) << "E1 " << E1 << "\tE2 " << E2 << "\n";
-    F1 = E2*E2 + D2*D2/(D1*D1) + 1.;
-    F2 = -(E1*E2 + D2*D3/(D1*D1));
-    F3 = E1*E1 + D3*D3/(D1*D1) - C;
-    Log() << Verbose(2) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
-    if (fabs(F1) < MYEPSILON) {
-      Log() << Verbose(3) << "F1 == 0!\n";
-      Log() << Verbose(3) << "Gleichungssystem linear\n";
-      x[2] = F3/(2.*F2);
-    } else {
-      p = F2/F1;
-      q = p*p - F3/F1;
-      Log() << Verbose(3) << "p " << p << "\tq " << q << endl;
-      if (q < 0) {
-        Log() << Verbose(3) << "q < 0" << endl;
-        return false;
-      }
-      x[2] = p + sqrt(q);
-    }
-    x[1] = (-D2 * x[2] - D3)/D1;
-    x[0] = A/x1->x[0] - x1->x[1]/x1->x[0]*x[1] + x1->x[2]/x1->x[0]*x[2];
-  }
-  switch (flag) { // back-flipping
-    default:
-    case 0:
-      break;
-    case 2:
-      flip(x1->x[0],x1->x[1]);
-      flip(x2->x[0],x2->x[1]);
-      flip(y->x[0],y->x[1]);
-      flip(x[0],x[1]);
-      flip(x1->x[1],x1->x[2]);
-      flip(x2->x[1],x2->x[2]);
-      flip(y->x[1],y->x[2]);
-      flip(x[1],x[2]);
-    case 1:
-      flip(x1->x[0],x1->x[1]);
-      flip(x2->x[0],x2->x[1]);
-      flip(y->x[0],y->x[1]);
-      //flip(x[0],x[1]);
-      flip(x1->x[1],x1->x[2]);
-      flip(x2->x[1],x2->x[2]);
-      flip(y->x[1],y->x[2]);
-      flip(x[1],x[2]);
-      break;
-  }
-  // one z component is only determined by its radius (without sign)
-  // thus check eight possible sign flips and determine by checking angle with second vector
-  for (i=0;i<8;i++) {
-    // set sign vector accordingly
-    for (j=2;j>=0;j--) {
-      k = (i & pot(2,j)) << j;
-      Log() << Verbose(2) << "k " << k << "\tpot(2,j) " << pot(2,j) << endl;
-      sign[j] = (k == 0) ? 1. : -1.;
-    }
-    Log() << Verbose(2) << i << ": sign matrix is " << sign[0] << "\t" << sign[1] << "\t" << sign[2] << "\n";
-    // apply sign matrix
-    for (j=NDIM;j--;)
-      x[j] *= sign[j];
-    // calculate angle and check
-    ang = x2->Angle (this);
-    Log() << Verbose(1) << i << "th angle " << ang << "\tbeta " << cos(beta) << " :\t";
-    if (fabs(ang - cos(beta)) < MYEPSILON) {
-      break;
-    }
-    // unapply sign matrix (is its own inverse)
-    for (j=NDIM;j--;)
-      x[j] *= sign[j];
-  }
-  return true;
-};
-
-#endif
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  rep->SubtractVector(y);
+}
 
 /**
@@ -922 +511 @@
 bool Vector::IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const
 {
-  Vector a = (*this) - offset;
-  a.InverseMatrixMultiplication(parallelepiped);
-  bool isInside = true;
-
-  for (int i=NDIM;i--;)
-    isInside = isInside && ((a.x[i] <= 1) && (a.x[i] >= 0));
-
-  return isInside;
-}
+  ASSERT((rep.get()) && (!rep->isBaseClass()),"Representation stored in vector Object was not of derived type");
+  return rep->IsInParallelepiped(offset, parallelepiped);
+}
+
+bool Vector::isBaseClass() const{
+  return true;
+}
+
+Vector* Vector::clone() const{
+  ASSERT(false, "Cannot clone a base Vector object");
+  return 0;
+}