Moved sparse_to_dense() into the file with all the other sparse

vector functions.

dlib/data_io/libsvm_io.h

@@ -23,13 +23,6 @@ namespace dlib
 
 // ----------------------------------------------------------------------------------------
 
-    namespace impl
-    {
-        template <typename T> struct strip_const { typedef T type; };
-        template <typename T> struct strip_const<const T> { typedef T type; };
-        template <typename T> struct strip_const<const T&> { typedef T type; };
-    }
-
     template <typename sample_type, typename label_type, typename alloc1, typename alloc2>
     void load_libsvm_formatted_data (
         const std::string& file_name,
@@ -39,7 +32,7 @@ namespace dlib
     {
         using namespace std;
         typedef typename sample_type::value_type pair_type;
-        typedef typename impl::strip_const<typename pair_type::first_type>::type key_type;
+        typedef typename basic_type<typename pair_type::first_type>::type key_type;
         typedef typename pair_type::second_type value_type;
 
         // You must use unsigned integral key types in your sparse vectors
@@ -116,7 +109,7 @@ namespace dlib
     )
     {
         typedef typename sample_type::value_type pair_type;
-        typedef typename impl::strip_const<typename pair_type::first_type>::type key_type;
+        typedef typename basic_type<typename pair_type::first_type>::type key_type;
 
         if (samples.size() == 0)
             return;
@@ -157,7 +150,7 @@ namespace dlib
     )
     {
         typedef typename sample_type::value_type pair_type;
-        typedef typename impl::strip_const<typename pair_type::first_type>::type key_type;
+        typedef typename basic_type<typename pair_type::first_type>::type key_type;
 
         if (samples.size() == 0)
             return;
@@ -193,7 +186,7 @@ namespace dlib
     )
     {
         typedef typename sample_type::value_type pair_type;
-        typedef typename impl::strip_const<typename pair_type::first_type>::type key_type;
+        typedef typename basic_type<typename pair_type::first_type>::type key_type;
 
         // You must use unsigned integral key types in your sparse vectors
         COMPILE_TIME_ASSERT(is_unsigned_type<key_type>::value);
@@ -273,50 +266,6 @@ namespace dlib
 
     }
 
-// ----------------------------------------------------------------------------------------
-
-    template <typename sample_type, typename alloc>
-    std::vector<matrix<typename sample_type::value_type::second_type,0,1> > sparse_to_dense (
-        const std::vector<sample_type, alloc>& samples
-    )
-    {
-        typedef typename sample_type::value_type pair_type;
-        typedef typename impl::strip_const<typename pair_type::first_type>::type key_type;
-
-        // You must use unsigned integral key types in your sparse vectors
-        COMPILE_TIME_ASSERT(is_unsigned_type<key_type>::value);
-
-        typedef typename sample_type::value_type pair_type;
-        typedef typename impl::strip_const<typename pair_type::first_type>::type key_type;
-        typedef typename pair_type::second_type value_type;
-
-        std::vector< matrix<value_type,0,1> > result;
-
-        // do nothing if there aren't any samples
-        if (samples.size() == 0)
-            return result;
-
-
-        // figure out how many elements we need in our dense vectors.  
-        const unsigned long max_dim = max_index_plus_one(samples);
-
-
-        // now turn all the samples into dense samples
-        result.resize(samples.size());
-
-        for (unsigned long i = 0; i < samples.size(); ++i)
-        {
-            result[i].set_size(max_dim);
-            result[i] = 0;
-            for (typename sample_type::const_iterator j = samples[i].begin(); j != samples[i].end(); ++j)
-            {
-                result[i](j->first) = j->second;
-            }
-        }
-
-        return result;
-    }
-
 // ----------------------------------------------------------------------------------------
 
 }

dlib/data_io/libsvm_io_abstract.h

@@ -99,36 +99,6 @@ namespace dlib
                 This exception is thrown if there is any problem saving data to file
     !*/
 
