add compound assignment operators for 2D and 3D vector classes

Kernel_23/doc/Kernel_23/CGAL/Vector_2.h

@@ -79,24 +79,6 @@ introduces a vector `v` initialized to `(x,y)`.
 */ 
 Vector_2(const Kernel::FT &x, const Kernel::FT &y); 
 
-/// @} 
-
-/// \name Operations 
-/// @{
-
-/*!
-Test for equality: two vectors are equal, iff their \f$ x\f$ and \f$ y\f$ 
-coordinates are equal. You can compare a vector with the 
-`NULL_VECTOR`. 
-*/ 
-bool operator==(const Vector_2<Kernel> &w) const; 
-
-/*!
-Test for inequality. You can compare a vector with the 
-`NULL_VECTOR`. 
-*/ 
-bool operator!=(const Vector_2<Kernel> &w) const; 
-
 /// @}
 
 /// \name Coordinate Access
@@ -197,26 +179,39 @@ Vector_2<Kernel> perpendicular(const Orientation &o) const;
 /// \name Operators 
 /// @{
 
-/// \ingroup Kernel_operator_plus
-///@{
+/*!
+Test for equality: two vectors are equal, iff their \f$ x\f$ and \f$ y\f$
+coordinates are equal. You can compare a vector with the
+`NULL_VECTOR`.
+*/
+bool operator==(const Vector_2<Kernel> &w) const;
+
+/*!
+Test for inequality. You can compare a vector with the
+`NULL_VECTOR`.
+*/
+bool operator!=(const Vector_2<Kernel> &w) const;
 
 /*!
 Addition. 
 */ 
 Vector_2<Kernel> operator+(const Vector_2<Kernel> &w) const; 
 
-// @}
+/*!
+Addition.
+*/
+Vector_2<Kernel>& operator+=(const Vector_2<Kernel> &w);
 
 
-/// \ingroup Kernel_operator_minus
-///@{
-
 /*!
 Subtraction. 
 */ 
 Vector_2<Kernel> operator-(const Vector_2<Kernel> &w) const; 
 
-/// @}
+/*!
+Subtraction.
+*/
+Vector_2<Kernel>& operator-=(const Vector_2<Kernel> &w);
 
 /*!
 returns the opposite vector. 
@@ -231,15 +226,25 @@ Kernel::FT operator*(const Vector_2<Kernel> &w) const;
 /*!
 Division by a scalar. 
 */ 
-Vector_2<Kernel> operator/(const Kernel::RT &s) const; 
+Vector_2<Kernel> operator/(const Kernel::RT &s) const;
+
+/*!
+Division by a scalar.
+*/
+Vector_2<Kernel>& operator/=(const Kernel::RT &s);
+
+/*!
+Multiplication by a scalar.
+*/
+Vector_2<Kernel>& operator*=(const Kernel::RT &s);
+
+/// @}
 
 /*!
 returns the squared length of `v`. 
 */ 
 Kernel::FT squared_length() const; 
 
-/// @}
-
 }; /* end Vector_2 */
 
 

Kernel_23/doc/Kernel_23/CGAL/Vector_3.h

@@ -82,24 +82,6 @@ Vector_3(const Kernel::FT &x, const Kernel::FT &y, const Kernel::FT &z);
 
 /// @} 
 
-/// \name Operations 
-/// @{
-
-/*!
-Test for equality: two vectors are equal, iff their \f$ x\f$, \f$ y\f$ 
-and \f$ z\f$ coordinates are equal. You can compare a vector with the 
-`NULL_VECTOR`. 
-*/ 
-bool operator==(const Vector_3<Kernel> &w) const; 
-
-/*!
-Test for inequality. You can compare a vector with the 
-`NULL_VECTOR`. 
-*/ 
-bool operator!=(const Vector_3<Kernel> &w) const; 
-
-/// @}
-
 /// \name Coordinate Access
 /// There are two sets of coordinate access functions, namely to the
 /// homogeneous and to the %Cartesian coordinates. They can be used
