Index: src/Makefile.am
===================================================================
--- src/Makefile.am	(revision 658efbccf150d86344577a2c04b5ed24167f3d03)
+++ src/Makefile.am	(revision ef9df3674aa570dbb84b779f3c1e9026ab21dbeb)
@@ -2,5 +2,7 @@
 HEADER = atom.hpp bond.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp helpers.hpp leastsquaremin.hpp linkedcell.hpp molecules.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp vector.hpp verbose.hpp
 
-bin_PROGRAMS = molecuilder joiner analyzer VectorUnitTest
+noinst_PROGRAMS =  VectorUnitTest
+
+bin_PROGRAMS = molecuilder joiner analyzer
 molecuilderdir = ${bindir}
 molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
Index: src/vector.cpp
===================================================================
--- src/vector.cpp	(revision 658efbccf150d86344577a2c04b5ed24167f3d03)
+++ src/vector.cpp	(revision ef9df3674aa570dbb84b779f3c1e9026ab21dbeb)
@@ -212,6 +212,6 @@
  * \param *PlaneNormal Plane's normal vector
  * \param *PlaneOffset Plane's offset vector
- * \param *LineVector first vector of line
- * \param *LineVector2 second vector of line
+ * \param *Origin first vector of line
+ * \param *LineVector second vector of line
  * \return true -  \a this contains intersection point on return, false - line is parallel to plane
  */
@@ -224,4 +224,5 @@
   Direction.CopyVector(LineVector);
   Direction.SubtractVector(Origin);
+  //*out << Verbose(4) << "INFO: Direction is " << Direction << "." << endl;
   factor = Direction.ScalarProduct(PlaneNormal);
   if (factor < MYEPSILON) { // Uniqueness: line parallel to plane?
@@ -230,9 +231,10 @@
   }
   helper.CopyVector(PlaneOffset);
-  helper.SubtractVector(LineVector);
+  helper.SubtractVector(Origin);
   factor = helper.ScalarProduct(PlaneNormal)/factor;
   //factor = Origin->ScalarProduct(PlaneNormal)*(-PlaneOffset->ScalarProduct(PlaneNormal))/(Direction.ScalarProduct(PlaneNormal));
   Direction.Scale(factor);
-  CopyVector(LineVector);
+  CopyVector(Origin);
+  //*out << Verbose(4) << "INFO: Scaled direction is " << Direction << "." << endl;
   AddVector(&Direction);
 
