Index: intern/itasc/kdl/frameacc.hpp
===================================================================
--- intern/itasc/kdl/frameacc.hpp	(revision 58364)
+++ intern/itasc/kdl/frameacc.hpp	(working copy)
@@ -78,9 +78,9 @@
     IMETHOD friend VectorAcc operator / (const VectorAcc& r2,const doubleAcc& r1);
 
 
-    IMETHOD friend bool Equal(const VectorAcc& r1,const VectorAcc& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const Vector& r1,const VectorAcc& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const VectorAcc& r1,const Vector& r2,double eps=epsilon);
+    IMETHOD friend bool Equal(const VectorAcc& r1,const VectorAcc& r2,double eps);
+    IMETHOD friend bool Equal(const Vector& r1,const VectorAcc& r2,double eps);
+    IMETHOD friend bool Equal(const VectorAcc& r1,const Vector& r2,double eps);
     IMETHOD friend VectorAcc operator - (const VectorAcc& r);
     IMETHOD friend doubleAcc dot(const VectorAcc& lhs,const VectorAcc& rhs);
     IMETHOD friend doubleAcc dot(const VectorAcc& lhs,const Vector& rhs);
@@ -132,9 +132,9 @@
     IMETHOD friend RotationAcc operator* (const RotationAcc& r1,const RotationAcc& r2);
     IMETHOD friend RotationAcc operator* (const Rotation& r1,const RotationAcc& r2);
     IMETHOD friend RotationAcc operator* (const RotationAcc& r1,const Rotation& r2);
-    IMETHOD friend bool Equal(const RotationAcc& r1,const RotationAcc& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const Rotation& r1,const RotationAcc& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const RotationAcc& r1,const Rotation& r2,double eps=epsilon);
+    IMETHOD friend bool Equal(const RotationAcc& r1,const RotationAcc& r2,double eps);
+    IMETHOD friend bool Equal(const Rotation& r1,const RotationAcc& r2,double eps);
+    IMETHOD friend bool Equal(const RotationAcc& r1,const Rotation& r2,double eps);
     IMETHOD TwistAcc Inverse(const TwistAcc& arg) const;
     IMETHOD TwistAcc Inverse(const Twist& arg) const;
     IMETHOD TwistAcc operator * (const TwistAcc& arg) const;
@@ -170,9 +170,9 @@
     IMETHOD friend FrameAcc operator * (const FrameAcc& f1,const FrameAcc& f2);
     IMETHOD friend FrameAcc operator * (const Frame& f1,const FrameAcc& f2);
     IMETHOD friend FrameAcc operator * (const FrameAcc& f1,const Frame& f2);
-    IMETHOD friend bool Equal(const FrameAcc& r1,const FrameAcc& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const Frame& r1,const FrameAcc& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const FrameAcc& r1,const Frame& r2,double eps=epsilon);
+    IMETHOD friend bool Equal(const FrameAcc& r1,const FrameAcc& r2,double eps);
+    IMETHOD friend bool Equal(const Frame& r1,const FrameAcc& r2,double eps);
+    IMETHOD friend bool Equal(const FrameAcc& r1,const Frame& r2,double eps);
 
     IMETHOD TwistAcc  Inverse(const TwistAcc& arg) const;
     IMETHOD TwistAcc  Inverse(const Twist& arg) const;
@@ -226,9 +226,9 @@
      // the new point.
      // Complexity : 6M+6A
 
-     IMETHOD friend bool Equal(const TwistAcc& a,const TwistAcc& b,double eps=epsilon);
-     IMETHOD friend bool Equal(const Twist& a,const TwistAcc& b,double eps=epsilon);
-     IMETHOD friend bool Equal(const TwistAcc& a,const Twist& b,double eps=epsilon);
+     IMETHOD friend bool Equal(const TwistAcc& a,const TwistAcc& b,double eps);
+     IMETHOD friend bool Equal(const Twist& a,const TwistAcc& b,double eps);
+     IMETHOD friend bool Equal(const TwistAcc& a,const Twist& b,double eps);
 
 
      IMETHOD Twist GetTwist() const;
