Index: src/Actions/WorldAction/RepeatBoxAction.cpp
===================================================================
--- src/Actions/WorldAction/RepeatBoxAction.cpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/Actions/WorldAction/RepeatBoxAction.cpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -99,5 +99,5 @@
                 DoeLog(1) && (eLog()<< Verbose(1) << "AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl);
               x = y;
-              x.MatrixMultiplication(M);
+              x *= M;
               newmol = World::getInstance().createMolecule();
               molecules->insert(newmol);
Index: src/analysis_correlation.cpp
===================================================================
--- src/analysis_correlation.cpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/analysis_correlation.cpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -142,12 +142,10 @@
       for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
-        periodicX = *(*iter)->node;
-        periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+        periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
         // go through every range in xyz and get distance
         for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
           for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
             for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
-              checkX = Vector(n[0], n[1], n[2]) + periodicX;
-              checkX.MatrixMultiplication(FullMatrix);
+              checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
               for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
                 if ((*MolOtherWalker)->ActiveFlag) {
@@ -158,12 +156,10 @@
                       for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
                         if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
-                          periodicOtherX = *(*runner)->node;
-                          periodicOtherX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+                          periodicOtherX = FullInverseMatrix * (*(*runner)->node); // x now in [0,1)^3
                           // go through every range in xyz and get distance
                           for (Othern[0]=-ranges[0]; Othern[0] <= ranges[0]; Othern[0]++)
                             for (Othern[1]=-ranges[1]; Othern[1] <= ranges[1]; Othern[1]++)
                               for (Othern[2]=-ranges[2]; Othern[2] <= ranges[2]; Othern[2]++) {
-                                checkOtherX = Vector(Othern[0], Othern[1], Othern[2]) + periodicOtherX;
-                                checkOtherX.MatrixMultiplication(FullMatrix);
+                                checkOtherX = FullMatrix * (Vector(Othern[0], Othern[1], Othern[2]) + periodicOtherX);
                                 distance = checkX.distance(checkOtherX);
                                 //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
@@ -252,12 +248,10 @@
         for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
           if ((*type == NULL) || ((*iter)->type == *type)) {
-            periodicX = *(*iter)->node;
-            periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+            periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
             // go through every range in xyz and get distance
             for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
               for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
                 for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
-                  checkX = Vector(n[0], n[1], n[2]) + periodicX;
-                  checkX.MatrixMultiplication(FullMatrix);
+                  checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
                   distance = checkX.distance(*point);
                   DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
@@ -356,6 +350,5 @@
         for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
           if ((*type == NULL) || ((*iter)->type == *type)) {
-            periodicX = *(*iter)->node;
-            periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+            periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
             // go through every range in xyz and get distance
             ShortestDistance = -1.;
@@ -363,6 +356,5 @@
               for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
                 for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
-                  checkX = Vector(n[0], n[1], n[2]) + periodicX;
-                  checkX.MatrixMultiplication(FullMatrix);
+                  checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
                   TriangleIntersectionList Intersections(&checkX,Surface,LC);
                   distance = Intersections.GetSmallestDistance();
Index: src/boundary.cpp
===================================================================
--- src/boundary.cpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/boundary.cpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -800,6 +800,5 @@
 
   // calculate filler grid in [0,1]^3
-  FillerDistance = Vector(distance[0], distance[1], distance[2]);
-  FillerDistance.MatrixMultiplication(MInverse);
+  FillerDistance = MInverse * Vector(distance[0], distance[1], distance[2]);
   for(int i=0;i<NDIM;i++)
     N[i] = (int) ceil(1./FillerDistance[i]);
@@ -814,6 +813,5 @@
       for (n[2] = 0; n[2] < N[2]; n[2]++) {
         // calculate position of current grid vector in untransformed box
-        CurrentPosition = Vector((double)n[0]/(double)N[0], (double)n[1]/(double)N[1], (double)n[2]/(double)N[2]);
-        CurrentPosition.MatrixMultiplication(M);
+        CurrentPosition = M * Vector((double)n[0]/(double)N[0], (double)n[1]/(double)N[1], (double)n[2]/(double)N[2]);
         // create molecule random translation vector ...
         for (int i=0;i<NDIM;i++)
@@ -850,13 +848,13 @@
           Inserter = (*iter)->x;
           if (DoRandomRotation)
-            Inserter.MatrixMultiplication(Rotations);
+            Inserter *= Rotations;
           Inserter += AtomTranslations + FillerTranslations + CurrentPosition;
 
           // check whether inserter is inside box
-          Inserter.MatrixMultiplication(MInverse);
+          Inserter *= MInverse;
           FillIt = true;
           for (int i=0;i<NDIM;i++)
             FillIt = FillIt && (Inserter[i] >= -MYEPSILON) && ((Inserter[i]-1.) <= MYEPSILON);
-          Inserter.MatrixMultiplication(M);
+          Inserter *= M;
 
           // Check whether point is in- or outside
Index: src/ellipsoid.cpp
===================================================================
--- src/ellipsoid.cpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/ellipsoid.cpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -61,5 +61,5 @@
   Matrix.set(1,2, sin(theta)*cos(phi));
   Matrix.set(2,2, cos(theta));
-  helper.MatrixMultiplication(Matrix);
+  helper *= Matrix;
   helper.ScaleAll(InverseLength);
   //Log() << Verbose(4) << "Transformed RefPoint is at " << helper << "." << endl;
@@ -83,5 +83,5 @@
   Matrix.set(1,2, sin(theta)*cos(phi));
   Matrix.set(2,2, cos(theta));
-  helper.MatrixMultiplication(Matrix);
+  helper *= Matrix;
   //Log() << Verbose(4) << "Intersection is at " << helper << "." << endl;
 
Index: src/molecule.cpp
===================================================================
--- src/molecule.cpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/molecule.cpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -309,5 +309,5 @@
     }
     matrix = ReturnFullMatrixforSymmetric(cell_size);
-    Orthovector1.MatrixMultiplication(matrix);
+    Orthovector1 *= matrix;
     InBondvector -= Orthovector1; // subtract just the additional translation
     bondlength = InBondvector.Norm();
Index: src/molecule_fragmentation.cpp
===================================================================
--- src/molecule_fragmentation.cpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/molecule_fragmentation.cpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -1750,5 +1750,5 @@
           Translationvector[i] = (tmp < 0) ? +1. : -1.;
       }
-      Translationvector.MatrixMultiplication(matrix);
+      Translationvector *= matrix;
       //Log() << Verbose(3) << "Translation vector is ";
       Log() << Verbose(0) << Translationvector <<  endl;
Index: src/molecule_geometry.cpp
===================================================================
--- src/molecule_geometry.cpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/molecule_geometry.cpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -156,5 +156,5 @@
   const double *cell_size = World::getInstance().getDomain();
   Matrix M = ReturnFullMatrixforSymmetric(cell_size);
-  a->MatrixMultiplication(M);
+  (*a) *= M;
 
   return a;
@@ -287,6 +287,5 @@
       if ((*iter)->type->Z != 1) {
 #endif
-        Testvector = (*iter)->x;
-        Testvector.MatrixMultiplication(inversematrix);
+        Testvector = inversematrix * (*iter)->x;
         Translationvector.Zero();
         for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
@@ -305,5 +304,5 @@
         }
         Testvector += Translationvector;
-        Testvector.MatrixMultiplication(matrix);
+        Testvector *= matrix;
         Center += Testvector;
         Log() << Verbose(1) << "vector is: " << Testvector << endl;
@@ -312,8 +311,7 @@
         for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
           if ((*Runner)->GetOtherAtom((*iter))->type->Z == 1) {
-            Testvector = (*Runner)->GetOtherAtom((*iter))->x;
-            Testvector.MatrixMultiplication(inversematrix);
+            Testvector = inversematrix * (*Runner)->GetOtherAtom((*iter))->x;
             Testvector += Translationvector;
-            Testvector.MatrixMultiplication(matrix);
+            Testvector *= matrix;
             Center += Testvector;
             Log() << Verbose(1) << "Hydrogen vector is: " << Testvector << endl;
@@ -386,5 +384,7 @@
     // the eigenvectors specify the transformation matrix
     Matrix M = Matrix(evec->data);
-    ActOnAllVectors( &Vector::MatrixMultiplication, static_cast<const Matrix>(M));
+    BOOST_FOREACH(atom* iter, atoms){
+      (*iter->node) *= M;
+    }
     DoLog(0) && (Log() << Verbose(0) << "done." << endl);
 
Index: src/vector.cpp
===================================================================
--- src/vector.cpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/vector.cpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -125,8 +125,5 @@
         for (N[2]=-1;N[2]<=1;N[2]++) {
           // create the translation vector
-          TranslationVector.Zero();
-          for (int i=NDIM;i--;)
-            TranslationVector[i] = (double)N[i];
-          TranslationVector.MatrixMultiplication(matrix);
+          TranslationVector = matrix * Vector(N[0],N[1],N[2]);
           // add onto the original vector to compare with
           Shiftedy = y + TranslationVector;
@@ -470,5 +467,5 @@
 void Vector::WrapPeriodically(const Matrix &M, const Matrix &Minv)
 {
-  MatrixMultiplication(Minv);
+  *this *= Minv;
   // truncate to [0,1] for each axis
   for (int i=0;i<NDIM;i++) {
@@ -479,5 +476,5 @@
       at(i) += 1.;
   }
-  MatrixMultiplication(M);
+  *this *= M;
 };
 
@@ -498,12 +495,4 @@
   return make_pair(res,helper);
 }
-
-/** Do a matrix multiplication.
- * \param *matrix NDIM_NDIM array
- */
-void Vector::MatrixMultiplication(const Matrix &M)
-{
-  (*this) *= M;
-};
 
 /** Creates this vector as the b y *factors' components scaled linear combination of the given three.
@@ -615,7 +604,6 @@
 bool Vector::IsInParallelepiped(const Vector &offset, const double * const _parallelepiped) const
 {
-  Vector a = (*this)-offset;
   Matrix parallelepiped = Matrix(_parallelepiped).invert();
-  a.MatrixMultiplication(parallelepiped);
+  Vector a = parallelepiped * ((*this)-offset);
   bool isInside = true;
 
Index: src/vector.hpp
===================================================================
--- src/vector.hpp	(revision 4d206f76b42ca48e260cc39a9dcdaecaff8ec863)
+++ src/vector.hpp	(revision 5108e1ee1cf9c498299f8b2bf556d3a3275459c6)
@@ -60,5 +60,4 @@
   void ScaleAll(const double *factor);
   void Scale(const double factor);
-  void MatrixMultiplication(const Matrix &M);
   bool GetOneNormalVector(const Vector &x1);
   bool MakeNormalTo(const Vector &y1);
