Added the mat() function. It rolls the array_to_matrix(), vector_to_matrix(),

pointer_to_column_vector(), and pointer_to_matrix() methods all into one
convenient interface.  Also made stddev() slightly more general.

This change also deprecates the previous matrix conversion functions.

dlib/matrix/matrix_mat.h

+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_MATRIx_MAT_H__
+#define DLIB_MATRIx_MAT_H__
+
+#include "matrix_mat_abstract.h"
+#include "matrix.h"
+#include "../stl_checked.h"
+#include <vector>
+#include "matrix_op.h"
+#include "../array2d.h"
+#include "../array.h"
+
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+    
+    template <
+        typename EXP
+        >
+    const matrix_exp<EXP>& mat (
+        const matrix_exp<EXP>& m
+    )
+    {
+        return m;
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T>
+    struct op_array2d_to_mat : does_not_alias 
+    {
+        op_array2d_to_mat( const T& array_) : array(array_){}
+
+        const T& array;
+
+        const static long cost = 1;
+        const static long NR = 0;
+        const static long NC = 0;
+        typedef typename T::type type;
+        typedef const typename T::type& const_ret_type;
+        typedef typename T::mem_manager_type mem_manager_type;
+        typedef row_major_layout layout_type;
+
+        const_ret_type apply (long r, long c ) const { return array[r][c]; }
+
+        long nr () const { return array.nr(); }
+        long nc () const { return array.nc(); }
+    }; 
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename MM
+        >
+    const matrix_op<op_array2d_to_mat<array2d<T,MM> > > mat (
+        const array2d<T,MM>& array
+    )
+    {
+        typedef op_array2d_to_mat<array2d<T,MM> > op;
+        return matrix_op<op>(op(array));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T>
+    struct op_array_to_mat : does_not_alias 
+    {
+        op_array_to_mat( const T& vect_) : vect(vect_){}
+
+        const T& vect;
+
+        const static long cost = 1;
+        const static long NR = 0;
+        const static long NC = 1;
+        typedef typename T::type type;
+        typedef const typename T::type& const_ret_type;
+        typedef typename T::mem_manager_type mem_manager_type;
+        typedef row_major_layout layout_type;
+
+        const_ret_type apply (long r, long  ) const { return vect[r]; }
+
+        long nr () const { return vect.size(); }
+        long nc () const { return 1; }
+    }; 
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename MM
+        >
+    const matrix_op<op_array_to_mat<array<T,MM> > > mat (
+        const array<T,MM>& m 
+    )
+    {
+        typedef op_array_to_mat<array<T,MM> > op;
+        return matrix_op<op>(op(m));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T>
+    struct op_std_vect_to_mat : does_not_alias 
+    {
+        op_std_vect_to_mat( const T& vect_) : vect(vect_){}
+
+        const T& vect;
+
+        const static long cost = 1;
+        const static long NR = 0;
+        const static long NC = 1;
+        typedef typename T::value_type type;
+        typedef const typename T::value_type& const_ret_type;
+        typedef default_memory_manager mem_manager_type;
+        typedef row_major_layout layout_type;
+
+        const_ret_type apply (long r, long ) const { return vect[r]; }
+
+        long nr () const { return vect.size(); }
+        long nc () const { return 1; }
+    }; 
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename value_type,
+        typename alloc
+        >
+    const matrix_op<op_std_vect_to_mat<std::vector<value_type,alloc> > > mat (
+        const std::vector<value_type,alloc>& vector
+    )
+    {
+        typedef op_std_vect_to_mat<std::vector<value_type,alloc> > op;
+        return matrix_op<op>(op(vector));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename value_type,
+        typename alloc
+        >
+    const matrix_op<op_std_vect_to_mat<std::vector<value_type,alloc> > > mat (
+        const std_vector_c<value_type,alloc>& vector
+    )
+    {
+        typedef op_std_vect_to_mat<std_vector_c<value_type,alloc> > op;
+        return matrix_op<op>(op(vector));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T>
+    struct op_pointer_to_col_vect : does_not_alias 
+    {
+        op_pointer_to_col_vect(
+            const T* ptr_,
+            const long size_
+        ) : ptr(ptr_), size(size_){}
+
+        const T* ptr;
+        const long size;
+
+        const static long cost = 1;
+        const static long NR = 0;
+        const static long NC = 1;
+        typedef T type;
+        typedef const T& const_ret_type;
+        typedef default_memory_manager mem_manager_type;
+        typedef row_major_layout layout_type;
+
+        const_ret_type apply (long r, long ) const { return ptr[r]; }
+
+        long nr () const { return size; }
+        long nc () const { return 1; }
+    }; 
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    const matrix_op<op_pointer_to_col_vect<T> > mat (
+        const T* ptr,
+        long nr
+    )
+    {
+        DLIB_ASSERT(nr > 0 , 
+                    "\tconst matrix_exp mat(ptr, nr)"
+                    << "\n\t nr must be bigger than 0"
+                    << "\n\t nr: " << nr
+        );
+        typedef op_pointer_to_col_vect<T> op;
+        return matrix_op<op>(op(ptr, nr));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <typename T>
+    struct op_pointer_to_mat : does_not_alias 
+    {
+        op_pointer_to_mat(
+            const T* ptr_,
+            const long nr_,
+            const long nc_ 
+        ) : ptr(ptr_), rows(nr_), cols(nc_){}
+
+        const T* ptr;
+        const long rows;
+        const long cols;
+
+        const static long cost = 1;
+        const static long NR = 0;
+        const static long NC = 0;
+        typedef T type;
+        typedef const T& const_ret_type;
+        typedef default_memory_manager mem_manager_type;
+        typedef row_major_layout layout_type;
+
+        const_ret_type apply (long r, long c) const { return ptr[r*cols + c]; }
+
+        long nr () const { return rows; }
+        long nc () const { return cols; }
+    }; 
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    const matrix_op<op_pointer_to_mat<T> > mat (
+        const T* ptr,
+        long nr,
+        long nc
+    )
+    {
+        DLIB_ASSERT(nr > 0 && nc > 0 , 
+                    "\tconst matrix_exp mat(ptr, nr, nc)"
+                    << "\n\t nr and nc must be bigger than 0"
+                    << "\n\t nr: " << nr
+                    << "\n\t nc: " << nc
+        );
+        typedef op_pointer_to_mat<T> op;
+        return matrix_op<op>(op(ptr,nr,nc));
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+//                                  DEPRECATED FUNCTIONS
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+// vector_to_matrix(), array_to_matrix(), pointer_to_matrix(), and
+// pointer_to_column_vector() have been deprecated in favor of the more uniform mat()
+// function.  But they are here for backwards compatibility.
+
+    template <
+        typename vector_type
+        >
+    const typename disable_if<is_matrix<vector_type>, matrix_op<op_array_to_mat<vector_type> > >::type 
+    vector_to_matrix (
+        const vector_type& vector
+    )
+    {
+        typedef op_array_to_mat<vector_type> op;
+        return matrix_op<op>(op(vector));
+    }
+
+    template <
+        typename vector_type
+        >
+    const typename enable_if<is_matrix<vector_type>,vector_type>::type& vector_to_matrix (
+        const vector_type& vector
+    )
+    /*!
+        This overload catches the case where the argument to this function is
+        already a matrix.
+    !*/
+    {
+        return vector;
+    }
+
+    template <
+        typename value_type,
+        typename alloc
+        >
+    const matrix_op<op_std_vect_to_mat<std::vector<value_type,alloc> > > vector_to_matrix (
+        const std::vector<value_type,alloc>& vector
+    )
+    {
+        typedef op_std_vect_to_mat<std::vector<value_type,alloc> > op;
+        return matrix_op<op>(op(vector));
+    }
+
+    template <
+        typename value_type,
+        typename alloc
+        >
+    const matrix_op<op_std_vect_to_mat<std_vector_c<value_type,alloc> > > vector_to_matrix (
+        const std_vector_c<value_type,alloc>& vector
+    )
+    {
+        typedef op_std_vect_to_mat<std_vector_c<value_type,alloc> > op;
+        return matrix_op<op>(op(vector));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename array_type
+        >
+    const typename enable_if<is_matrix<array_type>,array_type>::type& 
+    array_to_matrix (
+        const array_type& array
+    )
+    {
+        return array;
+    }
+
+    template <
+        typename array_type
+        >
+    const typename disable_if<is_matrix<array_type>,matrix_op<op_array2d_to_mat<array_type> > >::type 
+    array_to_matrix (
+        const array_type& array
+    )
+    {
+        typedef op_array2d_to_mat<array_type> op;
+        return matrix_op<op>(op(array));
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    const matrix_op<op_pointer_to_mat<T> > pointer_to_matrix (
+        const T* ptr,
+        long nr,
+        long nc
+    )
+    {
+        DLIB_ASSERT(nr > 0 && nc > 0 , 
+                    "\tconst matrix_exp pointer_to_matrix(ptr, nr, nc)"
+                    << "\n\t nr and nc must be bigger than 0"
+                    << "\n\t nr: " << nr
+                    << "\n\t nc: " << nc
+        );
+        typedef op_pointer_to_mat<T> op;
+        return matrix_op<op>(op(ptr,nr,nc));
+    }
+
+    template <
+        typename T
+        >
+    const matrix_op<op_pointer_to_col_vect<T> > pointer_to_column_vector (
+        const T* ptr,
+        long nr
+    )
+    {
+        DLIB_ASSERT(nr > 0 , 
+                    "\tconst matrix_exp pointer_to_column_vector(ptr, nr)"
+                    << "\n\t nr must be bigger than 0"
+                    << "\n\t nr: " << nr
+        );
+        typedef op_pointer_to_col_vect<T> op;
+        return matrix_op<op>(op(ptr, nr));
+    }
+
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_MATRIx_MAT_H__
+
+

dlib/matrix/matrix_mat_abstract.h

+// Copyright (C) 2006  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_MATRIx_MAT_ABSTRACT_H__
+#ifdef DLIB_MATRIx_MAT_ABSTRACT_H__
+
+#include "matrix_abstract.h"
+#inclue <vector>
+#include "../array/array_kernel_abstract.h"
+#include "../array2d/array2d_kernel_abstract.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename EXP
+        >
+    const matrix_exp<EXP>& mat (
+        const matrix_exp<EXP>& m
+    );
+    /*!
+        ensures
+            - returns m
+              (i.e. this function just returns the input matrix without any modifications)
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename MM
+        >
+    const matrix_exp mat (
+        const array2d<T,MM>& array
+    );
+    /*!
+        ensures
+            - returns a matrix R such that:
+                - R.nr() == array.nr() 
+                - R.nc() == array.nc()
+                - for all valid r and c:
+                  R(r, c) == array[r][c]
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T,
+        typename MM
+        >
+    const matrix_exp mat (
+        const array<T,MM>& m 
+    );
+    /*!
+        ensures
+            - returns a matrix R such that:
+                - is_col_vector(R) == true 
+                - R.size() == m.size()
+                - for all valid r:
+                  R(r) == m[r]
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename value_type,
+        typename alloc
+        >
+    const matrix_exp mat (
+        const std::vector<value_type,alloc>& vector
+    );
+    /*!
+        ensures
+            - returns a matrix R such that:
+                - is_col_vector(R) == true 
+                - R.size() == vector.size()
+                - for all valid r:
+                  R(r) == vector[r]
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename value_type,
+        typename alloc
+        >
+    const matrix_exp mat (
+        const std_vector_c<value_type,alloc>& vector
+    );
+    /*!
+        ensures
+            - returns a matrix R such that:
+                - is_col_vector(R) == true 
+                - R.size() == vector.size()
+                - for all valid r:
+                  R(r) == vector[r]
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    const matrix_exp mat (
+        const T* ptr,
+        long nr
+    );
+    /*!
+        requires
+            - nr > 0
+            - ptr == a pointer to at least nr T objects
+        ensures
+            - returns a matrix M such that:
+                - M.nr() == nr
+                - m.nc() == 1
+                - for all valid i:
+                  M(i) == ptr[i]
+            - Note that the returned matrix doesn't take "ownership" of
+              the pointer and thus will not delete or free it.
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename T
+        >
+    const matrix_exp mat (
+        const T* ptr,
+        long nr,
+        long nc
+    );
+    /*!
+        requires
+            - nr > 0
+            - nc > 0
+            - ptr == a pointer to at least nr*nc T objects
+        ensures
+            - returns a matrix M such that:
+                - M.nr() == nr
+                - m.nc() == nc 
+                - for all valid r and c:
+                  M(r,c) == ptr[r*nc + c]
+                  (i.e. the pointer is interpreted as a matrix laid out in memory
+                  in row major order)
+            - Note that the returned matrix doesn't take "ownership" of
+              the pointer and thus will not delete or free it.
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_MATRIx_MAT_ABSTRACT_H__
+
+

dlib/matrix/matrix_utilities.h

@@ -17,6 +17,7 @@
 #include "matrix_math_functions.h"
 #include "matrix_op.h"
 #include "../general_hash/random_hashing.h"
+#include "matrix_mat.h"
 
 
 namespace dlib
@@ -282,246 +283,6 @@ namespace dlib
 // ----------------------------------------------------------------------------------------
 // ----------------------------------------------------------------------------------------
     
-    template <
-        typename array_type
-        >
-    const typename enable_if<is_matrix<array_type>,array_type>::type& 
-    array_to_matrix (
-        const array_type& array
-    )
-    {
-        return array;
-    }
-
-// ----------------------------------------------------------------------------------------
-
-    template <typename T>
-    struct op_array2d_to_mat : does_not_alias 
-    {
-        op_array2d_to_mat( const T& array_) : array(array_){}
-
-        const T& array;
-
-        const static long cost = 1;
-        const static long NR = 0;
-        const static long NC = 0;
-        typedef typename T::type type;
-        typedef const typename T::type& const_ret_type;
-        typedef typename T::mem_manager_type mem_manager_type;
-        typedef row_major_layout layout_type;
-
-        const_ret_type apply (long r, long c ) const { return array[r][c]; }
-
-        long nr () const { return array.nr(); }
-        long nc () const { return array.nc(); }
-    }; 
-
-    template <
-        typename array_type
-        >
-    const typename disable_if<is_matrix<array_type>,matrix_op<op_array2d_to_mat<array_type> > >::type 
-    array_to_matrix (
-        const array_type& array
-    )
-    {
-        typedef op_array2d_to_mat<array_type> op;
-        return matrix_op<op>(op(array));
-    }
-
-// ----------------------------------------------------------------------------------------
-
-    template <typename T>
-    struct op_array_to_mat : does_not_alias 
-    {
-        op_array_to_mat( const T& vect_) : vect(vect_){}
-
-        const T& vect;
-
-        const static long cost = 1;
-        const static long NR = 0;
-        const static long NC = 1;
-        typedef typename T::type type;
-        typedef const typename T::type& const_ret_type;
-        typedef typename T::mem_manager_type mem_manager_type;
-        typedef row_major_layout layout_type;
-
-        const_ret_type apply (long r, long  ) const { return vect[r]; }
-
-        long nr () const { return vect.size(); }
-        long nc () const { return 1; }
-    }; 
-
-    template <
-        typename vector_type
-        >
-    const typename disable_if<is_matrix<vector_type>, matrix_op<op_array_to_mat<vector_type> > >::type 
-    vector_to_matrix (
-        const vector_type& vector
-    )
-    {
-        typedef op_array_to_mat<vector_type> op;
-        return matrix_op<op>(op(vector));
-    }
-
-// ----------------------------------------------------------------------------------------
-
-    template <
-        typename vector_type
-        >
-    const typename enable_if<is_matrix<vector_type>,vector_type>::type& vector_to_matrix (
-        const vector_type& vector
-    )
-    /*!
-        This overload catches the case where the argument to this function is
-        already a matrix.
-    !*/
-    {
-        return vector;
-    }
-
-// ----------------------------------------------------------------------------------------
-
-    template <typename T>
-    struct op_std_vect_to_mat : does_not_alias 
-    {
-        op_std_vect_to_mat( const T& vect_) : vect(vect_){}
-
-        const T& vect;
-
-        const static long cost = 1;
-        const static long NR = 0;
-        const static long NC = 1;
-        typedef typename T::value_type type;
-        typedef const typename T::value_type& const_ret_type;
-        typedef default_memory_manager mem_manager_type;
-        typedef row_major_layout layout_type;
-
-        const_ret_type apply (long r, long ) const { return vect[r]; }
-
-        long nr () const { return vect.size(); }
-        long nc () const { return 1; }
-    }; 
-
-    template <
-        typename value_type,
-        typename alloc
-        >
-    const matrix_op<op_std_vect_to_mat<std::vector<value_type,alloc> > > vector_to_matrix (
-        const std::vector<value_type,alloc>& vector
-    )
-    {
-        typedef op_std_vect_to_mat<std::vector<value_type,alloc> > op;
-        return matrix_op<op>(op(vector));
-    }
-
-// ----------------------------------------------------------------------------------------
-
-    template <
-        typename value_type,
-        typename alloc
-        >
-    const matrix_op<op_std_vect_to_mat<std_vector_c<value_type,alloc> > > vector_to_matrix (
-        const std_vector_c<value_type,alloc>& vector
-    )
-    {
-        typedef op_std_vect_to_mat<std_vector_c<value_type,alloc> > op;
-        return matrix_op<op>(op(vector));
-    }
-
-// ----------------------------------------------------------------------------------------
-
-    template <typename T>
-    struct op_pointer_to_col_vect : does_not_alias 
-    {
-        op_pointer_to_col_vect(
-            const T* ptr_,
-            const long size_
-        ) : ptr(ptr_), size(size_){}
-
-        const T* ptr;
-        const long size;
-
-        const static long cost = 1;
-        const static long NR = 0;
-        const static long NC = 1;
-        typedef T type;
-        typedef const T& const_ret_type;
-        typedef default_memory_manager mem_manager_type;
-        typedef row_major_layout layout_type;
-
-        const_ret_type apply (long r, long ) const { return ptr[r]; }
-
-        long nr () const { return size; }
-        long nc () const { return 1; }
-    }; 
-
-    template <
-        typename T
-        >
-    const matrix_op<op_pointer_to_col_vect<T> > pointer_to_column_vector (
-        const T* ptr,
-        long nr
-    )
-    {
-        DLIB_ASSERT(nr > 0 , 
-                    "\tconst matrix_exp pointer_to_column_vector(ptr, nr)"
-                    << "\n\t nr must be bigger than 0"
-                    << "\n\t nr: " << nr
-        );
-        typedef op_pointer_to_col_vect<T> op;
-        return matrix_op<op>(op(ptr, nr));
-    }
-
-// ----------------------------------------------------------------------------------------
-
-    template <typename T>
-    struct op_pointer_to_mat : does_not_alias 
-    {
-        op_pointer_to_mat(
-            const T* ptr_,
-            const long nr_,
-            const long nc_ 
-        ) : ptr(ptr_), rows(nr_), cols(nc_){}
-
-        const T* ptr;
-        const long rows;
-        const long cols;
-
-        const static long cost = 1;
-        const static long NR = 0;
-        const static long NC = 0;
-        typedef T type;
-        typedef const T& const_ret_type;
-        typedef default_memory_manager mem_manager_type;
-        typedef row_major_layout layout_type;
-
-        const_ret_type apply (long r, long c) const { return ptr[r*cols + c]; }
-
-        long nr () const { return rows; }
-        long nc () const { return cols; }
-    }; 
-
-    template <
-        typename T
-        >
-    const matrix_op<op_pointer_to_mat<T> > pointer_to_matrix (
-        const T* ptr,
-        long nr,
-        long nc
-    )
-    {
-        DLIB_ASSERT(nr > 0 && nc > 0 , 
-                    "\tconst matrix_exp pointer_to_matrix(ptr, nr, nc)"
-                    << "\n\t nr and nc must be bigger than 0"
-                    << "\n\t nr: " << nr
-                    << "\n\t nc: " << nc
-        );
-        typedef op_pointer_to_mat<T> op;
-        return matrix_op<op>(op(ptr,nr,nc));
-    }
-
-// ----------------------------------------------------------------------------------------
-
     template <typename M>
     struct op_trans 
     {
@@ -1776,7 +1537,9 @@ namespace dlib
         const matrix_exp<EXP>& m
     )
     {
-        return std::sqrt(variance(m));
+        using std::sqrt;
+        using dlib::sqrt;
+        return sqrt(variance(m));
     }
 
 // ----------------------------------------------------------------------------------------

dlib/matrix/matrix_utilities_abstract.h

@@ -456,102 +456,6 @@ namespace dlib
                   M(r,c) == m(m.nr()-r-1, m.nc()-c-1)
     !*/
 
-// ----------------------------------------------------------------------------------------
-
-    template <
-        typename vector_type
-        >
-    const matrix_exp vector_to_matrix (
-        const vector_type& vector
-    );
-    /*!
-        requires
-            - vector_type is an implementation of array/array_kernel_abstract.h or
-              std::vector or dlib::std_vector_c or dlib::matrix
-        ensures
-            - if (vector_type is a dlib::matrix) then
-                - returns a reference to vector
-            - else
-                - returns a matrix R such that:
-                    - is_col_vector(R) == true 
-                    - R.size() == vector.size()
-                    - for all valid r:
-                      R(r) == vector[r]
-    !*/
-
-// ----------------------------------------------------------------------------------------
-
-    template <
-        typename array_type
-        >
-    const matrix_exp array_to_matrix (
-        const array_type& array
-    );
-    /*!
-        requires
-            - array_type is an implementation of array2d/array2d_kernel_abstract.h
-              or dlib::matrix
-        ensures
-            - if (array_type is a dlib::matrix) then
-                - returns a reference to array 
-            - else
-                - returns a matrix R such that:
-                    - R.nr() == array.nr() 
-                    - R.nc() == array.nc()
-                    - for all valid r and c:
-                      R(r, c) == array[r][c]
-    !*/
-
-// ----------------------------------------------------------------------------------------
-
-    template <
-        typename T
-        >
-    const matrix_exp pointer_to_matrix (
-        const T* ptr,
-        long nr,
-        long nc
-    );
-    /*!
-        requires
-            - nr > 0
-            - nc > 0
-            - ptr == a pointer to at least nr*nc T objects
-        ensures
-            - returns a matrix M such that:
-                - M.nr() == nr
-                - m.nc() == nc 
-                - for all valid r and c:
-                  M(r,c) == ptr[r*nc + c]
-                  (i.e. the pointer is interpreted as a matrix laid out in memory
-                  in row major order)
-            - Note that the returned matrix doesn't take "ownership" of
-              the pointer and thus will not delete or free it.
-    !*/
-
-// ----------------------------------------------------------------------------------------
-
-    template <
-        typename T
-        >
-    const matrix_exp pointer_to_column_vector (
-        const T* ptr,
-        long nr
-    );
-    /*!
-        requires
-            - nr > 0
-            - ptr == a pointer to at least nr T objects
-        ensures
-            - returns a matrix M such that:
-                - M.nr() == nr
-                - m.nc() == 1
-                - for all valid i:
-                  M(i) == ptr[i]
-            - Note that the returned matrix doesn't take "ownership" of
-              the pointer and thus will not delete or free it.
-    !*/
-
 // ----------------------------------------------------------------------------------------
 
     const matrix_exp reshape (
@@ -1548,7 +1452,7 @@ namespace dlib
     );
     /*!
         ensures
-            - returns std::sqrt(variance(m))
+            - returns sqrt(variance(m))
     !*/
 
 // ----------------------------------------------------------------------------------------