@@ -241,5 +243,5 @@
   helper.SubtractVector(PlaneOffset);
   if (helper.ScalarProduct(PlaneNormal) < MYEPSILON) {
-    *out << Verbose(2) << "INFO: Intersection at " << *this << " is good." << endl;
+    //*out << Verbose(2) << "INFO: Intersection at " << *this << " is good." << endl;
     return true;
   } else {
@@ -250,5 +252,7 @@
 
 /** Calculates the intersection of the two lines that are both on the same plane.
- * Note that we do not check whether they are on the same plane. Vector is calculated with respecy to second line.
+ * We construct auxiliary plane with its vector normal to one line direction and the PlaneNormal, then a vector
+ * from the first line's offset onto the plane. Finally, scale by factor is 1/cos(angle(line1,line2..)) = 1/SP(...), and
+ * project onto the first line's direction and add its offset.
  * \param *out output stream for debugging
  * \param *Line1a first vector of first line
@@ -261,48 +265,78 @@
 bool Vector::GetIntersectionOfTwoLinesOnPlane(ofstream *out, Vector *Line1a, Vector *Line1b, Vector *Line2a, Vector *Line2b, const Vector *PlaneNormal)
 {
-  double factor1, factor2;
-  Vector helper, Line, LineNormal, *OtherNormal = NULL;
-  const Vector *Normal;
-  bool result = false;
-
-  // create Plane normal vector
-  if (PlaneNormal == NULL) {
-    OtherNormal = new Vector(0.,0.,0.);
-    if (!OtherNormal->MakeNormalVector(Line1a, Line1b, Line2a))
-      if (!OtherNormal->MakeNormalVector(Line1a, Line1b, Line2b)) {
-        *out << Verbose(1) << "ERROR: GetIntersectionOfTwoLinesOnPlane() cannot create a normal of the plane, everything is linear dependent." << endl;
-        return false;
-      }
-    Normal = OtherNormal;
-  } else
-    Normal = PlaneNormal;
-  *out << Verbose(3) << "INFO: Normal of plane is " << *Normal << "." << endl;
-
-  // check if lines are parallel
-  helper.CopyVector(Line2b);
-  helper.SubtractVector(Line2a);
-  if (fabs(helper.ScalarProduct(Normal)) < MYEPSILON) {
-    *out << Verbose(1) << "Lines " << helper << " and " << Line << " are parallel, no cross point!" << endl;
-    result = false;
-  } else {  
-    helper.CopyVector(Line2a);
-    helper.SubtractVector(Line1a);
-    factor1 = helper.ScalarProduct(Normal);
-    helper.CopyVector(Line2b);
-    helper.SubtractVector(Line1a);
-    factor2 = helper.ScalarProduct(Normal);
-    if (fabs(factor2) > MYEPSILON) {
-      CopyVector(Line2a);
-      helper.Scale(factor1/factor2);
-      AddVector(&helper);
+  bool result = true;
+  Vector Direction, OtherDirection;
+  Vector AuxiliaryNormal;
+  Vector Distance;
+  const Vector *Normal = NULL;
+  Vector *ConstructedNormal = NULL;
+  bool FreeNormal = false;
+
+  // construct both direction vectors
+  Zero();
+  Direction.CopyVector(Line1b);
+  Direction.SubtractVector(Line1a);
+  if (Direction.IsZero())
+    return false;
+  OtherDirection.CopyVector(Line2b);
+  OtherDirection.SubtractVector(Line2a);
+  if (OtherDirection.IsZero())
+    return false;
+
+  Direction.Normalize();
+  OtherDirection.Normalize();
+
+  //*out << Verbose(4) << "INFO: Normalized Direction " << Direction << " and OtherDirection " << OtherDirection << "." << endl;
+
+  if (fabs(OtherDirection.ScalarProduct(&Direction) - 1.) < MYEPSILON) { // lines are parallel
+    if ((Line1a == Line2a) || (Line1a == Line2b))
+      CopyVector(Line1a);
+    else if ((Line1b == Line2b) || (Line1b == Line2b))
+        CopyVector(Line1b);
+    else
+      return false;
+    *out << Verbose(4) << "INFO: Intersection is " << *this << "." << endl;
+    return true;
+  } else {
+    // check whether we have a plane normal vector
+    if (PlaneNormal == NULL) {
+      ConstructedNormal = new Vector;
+      ConstructedNormal->MakeNormalVector(&Direction, &OtherDirection);
+      Normal = ConstructedNormal;
+      FreeNormal = true;
+    } else
+      Normal = PlaneNormal;
+
+    AuxiliaryNormal.MakeNormalVector(&OtherDirection, Normal);
+    //*out << Verbose(4) << "INFO: PlaneNormal is " << *Normal << " and AuxiliaryNormal " << AuxiliaryNormal << "." << endl;
+
+    Distance.CopyVector(Line2a);
+    Distance.SubtractVector(Line1a);
+    //*out << Verbose(4) << "INFO: Distance is " << Distance << "." << endl;
+    if (Distance.IsZero()) {
+      // offsets are equal, match found
+      CopyVector(Line1a);
       result = true;
     } else {
-      Zero();
-      result = false;
+      CopyVector(Distance.Projection(&AuxiliaryNormal));
+      //*out << Verbose(4) << "INFO: Projected Distance is " << *this << "." << endl;
+      double factor = Direction.ScalarProduct(&AuxiliaryNormal);
+      //*out << Verbose(4) << "INFO: Scaling factor is " << factor << "." << endl;
+      Scale(1./(factor*factor));
+      //*out << Verbose(4) << "INFO: Scaled Distance is " << *this << "." << endl;
+      CopyVector(Projection(&Direction));
+      //*out << Verbose(4) << "INFO: Distance, projected into Direction, is " << *this << "." << endl;
+      if (this->IsZero())
+        result = false;
+      else
+        result = true;
+      AddVector(Line1a);
     }
-  }
-
-  if (OtherNormal != NULL)
-    delete(OtherNormal);
+
+    if (FreeNormal)
+      delete(ConstructedNormal);
+  }
+  if (result)
+    *out << Verbose(4) << "INFO: Intersection is " << *this << "." << endl;
 
   return result;
@@ -311,9 +345,22 @@
 /** Calculates the projection of a vector onto another \a *y.
  * \param *y array to second vector
- * \return \f$\langle x, y \rangle\f$
- */
-double Vector::Projection(const Vector *y) const
-{
-  return (ScalarProduct(y));
+ */
+void Vector::ProjectIt(const Vector *y)
+{
+  Vector helper(*y);
+  helper.Scale(-(ScalarProduct(y)));
+  AddVector(&helper);
+};
+
+/** Calculates the projection of a vector onto another \a *y.
+ * \param *y array to second vector
+ * \return Vector
+ */
+Vector Vector::Projection(const Vector *y) const
+{
+  Vector helper(*y);
+  helper.Scale((ScalarProduct(y)/y->NormSquared()));
+
+  return helper;
 };
 
@@ -390,4 +437,15 @@
 };
 
+/** Checks whether vector is normal to \a *normal.
+ * @return true - vector is normalized, false - vector is not
+ */
+bool Vector::IsNormalTo(const Vector *normal) const
+{
+  if (ScalarProduct(normal) < MYEPSILON)
+    return true;
+  else
+    return false;
+};
+
 /** Calculates the angle between this and another vector.
  * \param *y array to second vector
@@ -397,5 +455,5 @@
 {
   double norm1 = Norm(), norm2 = y->Norm();
-  double angle = 1;
+  double angle = -1;
   if ((fabs(norm1) > MYEPSILON) && (fabs(norm2) > MYEPSILON))
     angle = this->ScalarProduct(y)/norm1/norm2;
@@ -418,6 +476,5 @@
   // normalise this vector with respect to axis
   a.CopyVector(this);
-  a.Scale(Projection(axis));
-  SubtractVector(&a);
+  a.ProjectOntoPlane(axis);
   // construct normal vector
   y.MakeNormalVector(axis,this);
@@ -430,4 +487,17 @@
   // add part in axis direction
   AddVector(&a);
+};
+
+/** Compares vector \a to vector \a b component-wise.
+ * \param a base vector
+ * \param b vector components to add
+ * \return a == b
+ */
+bool operator==(const Vector& a, const Vector& b)
+{
+  bool status = true;
+  for (int i=0;i<NDIM;i++)
+    status = status && (fabs(a.x[i] - b.x[i]) < MYEPSILON);
+  return status;
 };
 
@@ -703,5 +773,5 @@
   x2.SubtractVector(y2);
   if ((fabs(x1.Norm()) < MYEPSILON) || (fabs(x2.Norm()) < MYEPSILON) || (fabs(x1.Angle(&x2)) < MYEPSILON)) {
-    cout << Verbose(4) << "Given vectors are linear dependent." << endl;
+    cout << Verbose(4) << "WARNING: Given vectors are linear dependent." << endl;
     return false;
   }
@@ -737,5 +807,5 @@
   Zero();
   if ((fabs(x1.Norm()) < MYEPSILON) || (fabs(x2.Norm()) < MYEPSILON) || (fabs(x1.Angle(&x2)) < MYEPSILON)) {
-    cout << Verbose(4) << "Given vectors are linear dependent." << endl;
+    cout << Verbose(4) << "WARNING: Given vectors are linear dependent." << endl;
     return false;
   }
@@ -757,4 +827,5 @@
 /** Calculates orthonormal vector to one given vectors.
  * Just subtracts the projection onto the given vector from this vector.
+ * The removed part of the vector is Vector::Projection()
  * \param *x1 vector
  * \return true - success, false - vector is zero
@@ -763,5 +834,5 @@
 {
   bool result = false;
-  double factor = y1->Projection(this)/y1->Norm()/y1->Norm();
+  double factor = y1->ScalarProduct(this)/y1->NormSquared();
   Vector x1;
   x1.CopyVector(y1);
@@ -820,5 +891,5 @@
 };
 
-/** Determines paramter needed to multiply this vector to obtain intersection point with plane defined by \a *A, \a *B and \a *C.
+/** Determines parameter needed to multiply this vector to obtain intersection point with plane defined by \a *A, \a *B and \a *C.
  * \param *A first plane vector
  * \param *B second plane vector
@@ -833,5 +904,5 @@
 //  cout << "C " << C->Projection(this) << "\t";
 //  cout << endl;
-  return A->Projection(this);
+  return A->ScalarProduct(this);
 };
 
@@ -945,4 +1016,13 @@
   for (int i=NDIM;i--;)
     this->x[i] = y->x[i];
+}
+
+/** Copy vector \a y componentwise.
+ * \param y vector
+ */
+void Vector::CopyVector(const Vector y)
+{
+  for (int i=NDIM;i--;)
+    this->x[i] = y.x[i];
 }
 
Index: src/vector.hpp
===================================================================
--- src/vector.hpp	(revision 658efbccf150d86344577a2c04b5ed24167f3d03)
+++ src/vector.hpp	(revision ef9df3674aa570dbb84b779f3c1e9026ab21dbeb)
@@ -27,5 +27,4 @@
   double PeriodicDistanceSquared(const Vector *y, const double *cell_size) const;
   double ScalarProduct(const Vector *y) const;
-  double Projection(const Vector *y) const;
   double Norm() const;
   double NormSquared() const;
@@ -33,11 +32,15 @@
   bool IsZero() const;
   bool IsOne() const;
+  bool IsNormalTo(const Vector *normal) const;
 
   void AddVector(const Vector *y);
   void SubtractVector(const Vector *y);
   void CopyVector(const Vector *y);
+  void CopyVector(const Vector y);
   void RotateVector(const Vector *y, const double alpha);
   void VectorProduct(const Vector *y);
   void ProjectOntoPlane(const Vector *y);
+  void ProjectIt(const Vector *y);
+  Vector Projection(const Vector *y) const;
   void Zero();
   void One(double one);
@@ -68,4 +71,5 @@
 
 ostream & operator << (ostream& ost, const Vector &m);
+bool operator==(const Vector& a, const Vector& b);
 Vector& operator+=(Vector& a, const Vector& b);
 Vector& operator-=(Vector& a, const Vector& b);
Index: src/vectorunittest.cpp
===================================================================
--- src/vectorunittest.cpp	(revision 658efbccf150d86344577a2c04b5ed24167f3d03)
+++ src/vectorunittest.cpp	(revision ef9df3674aa570dbb84b779f3c1e9026ab21dbeb)
@@ -25,4 +25,9 @@
 void VectorTest::setUp()
 {
+  zero.Init(0.,0.,0.);
+  unit.Init(1.,0.,0.);
+  otherunit.Init(0.,1.,0.);
+  notunit.Init(0.,1.,1.);
+  two.Init(2.,1.,0.);
 };
 
@@ -36,9 +41,4 @@
 void VectorTest::UnityTest()
 {
-  Vector zero(0.,0.,0.);
-  Vector unit(1.,0.,0.);
-  Vector otherunit(1./sqrt(2.),0.,1./sqrt(2.));
-  Vector notunit(0.,1.,1.);
-
   // unity and zero tests
   CPPUNIT_ASSERT_EQUAL( true, zero.IsZero() );
@@ -55,11 +55,6 @@
 void VectorTest::SimpleAlgebraTest()
 {
-  Vector zero(0.,0.,0.);
-  Vector unit(1.,0.,0.);
-  Vector otherunit(0.,1.,0.);
-  Vector notunit(0.,1.,1.);
   Vector helper;
   double factor;
-
   // summation and scaling
   helper.CopyVector(&zero);
@@ -104,10 +99,6 @@
 void VectorTest::OperatorAlgebraTest()
 {
-  Vector zero(0.,0.,0.);
-  Vector unit(1.,0.,0.);
-  Vector otherunit(0.,1.,0.);
-  Vector notunit(0.,1.,1.);
-
   // summation and scaling
+  CPPUNIT_ASSERT_EQUAL( true, (zero+unit).IsOne() );
   CPPUNIT_ASSERT_EQUAL( true, (zero+unit).IsOne() );
   CPPUNIT_ASSERT_EQUAL( true, (zero-unit).IsOne() );
@@ -119,17 +110,14 @@
   CPPUNIT_ASSERT_EQUAL( false, (unit*0.98).IsOne() );
   CPPUNIT_ASSERT_EQUAL( true, (unit*1.).IsOne() );
-};
-
-/** UnitTest for scalar products, norms, distances and angles.
- */
-void VectorTest::EuclidianTest()
-{
-  Vector zero(0.,0.,0.);
-  Vector unit(1.,0.,0.);
-  Vector otherunit(0.,1.,0.);
-  Vector notunit(0.,1.,1.);
-  Vector two(2.,1.,0.);
-
-  // SCP
+
+  CPPUNIT_ASSERT_EQUAL( unit, (zero+unit) );
+  CPPUNIT_ASSERT_EQUAL( Vector(0.,0.,1.), (notunit-otherunit) );
+  CPPUNIT_ASSERT_EQUAL( Vector(-1, 0., 1.), (notunit-unit-otherunit) );
+};
+
+/** UnitTest for scalar products.
+ */
+void VectorTest::EuclidianScalarProductTest()
+{
   CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(&zero) );
   CPPUNIT_ASSERT_EQUAL( 0., zero.ScalarProduct(&unit) );
@@ -143,6 +131,10 @@
   CPPUNIT_ASSERT_EQUAL( 1., two.ScalarProduct(&otherunit) );
   CPPUNIT_ASSERT_EQUAL( 1., two.ScalarProduct(&notunit) );
-
-  // Norms
+}
+
+/** UnitTest for norms.
+ */
+void VectorTest::EuclidianNormTest()
+{
   CPPUNIT_ASSERT_EQUAL( 0., zero.Norm() );
   CPPUNIT_ASSERT_EQUAL( 0., zero.NormSquared() );
@@ -153,6 +145,10 @@
   CPPUNIT_ASSERT_EQUAL( 2., notunit.NormSquared() );
   CPPUNIT_ASSERT_EQUAL( sqrt(2.), notunit.Norm() );
-
-  // distances
+}
+
+/** UnitTest for distances.
+ */
+void VectorTest::EuclidianDistancesTest()
+{
   CPPUNIT_ASSERT_EQUAL( 1., zero.Distance(&unit) );
   CPPUNIT_ASSERT_EQUAL( sqrt(2.), otherunit.Distance(&unit) );
@@ -160,9 +156,64 @@
   CPPUNIT_ASSERT_EQUAL( 1., otherunit.Distance(&notunit) );
   CPPUNIT_ASSERT_EQUAL( sqrt(5.), two.Distance(&notunit) );
-
-  // Angles
+}
+
+/** UnitTest for angles.
+ */
+void VectorTest::EuclidianAnglesTest()
+{
   CPPUNIT_ASSERT_EQUAL( M_PI, zero.Angle(&unit) );
-};
-
+  CPPUNIT_ASSERT_EQUAL( 0., unit.Angle(&unit) );
+  CPPUNIT_ASSERT_EQUAL( true, fabs(M_PI/2. - otherunit.Angle(&unit)) < MYEPSILON );
+  CPPUNIT_ASSERT_EQUAL( true, fabs(M_PI/2. - unit.Angle(&notunit)) < MYEPSILON );
+  CPPUNIT_ASSERT_EQUAL( true, fabs(M_PI/4. - otherunit.Angle(&notunit)) < MYEPSILON );
+};
+
+/** UnitTest for projections.
+ */
+void VectorTest::ProjectionTest()
+{
+  CPPUNIT_ASSERT_EQUAL( zero, zero.Projection(&unit) );
+  CPPUNIT_ASSERT_EQUAL( zero, otherunit.Projection(&unit) );
+  CPPUNIT_ASSERT_EQUAL( Vector(0.4,0.2,0.),  otherunit.Projection(&two) );
+  CPPUNIT_ASSERT_EQUAL( Vector(0.,1.,0.),  two.Projection(&otherunit) );
+};
+
+/** UnitTest for line intersections.
+ */
+void VectorTest::LineIntersectionTest()
+{
+  Vector helper;
+  // plane at (0,0,0) normal to (1,0,0) cuts line from (0,0,0) to (2,1,0) at ???
+  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionWithPlane((ofstream *)&cout, &unit, &zero, &zero, &two) );
+  CPPUNIT_ASSERT_EQUAL( zero, helper );
+
+  // plane at (2,1,0) normal to (0,1,0) cuts line from (1,0,0) to (0,1,1) at ???
+  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionWithPlane((ofstream *)&cout, &otherunit, &two, &unit, &notunit) );
+  CPPUNIT_ASSERT_EQUAL( Vector(0., 1., 1.), helper );
+
+  // four vectors equal to zero
+  CPPUNIT_ASSERT_EQUAL( false, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &zero, &zero, &zero, &zero, NULL) );
+  CPPUNIT_ASSERT_EQUAL( zero, helper );
+
+  // four vectors equal to unit
+  CPPUNIT_ASSERT_EQUAL( false, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &unit, &unit, &unit, NULL) );
+  CPPUNIT_ASSERT_EQUAL( zero, helper );
+
+  // two equal lines
+  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &unit, &two, NULL) );
+  CPPUNIT_ASSERT_EQUAL( unit, helper );
+
+  // line from (1,0,0) to (2,1,0) cuts line from (1,0,0) to (0,1,0) at ???
+  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &unit, &otherunit, NULL) );
+  CPPUNIT_ASSERT_EQUAL( unit, helper );
+
+  // line from (1,0,0) to (0,0,0) cuts line from (0,0,0) to (2,1,0) at ???
+  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &zero, &zero, &two, NULL) );
+  CPPUNIT_ASSERT_EQUAL( zero, helper );
+
+  // line from (1,0,0) to (2,1,0) cuts line from (0,0,0) to (0,1,0) at ???
+  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &zero, &otherunit, NULL) );
+  CPPUNIT_ASSERT_EQUAL( Vector(0., -1., 0.), helper );
+};
 
 /********************************************** Main routine **************************************/