@@ -201,25 +183,38 @@ Direction_3<Kernel> direction() const;
 /// \name Operators 
 /// @{
 
-/// \ingroup Kernel_operator_plus
-///@{
+/*!
+Test for equality: two vectors are equal, iff their \f$ x\f$, \f$ y\f$
+and \f$ z\f$ coordinates are equal. You can compare a vector with the
+`NULL_VECTOR`.
+*/
+bool operator==(const Vector_3<Kernel> &w) const;
+
+/*!
+Test for inequality. You can compare a vector with the
+`NULL_VECTOR`.
+*/
+bool operator!=(const Vector_3<Kernel> &w) const;
 
 /*!
 Addition. 
 */ 
 Vector_3<Kernel> operator+(const Vector_3<Kernel> &w) const; 
 
-/// @}
-
-/// \ingroup Kernel_operator_minus
-///@{
+/*!
+Addition.
+*/
+Vector_3<Kernel>& operator+=(const Vector_3<Kernel> &w);
 
 /*!
 Subtraction. 
 */ 
 Vector_3<Kernel> operator-(const Vector_3<Kernel> &w) const; 
 
-/// @}
+/*!
+Subtraction.
+*/
+Vector_3<Kernel>& operator-=(const Vector_3<Kernel> &w);
 
 /*!
 Returns the opposite vector. 
@@ -232,17 +227,27 @@ Division by a scalar.
 Vector_3<Kernel> operator/(const Kernel::RT &s) const; 
 
 /*!
-returns the squared length of `v`. 
-*/ 
-Kernel::FT squared_length() const; 
+Division by a scalar.
+*/
+Vector_3<Kernel>& operator/=(const Kernel::RT &s);
 
 /*!
 returns the scalar product (= inner product) of the two vectors. 
 */ 
 Kernel::FT operator*(const Vector_3<Kernel> &w) const;
 
+/*!
+Multiplication by a scalar.
+*/
+Vector_3<Kernel>& operator*=(const Kernel::FT &s);
+
 /// @}
 
+/*!
+returns the squared length of `v`.
+*/
+Kernel::FT squared_length() const;
+
 }; /* end Vector_3 */
 
 /// \ingroup Kernel_operator_prod

Kernel_23/include/CGAL/Vector_2.h

@@ -175,21 +175,57 @@ public:
     return R().construct_difference_of_vectors_2_object()(*this,v);
   }
 
+  Vector_2& operator-=(const Vector_2& v)
+  {
+    *this = R().construct_difference_of_vectors_2_object()(*this,v);
+    return *this;
+  }
+
   Vector_2 operator+(const Vector_2& v) const
   {
     return R().construct_sum_of_vectors_2_object()(*this,v);
   }
 
+  Vector_2& operator+=(const Vector_2& v)
+  {
+    *this = R().construct_sum_of_vectors_2_object()(*this,v);
+    return *this;
+  }
+
   Vector_2 operator/(const RT& c) const
   {
    return R().construct_divided_vector_2_object()(*this,c);
   }
 
+  Vector_2& operator/=(const RT& c)
+  {
+    *this = R().construct_divided_vector_2_object()(*this,c);
+    return *this;
+  }
+
   Vector_2 operator/(const typename First_if_different<FT,RT>::Type & c) const
   {
    return R().construct_divided_vector_2_object()(*this,c);
   }
 
+  Vector_2& operator/=(const typename First_if_different<FT,RT>::Type & c)
+  {
+    *this = R().construct_divided_vector_2_object()(*this,c);
+    return *this;
+  }
+
+  Vector_2& operator*=(const RT& c)
+  {
+    *this = R().construct_scaled_vector_2_object()(*this,c);
+    return *this;
+  }
+
+  Vector_2& operator*=(const typename First_if_different<FT,RT>::Type & c)
+  {
+    *this = R().construct_scaled_vector_2_object()(*this,c);
+    return *this;
+  }
+
   FT squared_length() const
   {
     return R().compute_squared_length_2_object()(*this);

Kernel_23/include/CGAL/Vector_3.h

@@ -118,21 +118,57 @@ public:
     return R().construct_difference_of_vectors_3_object()(*this,v);
   }
 