Index: intern/itasc/kdl/frames.cpp
===================================================================
--- intern/itasc/kdl/frames.cpp	(revision 58364)
+++ intern/itasc/kdl/frames.cpp	(working copy)
@@ -99,7 +99,7 @@
 // makes v a unitvector and returns the norm of v.
 // if v is smaller than eps, Vector(1,0,0) is returned with norm 0.
 // if this is not good, check the return value of this method.
-double Vector2::Normalize(double eps) {
+double Vector2::Normalize(double eps=epsilon) {
 	double v = this->Norm();
 	if (v < eps) {
 		*this = Vector2(1,0);
@@ -154,7 +154,7 @@
 }
 
 
-bool Equal(const Rotation& a,const Rotation& b,double eps) {
+bool Equal(const Rotation& a,const Rotation& b,double eps=epsilon) {
     return (Equal(a.data[0],b.data[0],eps) &&
             Equal(a.data[1],b.data[1],eps) &&
             Equal(a.data[2],b.data[2],eps) &&
Index: intern/itasc/kdl/frames.hpp
===================================================================
--- intern/itasc/kdl/frames.hpp	(revision 58364)
+++ intern/itasc/kdl/frames.hpp	(working copy)
@@ -248,10 +248,10 @@
 
      //! do not use operator == because the definition of Equal(.,.) is slightly
      //! different.  It compares whether the 2 arguments are equal in an eps-interval
-     inline friend bool Equal(const Vector& a,const Vector& b,double eps=epsilon);
+     inline friend bool Equal(const Vector& a,const Vector& b,double eps);
 
 	 //! return a normalized vector
-	 inline friend Vector Normalize(const Vector& a, double eps=epsilon);
+     inline friend Vector Normalize(const Vector& a, double eps);
 
 	 //! The literal equality operator==(), also identical.
      inline friend bool operator==(const Vector& a,const Vector& b);
@@ -502,7 +502,7 @@
 
      //! do not use operator == because the definition of Equal(.,.) is slightly
      //! different.  It compares whether the 2 arguments are equal in an eps-interval
-     friend bool Equal(const Rotation& a,const Rotation& b,double eps=epsilon);
+     friend bool Equal(const Rotation& a,const Rotation& b,double eps);
 
 	 //! The literal equality operator==(), also identical.
      friend bool operator==(const Rotation& a,const Rotation& b);
@@ -663,7 +663,7 @@
 
      //! do not use operator == because the definition of Equal(.,.) is slightly
      //! different.  It compares whether the 2 arguments are equal in an eps-interval
-     inline friend bool Equal(const Frame& a,const Frame& b,double eps=epsilon);
+     inline friend bool Equal(const Frame& a,const Frame& b,double eps);
 
 	 //! The literal equality operator==(), also identical.
      inline friend bool operator==(const Frame& a,const Frame& b);
@@ -735,7 +735,7 @@
 
      //! do not use operator == because the definition of Equal(.,.) is slightly
      //! different.  It compares whether the 2 arguments are equal in an eps-interval
-     inline friend bool Equal(const Twist& a,const Twist& b,double eps=epsilon);
+     inline friend bool Equal(const Twist& a,const Twist& b,double eps);
 
 	 //! The literal equality operator==(), also identical.
      inline friend bool operator==(const Twist& a,const Twist& b);
@@ -898,7 +898,7 @@
 
      //! do not use operator == because the definition of Equal(.,.) is slightly
      //! different.  It compares whether the 2 arguments are equal in an eps-interval
-     inline friend bool Equal(const Wrench& a,const Wrench& b,double eps=epsilon);
+     inline friend bool Equal(const Wrench& a,const Wrench& b,double eps);
 
 	 //! The literal equality operator==(), also identical.
      inline friend bool operator==(const Wrench& a,const Wrench& b);
@@ -957,7 +957,7 @@
 	* if v is smaller than eps, Vector(1,0,0) is returned with norm 0.
 	* if this is not good, check the return value of this method.
 	*/
-     double Normalize(double eps=epsilon);
+     double Normalize(double eps);
 
      //!  @return the norm of the vector
      inline double Norm() const;
@@ -979,7 +979,7 @@
 
      //! do not use operator == because the definition of Equal(.,.) is slightly
      //! different.  It compares whether the 2 arguments are equal in an eps-interval
-     inline friend bool Equal(const Vector2& a,const Vector2& b,double eps=epsilon);
+     inline friend bool Equal(const Vector2& a,const Vector2& b,double eps);
 
     friend class Rotation2;
 };
@@ -1026,7 +1026,7 @@
 
      //! do not use operator == because the definition of Equal(.,.) is slightly
      //! different.  It compares whether the 2 arguments are equal in an eps-interval
-     inline friend bool Equal(const Rotation2& a,const Rotation2& b,double eps=epsilon);
+     inline friend bool Equal(const Rotation2& a,const Rotation2& b,double eps);
 };
 
 //! A 2D frame class, for further documentation see the Frames class
@@ -1067,7 +1067,7 @@
         tmp.SetIdentity();
         return tmp;
      }
-     inline friend bool Equal(const Frame2& a,const Frame2& b,double eps=epsilon);
+     inline friend bool Equal(const Frame2& a,const Frame2& b,double eps);
 };
 
 IMETHOD Vector diff(const Vector& a,const Vector& b,double dt=1);
Index: intern/itasc/kdl/frames.inl
===================================================================
--- intern/itasc/kdl/frames.inl	(revision 58364)
+++ intern/itasc/kdl/frames.inl	(working copy)
@@ -167,7 +167,7 @@
     return data[index];
 }
 
