Updated the += and -= operators to be a little more flexible.

--HG--
extra : convert_revision : svn%3Afdd8eb12-d10e-0410-9acb-85c331704f74/trunk%403563

dlib/matrix/matrix.h

@@ -1387,28 +1387,26 @@ namespace dlib
             // m's dimensions don't match that of *this. 
             COMPILE_TIME_ASSERT(EXP::NR == NR || NR == 0 || EXP::NR == 0);
             COMPILE_TIME_ASSERT(EXP::NC == NC || NC == 0 || EXP::NC == 0);
-            DLIB_ASSERT(this->nr() == m.nr() && this->nc() == m.nc(), 
-                "\tmatrix& matrix::operator+=(const matrix_exp& m)"
-                << "\n\tYou are trying to add a dynamically sized matrix to a statically sized matrix with the wrong size"
-                << "\n\tthis->nr(): " << nr()
-                << "\n\tthis->nc(): " << nc()
-                << "\n\tm.nr():     " << m.nr()
-                << "\n\tm.nc():     " << m.nc()
-                << "\n\tthis:       " << this
-                );
             COMPILE_TIME_ASSERT((is_same_type<typename EXP::type,type>::value == true));
-            if (m.destructively_aliases(*this) == false)
+            if (nr() == m.nr() && nc() == m.nc())
             {
-                matrix_assign(*this, *this + m);
+                if (m.destructively_aliases(*this) == false)
+                {
+                    matrix_assign(*this, *this + m);
+                }
+                else
+                {
+                    // we have to use a temporary matrix object here because
+                    // this->data is aliased inside the matrix_exp m somewhere.
+                    matrix temp;
+                    temp.set_size(m.nr(),m.nc());
+                    matrix_assign(temp, *this + m);
+                    temp.swap(*this);
+                }
             }
             else
             {
-                // we have to use a temporary matrix object here because
-                // this->data is aliased inside the matrix_exp m somewhere.
-                matrix temp;
-                temp.set_size(m.nr(),m.nc());
-                matrix_assign(temp, *this + m);
-                temp.swap(*this);
+                *this = m;
             }
             return *this;
         }
@@ -1423,28 +1421,26 @@ namespace dlib
             // m's dimensions don't match that of *this. 
             COMPILE_TIME_ASSERT(EXP::NR == NR || NR == 0 || EXP::NR == 0);
             COMPILE_TIME_ASSERT(EXP::NC == NC || NC == 0 || EXP::NC == 0);
-            DLIB_ASSERT(this->nr() == m.nr() && this->nc() == m.nc(), 
-                "\tmatrix& matrix::operator-=(const matrix_exp& m)"
-                << "\n\tYou are trying to subtract a dynamically sized matrix from a statically sized matrix with the wrong size"
-                << "\n\tthis->nr(): " << nr()
-                << "\n\tthis->nc(): " << nc()
-                << "\n\tm.nr():     " << m.nr()
-                << "\n\tm.nc():     " << m.nc()
-                << "\n\tthis:       " << this
-                );
             COMPILE_TIME_ASSERT((is_same_type<typename EXP::type,type>::value == true));
-            if (m.destructively_aliases(*this) == false)
+            if (nr() == m.nr() && nc() == m.nc())
             {
-                matrix_assign(*this, *this - m);
+                if (m.destructively_aliases(*this) == false)
+                {
+                    matrix_assign(*this, *this - m);
+                }
+                else
+                {
+                    // we have to use a temporary matrix object here because
+                    // this->data is aliased inside the matrix_exp m somewhere.
+                    matrix temp;
+                    temp.set_size(m.nr(),m.nc());
+                    matrix_assign(temp, *this - m);
+                    temp.swap(*this);
+                }
             }
             else
             {
-                // we have to use a temporary matrix object here because
-                // this->data is aliased inside the matrix_exp m somewhere.
-                matrix temp;
-                temp.set_size(m.nr(),m.nc());
-                matrix_assign(temp, *this - m);
-                temp.swap(*this);
+                *this = -m;
             }
             return *this;
         }
@@ -1454,8 +1450,17 @@ namespace dlib
         )
         {
             const long size = m.nr()*m.nc();
-            for (long i = 0; i < size; ++i)
-                data(i) += m.data(i);
+            if (nr() == m.nr() && nc() == m.nc())
+            {
+                for (long i = 0; i < size; ++i)
+                    data(i) += m.data(i);
+            }
+            else
+            {
+                set_size(m.nr(), m.nc());
+                for (long i = 0; i < size; ++i)
+                    data(i) = m.data(i);
+            }
             return *this;
         }
 
@@ -1464,8 +1469,17 @@ namespace dlib
         )
         {
             const long size = m.nr()*m.nc();
-            for (long i = 0; i < size; ++i)
-                data(i) -= m.data(i);
+            if (nr() == m.nr() && nc() == m.nc())
+            {
+                for (long i = 0; i < size; ++i)
+                    data(i) -= m.data(i);
+            }
+            else
+            {
+                set_size(m.nr(), m.nc());
+                for (long i = 0; i < size; ++i)
+                    data(i) = -m.data(i);
+            }
             return *this;
         }
 

dlib/matrix/matrix_abstract.h

@@ -611,10 +611,13 @@ namespace dlib
         /*!
             requires
                 - matrix_exp<EXP>::type == T
-                - nr() == m.nr()
-                - nc() == m.nc()
             ensures
-                - #(*this) == *this + m
+                - if (nr() == m.nr() && nc() == m.nc()) then
+                    - #(*this) == *this + m
+                - else
+                    - #(*this) == m
+                      (i.e. if the dimensions don't match then this function performs a 
+                      normal assignment)
                 - returns *this
         !*/
 
@@ -625,10 +628,11 @@ namespace dlib
         /*!
             requires
                 - matrix_exp<EXP>::type == T
-                - nr() == m.nr()
-                - nc() == m.nc()
             ensures
-                - #(*this) == *this - m
+                - if (nr() == m.nr() && nc() == m.nc()) then
+                    - #(*this) == *this - m
+                - else
+                    - #(*this) == -m
                 - returns *this
         !*/
 
@@ -672,6 +676,9 @@ namespace dlib
             exactly m.size() or 1 values so that the matrix is fully initialized.  Supplying 
             fewer or more than that is an error that will cause a dlib::fatal_error to be 
             thrown.
+
+            Note also that using an expression of the form m = scalar; when m.size() == 0
+            is legal but has no effect on m.
         !*/
 
         void swap (

dlib/test/matrix3.cpp

@@ -776,6 +776,39 @@ namespace
             DLIB_TEST((1>=a) == b);
         }
 
+        {
+            matrix<double> a, b, c;
+            a = randm(4,2);
+
+            b += a;
+            c -= a;
+
+            DLIB_TEST(equal(a, b));
+            DLIB_TEST(equal(-a, c));
+
+            b += a;
+            c -= a;
+
+            DLIB_TEST(equal(2*a, b));
+            DLIB_TEST(equal(-2*a, c));
+
+            b += a + a;
+            c -= a + a;
+
+            DLIB_TEST(equal(4*a, b));
+            DLIB_TEST(equal(-4*a, c));
+
+            b.set_size(0,0);
+            c.set_size(0,0);
+
+
+            b += a + a;
+            c -= a + a;
+
+            DLIB_TEST(equal(2*a, b));
+            DLIB_TEST(equal(-2*a, c));
+        }
+
     }