Index: src/vectorunittest.hpp
===================================================================
--- src/vectorunittest.hpp	(revision 658efbccf150d86344577a2c04b5ed24167f3d03)
+++ src/vectorunittest.hpp	(revision ef9df3674aa570dbb84b779f3c1e9026ab21dbeb)
@@ -11,4 +11,5 @@
 #include <cppunit/extensions/HelperMacros.h>
 
+#include "vector.hpp"
 
 /********************************************** Test classes **************************************/
@@ -20,5 +21,10 @@
     CPPUNIT_TEST ( SimpleAlgebraTest );
     CPPUNIT_TEST ( OperatorAlgebraTest );
-    CPPUNIT_TEST ( EuclidianTest );
+    CPPUNIT_TEST ( EuclidianScalarProductTest );
+    CPPUNIT_TEST ( EuclidianNormTest );
+    CPPUNIT_TEST ( EuclidianDistancesTest );
+    CPPUNIT_TEST ( EuclidianAnglesTest );
+    CPPUNIT_TEST ( ProjectionTest );
+    CPPUNIT_TEST ( LineIntersectionTest );
     CPPUNIT_TEST_SUITE_END();
 
@@ -30,5 +36,17 @@
      void OperatorAlgebraTest();
      void SimpleAlgebraTest();
-     void EuclidianTest();
+     void EuclidianScalarProductTest();
+     void EuclidianNormTest();
+     void EuclidianDistancesTest();
+     void EuclidianAnglesTest();
+     void ProjectionTest();
+     void LineIntersectionTest();
+
+private:
+     Vector zero;
+     Vector unit;
+     Vector otherunit;
+     Vector notunit;
+     Vector two;
 };
 