-IMETHOD Vector Normalize(const Vector& a, double eps)
+IMETHOD Vector Normalize(const Vector& a, double eps=epsilon)
 {
 	double l=a.Norm();
 	return (l<eps) ? Vector(0.0,0.0,0.0) : a/l;
@@ -1065,38 +1065,38 @@
 
 
 
-IMETHOD bool Equal(const Vector& a,const Vector& b,double eps) {
+IMETHOD bool Equal(const Vector& a,const Vector& b,double eps=epsilon) {
         return (Equal(a.data[0],b.data[0],eps)&&
                 Equal(a.data[1],b.data[1],eps)&&
                 Equal(a.data[2],b.data[2],eps)   );
      }
      
 
-IMETHOD bool Equal(const Frame& a,const Frame& b,double eps) {
+IMETHOD bool Equal(const Frame& a,const Frame& b,double eps=epsilon) {
         return (Equal(a.p,b.p,eps)&&
                 Equal(a.M,b.M,eps)   );
 }
 
-IMETHOD bool Equal(const Wrench& a,const Wrench& b,double eps) {
+IMETHOD bool Equal(const Wrench& a,const Wrench& b,double eps=epsilon) {
         return (Equal(a.force,b.force,eps)&&
                 Equal(a.torque,b.torque,eps)  );
 }
 
-IMETHOD bool Equal(const Twist& a,const Twist& b,double eps) {
+IMETHOD bool Equal(const Twist& a,const Twist& b,double eps=epsilon) {
         return (Equal(a.rot,b.rot,eps)&&
                 Equal(a.vel,b.vel,eps)  );
 }
 
-IMETHOD bool Equal(const Vector2& a,const Vector2& b,double eps) {
+IMETHOD bool Equal(const Vector2& a,const Vector2& b,double eps=epsilon) {
         return (Equal(a.data[0],b.data[0],eps)&&
                 Equal(a.data[1],b.data[1],eps)   );
      }
      
-IMETHOD bool Equal(const Rotation2& a,const Rotation2& b,double eps) {
+IMETHOD bool Equal(const Rotation2& a,const Rotation2& b,double eps=epsilon) {
     return ( Equal(a.c,b.c,eps) && Equal(a.s,b.s,eps) );
 }
 
-IMETHOD bool Equal(const Frame2& a,const Frame2& b,double eps) {
+IMETHOD bool Equal(const Frame2& a,const Frame2& b,double eps=epsilon) {
         return (Equal(a.p,b.p,eps)&&
                 Equal(a.M,b.M,eps)   );
 }
Index: intern/itasc/kdl/framevel.hpp
===================================================================
--- intern/itasc/kdl/framevel.hpp	(revision 58364)
+++ intern/itasc/kdl/framevel.hpp	(working copy)
@@ -110,9 +110,9 @@
     IMETHOD friend void SetToZero(VectorVel& v);
 
 
-    IMETHOD friend bool Equal(const VectorVel& r1,const VectorVel& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const Vector& r1,const VectorVel& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const VectorVel& r1,const Vector& r2,double eps=epsilon);
+    IMETHOD friend bool Equal(const VectorVel& r1,const VectorVel& r2,double eps);
+    IMETHOD friend bool Equal(const Vector& r1,const VectorVel& r2,double eps);
+    IMETHOD friend bool Equal(const VectorVel& r1,const Vector& r2,double eps);
     IMETHOD friend VectorVel operator - (const VectorVel& r);
     IMETHOD friend doubleVel dot(const VectorVel& lhs,const VectorVel& rhs);
     IMETHOD friend doubleVel dot(const VectorVel& lhs,const Vector& rhs);
@@ -166,9 +166,9 @@
     IMETHOD friend RotationVel operator* (const RotationVel& r1,const RotationVel& r2);
     IMETHOD friend RotationVel operator* (const Rotation& r1,const RotationVel& r2);
     IMETHOD friend RotationVel operator* (const RotationVel& r1,const Rotation& r2);
-    IMETHOD friend bool Equal(const RotationVel& r1,const RotationVel& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const Rotation& r1,const RotationVel& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const RotationVel& r1,const Rotation& r2,double eps=epsilon);
+    IMETHOD friend bool Equal(const RotationVel& r1,const RotationVel& r2,double eps);
+    IMETHOD friend bool Equal(const Rotation& r1,const RotationVel& r2,double eps);
+    IMETHOD friend bool Equal(const RotationVel& r1,const Rotation& r2,double eps);
 
     IMETHOD TwistVel Inverse(const TwistVel& arg) const;
     IMETHOD TwistVel Inverse(const Twist& arg) const;
@@ -220,9 +220,9 @@
     IMETHOD friend FrameVel operator * (const FrameVel& f1,const FrameVel& f2);
     IMETHOD friend FrameVel operator * (const Frame& f1,const FrameVel& f2);
     IMETHOD friend FrameVel operator * (const FrameVel& f1,const Frame& f2);
-    IMETHOD friend bool Equal(const FrameVel& r1,const FrameVel& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const Frame& r1,const FrameVel& r2,double eps=epsilon);
-    IMETHOD friend bool Equal(const FrameVel& r1,const Frame& r2,double eps=epsilon);
+    IMETHOD friend bool Equal(const FrameVel& r1,const FrameVel& r2,double eps);
+    IMETHOD friend bool Equal(const Frame& r1,const FrameVel& r2,double eps);
+    IMETHOD friend bool Equal(const FrameVel& r1,const Frame& r2,double eps);
 
     IMETHOD TwistVel  Inverse(const TwistVel& arg) const;
     IMETHOD TwistVel  Inverse(const Twist& arg) const;
@@ -292,9 +292,9 @@
      // = Equality operators
      // do not use operator == because the definition of Equal(.,.) is slightly
      // different.  It compares whether the 2 arguments are equal in an eps-interval
-     IMETHOD friend bool Equal(const TwistVel& a,const TwistVel& b,double eps=epsilon);
-     IMETHOD friend bool Equal(const Twist& a,const TwistVel& b,double eps=epsilon);
-     IMETHOD friend bool Equal(const TwistVel& a,const Twist& b,double eps=epsilon);
+     IMETHOD friend bool Equal(const TwistVel& a,const TwistVel& b,double eps);
+     IMETHOD friend bool Equal(const Twist& a,const TwistVel& b,double eps);
+     IMETHOD friend bool Equal(const TwistVel& a,const Twist& b,double eps);
 
 // = Conversion to other entities
      IMETHOD Twist GetTwist() const;
Index: intern/itasc/kdl/jacobian.cpp
===================================================================
--- intern/itasc/kdl/jacobian.cpp	(revision 58364)
+++ intern/itasc/kdl/jacobian.cpp	(working copy)
@@ -110,15 +110,15 @@
 
     bool Jacobian::operator ==(const Jacobian& arg)
     {
-        return Equal((*this),arg);
+        return Equal((*this),arg, epsilon);
     }
     
     bool Jacobian::operator!=(const Jacobian& arg)
     {
-        return !Equal((*this),arg);
+        return !Equal((*this),arg, epsilon);
     }
     
-    bool Equal(const Jacobian& a,const Jacobian& b,double eps)
+    bool Equal(const Jacobian& a,const Jacobian& b,double eps=epsilon)
     {
         if(a.rows()==b.rows()&&a.columns()==b.columns()){
             bool rc=true;
Index: intern/itasc/kdl/jacobian.hpp
===================================================================
--- intern/itasc/kdl/jacobian.hpp	(revision 58364)
+++ intern/itasc/kdl/jacobian.hpp	(working copy)
@@ -45,7 +45,7 @@
         bool operator ==(const Jacobian& arg);
         bool operator !=(const Jacobian& arg);
         
-        friend bool Equal(const Jacobian& a,const Jacobian& b,double eps=epsilon);
+        friend bool Equal(const Jacobian& a,const Jacobian& b,double eps);
         
 
         ~Jacobian();
Index: intern/itasc/kdl/jntarray.cpp
===================================================================
--- intern/itasc/kdl/jntarray.cpp	(revision 58364)
+++ intern/itasc/kdl/jntarray.cpp	(working copy)
@@ -143,7 +143,7 @@
             array.data[i]=0;
     }
 
-    bool Equal(const JntArray& src1, const JntArray& src2,double eps)
+    bool Equal(const JntArray& src1, const JntArray& src2,double eps=epsilon)
     {
         assert(src1.size==src2.size);
         bool ret = true;
@@ -152,7 +152,7 @@
         return ret;
     }
 
-    bool operator==(const JntArray& src1,const JntArray& src2){return Equal(src1,src2);};
+    bool operator==(const JntArray& src1,const JntArray& src2){return Equal(src1,src2,epsilon);};
     //bool operator!=(const JntArray& src1,const JntArray& src2){return Equal(src1,src2);};
 
 }
Index: intern/itasc/kdl/jntarray.hpp
===================================================================
--- intern/itasc/kdl/jntarray.hpp	(revision 58364)
+++ intern/itasc/kdl/jntarray.hpp	(working copy)
@@ -209,7 +209,7 @@
          * @return true if each element of src1 is within eps of the same
 		 * element in src2, or if both src1 and src2 have no data (ie 0==rows())
          */
-        friend bool Equal(const JntArray& src1,const JntArray& src2,double eps=epsilon);
+        friend bool Equal(const JntArray& src1,const JntArray& src2,double eps);
 
         friend bool operator==(const JntArray& src1,const JntArray& src2);
         //friend bool operator!=(const JntArray& src1,const JntArray& src2);
Index: intern/itasc/kdl/jntarrayacc.hpp
===================================================================
--- intern/itasc/kdl/jntarrayacc.hpp	(revision 58364)
+++ intern/itasc/kdl/jntarrayacc.hpp	(working copy)
@@ -58,7 +58,7 @@
         friend void Divide(const JntArrayAcc& src,const doubleVel& factor,JntArrayAcc& dest);
         friend void Divide(const JntArrayAcc& src,const doubleAcc& factor,JntArrayAcc& dest);
         friend void SetToZero(JntArrayAcc& array);
-        friend bool Equal(const JntArrayAcc& src1,const JntArrayAcc& src2,double eps=epsilon);
+        friend bool Equal(const JntArrayAcc& src1,const JntArrayAcc& src2,double eps);
 
     };
 }
Index: intern/itasc/kdl/jntarrayvel.hpp
===================================================================
--- intern/itasc/kdl/jntarrayvel.hpp	(revision 58364)
+++ intern/itasc/kdl/jntarrayvel.hpp	(working copy)
@@ -51,7 +51,7 @@
         friend void Divide(const JntArrayVel& src,const double& factor,JntArrayVel& dest);
         friend void Divide(const JntArrayVel& src,const doubleVel& factor,JntArrayVel& dest);
         friend void SetToZero(JntArrayVel& array);
-        friend bool Equal(const JntArrayVel& src1,const JntArrayVel& src2,double eps=epsilon);
+        friend bool Equal(const JntArrayVel& src1,const JntArrayVel& src2,double eps);
 
     };
 }