-// ----------------------------------------------------------------------------------------
-
-    template <
-        typename sample_type, 
-        typename alloc
-        >
-    std::vector<matrix<typename sample_type::value_type::second_type,0,1> > sparse_to_dense (
-        const std::vector<sample_type, alloc>& samples
-    );
-    /*!
-        requires
-            - sample_type must be an STL container
-            - sample_type::value_type == std::pair<T,U> where T is some kind of 
-              unsigned integral type
-        ensures
-            - converts from sparse sample vectors to dense (column matrix form)
-            - That is, this function returns a std::vector R such that:
-                - R contains column matrices    
-                - R.size() == samples.size()
-                - for all valid i: 
-                    - R[i] == the dense (i.e. dlib::matrix) version of the sparse sample
-                      given by samples[i]
-                    - for all valid j:
-                        - R[i](j) == the value of the element in samples[i] that has key
-                          value j.  That is, the key used for each element of a sparse
-                          vector directly determines where that element gets put into a
-                          dense vector.  Note that elements not explicitly in the sparse
-                          vector have a value of 0.
-    !*/
-
 // ----------------------------------------------------------------------------------------
 
     template <typename sample_type, typename alloc>

dlib/svm/sparse_vector.h

@@ -634,6 +634,48 @@ namespace dlib
         return temp;
     }
 
+// ----------------------------------------------------------------------------------------
+
+    template <typename sample_type, typename alloc>
+    std::vector<matrix<typename sample_type::value_type::second_type,0,1> > sparse_to_dense (
+        const std::vector<sample_type, alloc>& samples
+    )
+    {
+        typedef typename sample_type::value_type pair_type;
+        typedef typename basic_type<typename pair_type::first_type>::type key_type;
+
+        // You must use unsigned integral key types in your sparse vectors
+        COMPILE_TIME_ASSERT(is_unsigned_type<key_type>::value);
+
+        typedef typename pair_type::second_type value_type;
+
+        std::vector< matrix<value_type,0,1> > result;
+
+        // do nothing if there aren't any samples
+        if (samples.size() == 0)
+            return result;
+
+
+        // figure out how many elements we need in our dense vectors.  
+        const unsigned long max_dim = max_index_plus_one(samples);
+
+
+        // now turn all the samples into dense samples
+        result.resize(samples.size());
+
+        for (unsigned long i = 0; i < samples.size(); ++i)
+        {
+            result[i].set_size(max_dim);
+            result[i] = 0;
+            for (typename sample_type::const_iterator j = samples[i].begin(); j != samples[i].end(); ++j)
+            {
+                result[i](j->first) = j->second;
+            }
+        }
+
+        return result;
+    }
+
 // ----------------------------------------------------------------------------------------
 
 }

dlib/svm/sparse_vector_abstract.h

@@ -361,6 +361,36 @@ namespace dlib
               of 0 elements.
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename sample_type, 
+        typename alloc
+        >
+    std::vector<matrix<typename sample_type::value_type::second_type,0,1> > sparse_to_dense (
+        const std::vector<sample_type, alloc>& samples
+    );
+    /*!
+        requires
+            - sample_type must be an STL container
+            - sample_type::value_type == std::pair<T,U> where T is some kind of 
+              unsigned integral type
+        ensures
+            - converts from sparse sample vectors to dense (column matrix form)
+            - That is, this function returns a std::vector R such that:
+                - R contains column matrices    
+                - R.size() == samples.size()
+                - for all valid i: 
+                    - R[i] == the dense (i.e. dlib::matrix) version of the sparse sample
+                      given by samples[i]
+                    - for all valid j:
+                        - R[i](j) == the value of the element in samples[i] that has key
+                          value j.  That is, the key used for each element of a sparse
+                          vector directly determines where that element gets put into a
+                          dense vector.  Note that elements not explicitly in the sparse
+                          vector have a value of 0.
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
 }