Added a randomize_samples() that works on three things.

dlib/svm/svm.h

@@ -779,9 +779,115 @@ namespace dlib
     template <
         typename T,
         typename U,
+        typename V,
         typename rand_type 
         >
     typename enable_if<is_matrix<T>,void>::type randomize_samples (
+        T& t,
+        U& u,
+        V& v,
+        rand_type& r
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT(is_vector(t) && is_vector(u) && is_vector(v) && u.size() == t.size() &&
+                    u.size() == v.size(),
+            "\t randomize_samples(t,u,v)"
+            << "\n\t invalid inputs were given to this function"
+            << "\n\t t.size(): " << t.size()
+            << "\n\t u.size(): " << u.size()
+            << "\n\t v.size(): " << v.size()
+            << "\n\t is_vector(t): " << is_vector(t)
+            << "\n\t is_vector(u): " << is_vector(u)
+            << "\n\t is_vector(v): " << is_vector(v)
+            );
+
+        long n = t.size()-1;
+        while (n > 0)
+        {
+            // put a random integer into idx
+            unsigned long idx = r.get_random_32bit_number();
+
+            // make idx be less than n
+            idx %= n;
+
+            // swap our randomly selected index into the n position
+            exchange(t(idx), t(n));
+            exchange(u(idx), u(n));
+            exchange(v(idx), v(n));
+
+            --n;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename U,
+        typename V,
+        typename rand_type
+        >
+    typename disable_if<is_matrix<T>,void>::type randomize_samples (
+        T& t,
+        U& u,
+        V& v,
+        rand_type& r
+    )
+    {
+        // make sure requires clause is not broken
+        DLIB_ASSERT(u.size() == t.size() && u.size() == v.size(),
+            "\t randomize_samples(t,u,v)"
+            << "\n\t invalid inputs were given to this function"
+            << "\n\t t.size(): " << t.size()
+            << "\n\t u.size(): " << u.size()
+            << "\n\t v.size(): " << v.size()
+            );
+
+        long n = t.size()-1;
+        while (n > 0)
+        {
+            // put a random integer into idx
+            unsigned long idx = r.get_random_32bit_number();
+
+            // make idx be less than n
+            idx %= n;
+
+            // swap our randomly selected index into the n position
+            exchange(t[idx], t[n]);
+            exchange(u[idx], u[n]);
+            exchange(v[idx], v[n]);
+
+            --n;
+        }
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename U,
+        typename V
+        >
+    typename disable_if<is_rand<V>,void>::type randomize_samples (
+        T& t,
+        U& u,
+        V& v
+    )
+    {
+        rand r;
+        randomize_samples(t,u,v,r);
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename U,
+        typename rand_type 
+        >
+    typename enable_if_c<is_matrix<T>::value && is_rand<rand_type>::value,void>::type randomize_samples (
         T& t,
         U& u,
         rand_type& r
@@ -821,7 +927,7 @@ namespace dlib
         typename U,
         typename rand_type
         >
-    typename disable_if<is_matrix<T>,void>::type randomize_samples (
+    typename disable_if_c<is_matrix<T>::value || !is_rand<rand_type>::value,void>::type randomize_samples (
         T& t,
         U& u,
         rand_type& r
@@ -867,6 +973,7 @@ namespace dlib
         randomize_samples(t,u,r);
     }
 
+// ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 
     template <

dlib/svm/svm_abstract.h

@@ -345,6 +345,82 @@ namespace dlib
             - the given rnd random number generator object is used to do the randomizing
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename U,
+        typename V
+        >
+    void randomize_samples (
+        T& samples,
+        U& labels,
+        V& auxiliary
+    );
+    /*!
+        requires
+            - T == a matrix object or an object compatible with std::vector that contains 
+              a swappable type.
+            - U == a matrix object or an object compatible with std::vector that contains 
+              a swappable type.
+            - V == a matrix object or an object compatible with std::vector that contains 
+              a swappable type.
+            - if (samples, labels, or auxiliary are matrix objects) then 
+                - is_vector(samples) == true 
+                - is_vector(labels) == true
+                - is_vector(auxiliary) == true
+            - samples.size() == labels.size() == auxiliary.size()
+            - rand_type == a type that implements the dlib/rand/rand_kernel_abstract.h interface
+        ensures
+            - randomizes the order of the samples, labels, and auxiliary but preserves the
+              pairing between each sample, its label, and its auxiliary value.
+            - A default initialized random number generator is used to perform the
+              randomizing.  Note that this means that each call this this function does the
+              same thing.  That is, the random number generator always uses the same seed.
+            - for all valid i:
+                - let r == the random index samples(i) was moved to.  then:
+                    - #labels(r) == labels(i)
+                    - #auxiliary(r) == auxiliary(i)
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename U,
+        typename V,
+        typename rand_type
+        >
+    void randomize_samples (
+        T& samples,
+        U& labels,
+        V& auxiliary,
+        rand_type& rnd
+    );
+    /*!
+        requires
+            - T == a matrix object or an object compatible with std::vector that contains 
+              a swappable type.
+            - U == a matrix object or an object compatible with std::vector that contains 
+              a swappable type.
+            - V == a matrix object or an object compatible with std::vector that contains 
+              a swappable type.
+            - if (samples, labels, or auxiliary are matrix objects) then 
+                - is_vector(samples) == true 
+                - is_vector(labels) == true
+                - is_vector(auxiliary) == true
+            - samples.size() == labels.size() == auxiliary.size()
+            - rand_type == a type that implements the dlib/rand/rand_kernel_abstract.h interface
+        ensures
+            - randomizes the order of the samples, labels, and auxiliary but preserves the
+              pairing between each sample, its label, and its auxiliary value.
+            - the given rnd random number generator object is used to do the randomizing
+            - for all valid i:
+                - let r == the random index samples(i) was moved to.  then:
+                    - #labels(r) == labels(i)
+                    - #auxiliary(r) == auxiliary(i)
+    !*/
+
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
 

dlib/test/statistics.cpp

@@ -8,6 +8,7 @@
 #include <ctime>
 #include <dlib/statistics.h>
 #include <dlib/rand.h>
+#include <dlib/svm.h>
 #include <algorithm>
 
 #include "tester.h"
@@ -238,6 +239,53 @@ namespace
 
         }
 
+        void test_randomize_samples()
+        {
+            std::vector<unsigned int> t(15),u(15),v(15);
+
+            for (unsigned long i = 0; i < t.size(); ++i)
+            {
+                t[i] = i;
+                u[i] = i+1;
+                v[i] = i+2;
+            }
+            randomize_samples(t,u,v);
+
+            DLIB_TEST(t.size() == 15);
+            DLIB_TEST(u.size() == 15);
+            DLIB_TEST(v.size() == 15);
+
+            for (unsigned long i = 0; i < t.size(); ++i)
+            {
+                const unsigned long val = t[i];
+                DLIB_TEST(u[i] == val+1);
+                DLIB_TEST(v[i] == val+2);
+            }
+        }
+        void test_randomize_samples2()
+        {
+            dlib::matrix<int,15,1> t(15),u(15),v(15);
+
+            for (long i = 0; i < t.size(); ++i)
+            {
+                t(i) = i;
+                u(i) = i+1;
+                v(i) = i+2;
+            }
+            randomize_samples(t,u,v);
+
+            DLIB_TEST(t.size() == 15);
+            DLIB_TEST(u.size() == 15);
+            DLIB_TEST(v.size() == 15);
+
+            for (long i = 0; i < t.size(); ++i)
+            {
+                const long val = t(i);
+                DLIB_TEST(u(i) == val+1);
+                DLIB_TEST(v(i) == val+2);
+            }
+        }
+
         void perform_test (
         )
         {
@@ -245,6 +293,8 @@ namespace
             test_random_subset_selector2();
             test_running_covariance();
             test_running_stats();
+            test_randomize_samples();
+            test_randomize_samples2();
         }
     } a;