+  Vector_3& operator-=(const Vector_3& v)
+  {
+    *this = R().construct_difference_of_vectors_3_object()(*this,v);
+    return *this;
+  }
+
   Vector_3 operator+(const Vector_3& v) const
   {
     return R().construct_sum_of_vectors_3_object()(*this,v);
   }
 
+  Vector_3& operator+=(const Vector_3& v)
+  {
+    *this = R().construct_sum_of_vectors_3_object()(*this,v);
+    return *this;
+  }
+
   Vector_3 operator/(const RT& c) const
   {
    return R().construct_divided_vector_3_object()(*this,c);
   }
 
+  Vector_3& operator/=(const RT& c)
+  {
+    *this = R().construct_divided_vector_3_object()(*this,c);
+    return *this;
+  }
+
   Vector_3 operator/(const typename First_if_different<FT_,RT>::Type & c) const
   {
    return R().construct_divided_vector_3_object()(*this,c);
   }
 
+  Vector_3& operator/=(const typename First_if_different<FT_,RT>::Type & c)
+  {
+    *this = R().construct_divided_vector_3_object()(*this,c);
+    return *this;
+  }
+
+  Vector_3& operator*=(const RT& c)
+  {
+    *this = R().construct_scaled_vector_3_object()(*this,c);
+    return *this;
+  }
+
+  Vector_3& operator*=(const typename First_if_different<FT_,RT>::Type & c)
+  {
+    *this = R().construct_scaled_vector_3_object()(*this,c);
+    return *this;
+  }
+
   typename cpp11::result_of<typename R::Compute_x_3(Vector_3)>::type
   x() const
   {

Kernel_23/test/Kernel_23/include/CGAL/_test_cls_vector_2.h

@@ -160,6 +160,24 @@ _test_cls_vector_2(const R& )
   it2++;
   assert(it == it2);
 
+  // test arithmetic operators
+  CGAL::Vector_2<R> v_1(2, 4);
+  const CGAL::Vector_2<R> v_1_const=v_1;
+  CGAL::Vector_2<R> v_2(1, 2);
+
+  v_1*=FT(2);
+  assert(v_1==v_1_const * FT(2));
+  v_1=v_1_const;
+  v_1/=FT(2);
+  assert(v_1==v_1_const / FT(2));
+  v_1=v_1_const;
+  v_1+=v_2;
+  assert(v_1==v_1_const + v_2);
+  v_1=v_1_const;
+  v_1-=v_2;
+  assert(v_1==v_1_const - v_2);
+
+
  std::cout << "done" << std::endl;
  return true;
 }

Kernel_23/test/Kernel_23/include/CGAL/_test_cls_vector_3.h

@@ -156,6 +156,23 @@ _test_cls_vector_3(const R& )
   it2++;
   assert(it == it2);
 
+  // test arithmetic operators
+  CGAL::Vector_3<R> v_1(2, 4, 6);
+  const CGAL::Vector_3<R> v_1_const=v_1;
+  CGAL::Vector_3<R> v_2(1, 2, 3);
+
+  v_1*=FT(2);
+  assert(v_1==v_1_const * FT(2));
+  v_1=v_1_const;
+  v_1/=FT(2);
+  assert(v_1==v_1_const / FT(2));
+  v_1=v_1_const;
+  v_1+=v_2;
+  assert(v_1==v_1_const + v_2);
+  v_1=v_1_const;
+  v_1-=v_2;
+  assert(v_1==v_1_const - v_2);
+
  std::cout << "done" << std::endl;
  return true;
 }