- Added overloads for rowm() and colm() that allow you to pick out

     less than an entire vector
   - Added the lowerm() and upperm() functions
   - Added the const_temp_matrix class.

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

dlib/matrix/matrix.h

@@ -1733,6 +1733,79 @@ namespace dlib
         return out;
     }
 
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------
+
+    template <typename EXP>
+    class const_temp_matrix;
+
+    template <
+        typename EXP
+        >
+    struct matrix_traits<const_temp_matrix<EXP> >
+    {
+        typedef typename EXP::type type;
+        typedef typename EXP::mem_manager_type mem_manager_type;
+        typedef typename EXP::layout_type layout_type;
+        const static long NR = EXP::NR;
+        const static long NC = EXP::NC;
+        const static long cost = 1;
+    };
+
+    template <typename EXP>
+    class const_temp_matrix : public matrix_exp<const_temp_matrix<EXP> >, noncopyable 
+    {
+    public:
+        typedef typename matrix_traits<const_temp_matrix>::type type;
+        typedef typename matrix_traits<const_temp_matrix>::mem_manager_type mem_manager_type;
+        typedef typename matrix_traits<const_temp_matrix>::layout_type layout_type;
+        const static long NR = matrix_traits<const_temp_matrix>::NR;
+        const static long NC = matrix_traits<const_temp_matrix>::NC;
+        const static long cost = matrix_traits<const_temp_matrix>::cost;
+
+        const_temp_matrix (
+            const matrix_exp<EXP>& item
+        ) :
+            matrix_exp<const_temp_matrix>(*this),
+            ref_(item.ref())
+        {}
+        const_temp_matrix (
+            const EXP& item
+        ) :
+            matrix_exp<const_temp_matrix>(*this),
+            ref_(item)
+        {}
+
+        const type operator() (
+            long r, 
+            long c
+        ) const { return ref_(r,c); }
+
+        const type operator() ( long i ) const 
+        { return ref_(i); }
+
+        template <typename U, long iNR, long iNC, typename MM, typename L >
+        bool aliases (
+            const matrix<U,iNR,iNC,MM,L>& item
+        ) const { return ref_.aliases(item); }
+
+        template <typename U, long iNR, long iNC, typename MM, typename L >
+        bool destructively_aliases (
+            const matrix<U,iNR,iNC,MM,L>& item
+        ) const { return ref_.destructively_aliases(item); }
+
+        long nr (
+        ) const { return ref_.nr(); }
+
+        long nc (
+        ) const { return ref_.nc(); }
+
+    private:
+
+        typename conditional_matrix_temp<const EXP, (EXP::cost <= 1)>::type ref_;
+    };
+
 // ----------------------------------------------------------------------------------------
 
 }

dlib/matrix/matrix_abstract.h

@@ -744,6 +744,58 @@ namespace dlib
             - returns out
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    template <typename EXP>
+    class const_temp_matrix : public matrix_exp<const_temp_matrix<EXP> >, noncopyable 
+    {
+        /*!
+            REQUIREMENTS ON EXP
+                - must be an object that inherits publicly from matrix_exp.
+
+            WHAT THIS OBJECT REPRESENTS
+                This object represents a copy of a matrix expression.  The twist
+                is that it only actually makes a copy of its input matrix expression
+                if that matrix expression is costly to evaluate.  If it has
+                low cost then this object just stores a reference.  
+
+                This class is useful in cases where you write a function that
+                takes a matrix_exp object as input and you want to do some
+                intensive computation that looks at each element of that matrix_exp
+                many times.  If the input matrix_exp has a high cost then you want
+                to store it into a temporary matrix.  But if it has low cost then
+                it is faster if you just use a reference to it.  The const_temp_matrix
+                makes doing this easy.
+        !*/
+    public:
+
+        const_temp_matrix (
+            const matrix_exp<EXP>& item
+        );
+        /*!
+            ensures
+                - #*this == item
+                - if (EXP::cost <= 1) then
+                    - this const_temp_matrix stores a reference to the item matrix
+                - else
+                    - this const_temp_matrix creates a temporary matrix and copies 
+                      item into it
+        !*/
+
+        const_temp_matrix (
+            const EXP& item
+        );
+        /*!
+            ensures
+                - #*this == item
+                - if (EXP::cost <= 1) then
+                    - this const_temp_matrix stores a reference to the item matrix
+                - else
+                    - this const_temp_matrix creates a temporary matrix and copies 
+                      item into it
+        !*/
+    };
+
 // ----------------------------------------------------------------------------------------
 
 }

dlib/matrix/matrix_assign.h

@@ -123,6 +123,18 @@ namespace dlib
             const static int value = row_matrix;
         };
 
+        template <typename T, long NR, long NC, typename MM, typename L>
+        struct matrix_type_id<matrix_scalar_ternary_exp<matrix<T,NR,NC,MM,L>,long,op_colm2> >
+        {
+            const static int value = column_matrix;
+        };
+
+        template <typename T, long NR, long NC, typename MM, typename L>
+        struct matrix_type_id<matrix_scalar_ternary_exp<matrix<T,NR,NC,MM,L>,long,op_rowm2> >
+        {
+            const static int value = row_matrix;
+        };
+
         template <typename T, long NR, long NC, typename MM, typename L>
         struct matrix_type_id<matrix_sub_exp<matrix<T,NR,NC,MM,L> > >
         {

dlib/matrix/matrix_blas_bindings.h

@@ -237,6 +237,20 @@ namespace dlib
             return 1;
         }
 
+        template <typename T, long NR, long NC, typename MM>
+        int get_inc(const matrix_scalar_ternary_exp<matrix<T,NR,NC,MM,row_major_layout>,long,op_colm2>& m)
+        {
+            return m.m.nc();
+        }
+
+        template <typename T, long NR, long NC, typename MM>
+        int get_inc(const matrix_scalar_ternary_exp<matrix<T,NR,NC,MM,row_major_layout>,long,op_rowm2>& m)
+        {
+            return 1;
+        }
+
+
+
         template <typename T, long NR, long NC, typename MM>
         int get_inc(const matrix_scalar_binary_exp<matrix<T,NR,NC,MM,column_major_layout>,long,op_colm>& m)
         {
@@ -249,6 +263,19 @@ namespace dlib
             return m.m.nr();
         }
 
+        template <typename T, long NR, long NC, typename MM>
+        int get_inc(const matrix_scalar_ternary_exp<matrix<T,NR,NC,MM,column_major_layout>,long,op_colm2>& m)
+        {
+            return 1;
+        }
+
+        template <typename T, long NR, long NC, typename MM>
+        int get_inc(const matrix_scalar_ternary_exp<matrix<T,NR,NC,MM,column_major_layout>,long,op_rowm2>& m)
+        {
+            return m.m.nr();
+        }
+
+
 
         template <typename T, long NR, long NC, typename MM>
         int get_inc(const assignable_row_matrix<T,NR,NC,MM,row_major_layout>& m)
@@ -291,6 +318,12 @@ namespace dlib
         template <typename T, long NR, long NC, typename MM, typename L>
         const T* get_ptr (const matrix_scalar_binary_exp<matrix<T,NR,NC,MM,L>,long,op_rowm>& m) { return &m.m(m.s,0); }
 
+        template <typename T, long NR, long NC, typename MM, typename L>
+        const T* get_ptr (const matrix_scalar_ternary_exp<matrix<T,NR,NC,MM,L>,long,op_colm2>& m) { return &m.m(0,m.s1); }
+
+        template <typename T, long NR, long NC, typename MM, typename L>
+        const T* get_ptr (const matrix_scalar_ternary_exp<matrix<T,NR,NC,MM,L>,long,op_rowm2>& m) { return &m.m(m.s1,0); }
+
 
         template <typename T, long NR, long NC, typename MM, typename L>
         T* get_ptr (assignable_col_matrix<T,NR,NC,MM,L>& m) { return &m(0,0); }

dlib/matrix/matrix_expressions.h

@@ -465,12 +465,11 @@ namespace dlib
         ) const { return OP::destructively_aliases(m,item); }
 
         long nr (
-        ) const { return OP::nr(m); }
+        ) const { return OP::nr(m,s1,s2); }
 
         long nc (
-        ) const { return OP::nc(m); }
+        ) const { return OP::nc(m,s1,s2); }
 
-    private:
 
         const M& m;
         const S s1;

dlib/matrix/matrix_subexp.h

@@ -202,6 +202,52 @@ namespace dlib
         return exp(m.ref(),row);
     }
 
+// ----------------------------------------------------------------------------------------
+
+    struct op_rowm2
+    {
+        template <typename EXP>
+        struct op : has_destructive_aliasing
+        {
+            const static long cost = EXP::cost;
+            const static long NR = 1;
+            const static long NC = 0;
+            typedef typename EXP::type type;
+            typedef typename EXP::mem_manager_type mem_manager_type;
+            template <typename M>
+            static type apply ( const M& m, long row, long length, long r, long c)
+            { return m(row,c); }
+
+            template <typename M>
+            static long nr (const M& m, long, long) { return 1; }
+            template <typename M>
+            static long nc (const M& m, long, long length) { return length; }
+        };
+    };
+
+    template <
+        typename EXP
+        >
+    const matrix_scalar_ternary_exp<EXP,long,op_rowm2> rowm (
+        const matrix_exp<EXP>& m,
+        long row,
+        long length
+    )
+    {
+        DLIB_ASSERT(row >= 0 && row < m.nr() && 
+                    length >= 0 && length < m.nc(), 
+            "\tconst matrix_exp rowm(const matrix_exp& m, row, length)"
+            << "\n\tYou have specified invalid sub matrix dimensions"
+            << "\n\tm.nr(): " << m.nr()
+            << "\n\tm.nc(): " << m.nc() 
+            << "\n\trow:    " << row 
+            << "\n\tlength: " << length 
+            );
+
+        typedef matrix_scalar_ternary_exp<EXP,long,op_rowm2> exp;
+        return exp(m.ref(),row, length);
+    }
+
 // ----------------------------------------------------------------------------------------
 
     struct op_rowm_range
@@ -296,6 +342,52 @@ namespace dlib
         return exp(m.ref(),col);
     }
 
+// ----------------------------------------------------------------------------------------
+
+    struct op_colm2
+    {
+        template <typename EXP>
+        struct op : has_destructive_aliasing
+        {
+            const static long cost = EXP::cost;
+            const static long NR = 0;
+            const static long NC = 1;
+            typedef typename EXP::type type;
+            typedef typename EXP::mem_manager_type mem_manager_type;
+            template <typename M>
+            static type apply ( const M& m, long col, long length, long r, long c)
+            { return m(r,col); }
+
+            template <typename M>
+            static long nr (const M& m, long, long length) { return length; }
+            template <typename M>
+            static long nc (const M& m, long, long) { return 1; }
+        };
+    };
+
+    template <
+        typename EXP
+        >
+    const matrix_scalar_ternary_exp<EXP,long,op_colm2> colm (
+        const matrix_exp<EXP>& m,
+        long col,
+        long length
+    )
+    {
+        DLIB_ASSERT(col >= 0 && col < m.nc() && 
+                    length >= 0 && length < m.nr(), 
+            "\tconst matrix_exp colm(const matrix_exp& m, col, length)"
+            << "\n\tYou have specified invalid sub matrix dimensions"
+            << "\n\tm.nr(): " << m.nr()
+            << "\n\tm.nc(): " << m.nc() 
+            << "\n\tcol:    " << col 
+            << "\n\tlength: " << length 
+            );
+
+        typedef matrix_scalar_ternary_exp<EXP,long,op_colm2> exp;
+        return exp(m.ref(),col, length);
+    }
+
 // ----------------------------------------------------------------------------------------
 
     struct op_colm_range

dlib/matrix/matrix_subexp_abstract.h

@@ -150,6 +150,25 @@ namespace dlib
                   R(i) == m(row,i)
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    const matrix_exp rowm (
+        const matrix_exp& m,
+        long row,
+        long length
+    );
+    /*!
+        requires
+            - 0 <= row < m.nr()
+            - 0 <= length < m.nc()
+        ensures
+            - returns a matrix R such that:
+                - R.nr() == 1
+                - R.nc() == length
+                - for all valid i:
+                  R(i) == m(row,i)
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
     const matrix_exp rowm (
@@ -188,6 +207,25 @@ namespace dlib
                   R(i) == m(i,col)
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    const matrix_exp colm (
+        const matrix_exp& m,
+        long col,
+        long length
+    );
+    /*!
+        requires
+            - 0 <= col < m.nr()
+            - 0 <= length < m.nc()
+        ensures
+            - returns a matrix R such that:
+                - R.nr() == length 
+                - R.nc() == 1
+                - for all valid i:
+                  R(i) == m(i,col)
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
     const matrix_exp colm (

dlib/matrix/matrix_utilities.h

@@ -1221,10 +1221,10 @@ convergence:
                 }
             }
 
-            template <typename M>
-            static long nr (const M& m) { return m.nr() - 1; }
-            template <typename M>
-            static long nc (const M& m) { return m.nc() - 1; }
+            template <typename M, typename S>
+            static long nr (const M& m, S&, S&) { return m.nr() - 1; }
+            template <typename M, typename S>
+            static long nc (const M& m, S&, S&) { return m.nc() - 1; }
         };
     };
 
@@ -3213,6 +3213,117 @@ convergence:
         return exp(a.ref(),b.ref());
     }
 
+// ----------------------------------------------------------------------------------------
+
+
+    struct op_lowerm
+    {
+        template <typename EXP>
+        struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
+        {
+            const static long cost = EXP::cost+1;
+            typedef typename EXP::type type;
+            template <typename M>
+            static type apply ( const M& m, long r, long c)
+            { 
+                if (r >= c)
+                    return m(r,c); 
+                else
+                    return 0;
+            }
+
+            template <typename M>
+            static type apply ( const M& m, const type& s, long r, long c)
+            { 
+                if (r > c)
+                    return m(r,c); 
+                else if (r==c)
+                    return s;
+                else
+                    return 0;
+            }
+        };
+    };
+
+    template <
+        typename EXP
+        >
+    const matrix_unary_exp<EXP,op_lowerm> lowerm (
+        const matrix_exp<EXP>& m
+    )
+    {
+        typedef matrix_unary_exp<EXP,op_lowerm> exp;
+        return exp(m.ref());
+    }
+
+    template <
+        typename EXP
+        >
+    const matrix_scalar_binary_exp<EXP, typename EXP::type,op_lowerm> lowerm (
+        const matrix_exp<EXP>& m,
+        typename EXP::type s
+        )
+    {
+        typedef matrix_scalar_binary_exp<EXP, typename EXP::type, op_lowerm> exp;
+        return exp(m.ref(),s);
+    }
+
+// ----------------------------------------------------------------------------------------
+
+    struct op_upperm
+    {
+        template <typename EXP>
+        struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
+        {
+            const static long cost = EXP::cost+1;
+            typedef typename EXP::type type;
+
+            template <typename M>
+            static type apply ( const M& m, long r, long c)
+            { 
+                if (r <= c)
+                    return m(r,c); 
+                else
+                    return 0;
+            }
+
+            template <typename M>
+            static type apply ( const M& m, const type& s, long r, long c)
+            { 
+                if (r < c)
+                    return m(r,c); 
+                else if (r==c)
+                    return s;
+                else
+                    return 0;
+            }
+        };
+    };
+
+
+    template <
+        typename EXP
+        >
+    const matrix_unary_exp<EXP,op_upperm> upperm (
+        const matrix_exp<EXP>& m
+    )
+    {
+        typedef matrix_unary_exp<EXP,op_upperm> exp;
+        return exp(m.ref());
+    }
+
+    template <
+        typename EXP
+        >
+    const matrix_scalar_binary_exp<EXP, typename EXP::type,op_upperm> upperm (
+        const matrix_exp<EXP>& m,
+        typename EXP::type s
+        )
+    {
+        typedef matrix_scalar_binary_exp<EXP, typename EXP::type ,op_upperm> exp;
+        return exp(m.ref(),s);
+    }
+
 // ----------------------------------------------------------------------------------------
 
 }

dlib/matrix/matrix_utilities_abstract.h

@@ -51,6 +51,82 @@ namespace dlib
             - returns the transpose of the matrix m
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    const matrix_exp lowerm (
+        const matrix_exp& m
+    );
+    /*!
+        ensures
+            - returns a matrix M such that:
+                - M::type == the same type that was in m
+                - M has the same dimensions as m
+                - M is the lower triangular part of m.  That is:
+                    - if (r >= c) then
+                        - M(r,c) == m(r,c)
+                    - else
+                        - M(r,c) == 0
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    const matrix_exp lowerm (
+        const matrix_exp& m,
+        const matrix_exp::type scalar_value
+    );
+    /*!
+        ensures
+            - returns a matrix M such that:
+                - M::type == the same type that was in m
+                - M has the same dimensions as m
+                - M is the lower triangular part of m except that the diagonal has
+                  been set to scalar_value.  That is:
+                    - if (r > c) then
+                        - M(r,c) == m(r,c)
+                    - else if (r == c) then
+                        - M(r,c) == scalar_value 
+                    - else
+                        - M(r,c) == 0
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    const matrix_exp upperm (
+        const matrix_exp& m
+    );
+    /*!
+        ensures
+            - returns a matrix M such that:
+                - M::type == the same type that was in m
+                - M has the same dimensions as m
+                - M is the upper triangular part of m.  That is:
+                    - if (r <= c) then
+                        - M(r,c) == m(r,c)
+                    - else
+                        - M(r,c) == 0
+    !*/
+
+// ----------------------------------------------------------------------------------------
+
+    const matrix_exp upperm (
+        const matrix_exp& m,
+        const matrix_exp::type scalar_value
+    );
+    /*!
+        ensures
+            - returns a matrix M such that:
+                - M::type == the same type that was in m
+                - M has the same dimensions as m
+                - M is the upper triangular part of m except that the diagonal has
+                  been set to scalar_value.  That is:
+                    - if (r < c) then
+                        - M(r,c) == m(r,c)
+                    - else if (r == c) then
+                        - M(r,c) == scalar_value 
+                    - else
+                        - M(r,c) == 0
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
     template <

dlib/test/matrix3.cpp

@@ -522,6 +522,54 @@ namespace
             dlog << LTRACE << "testing done";
         }
 
+
+        {
+            matrix<long> m(3,4), ml(3,4), mu(3,4);
+            m = 1,2,3,4,
+                4,5,6,7,
+                7,8,9,0;
+
+            ml = 1,0,0,0,
+                 4,5,0,0,
+                 7,8,9,0;
+
+            mu = 1,2,3,4,
+                 0,5,6,7,
+                 0,0,9,0;
+
+
+            DLIB_CASSERT(lowerm(m) == ml,"");
+            DLIB_CASSERT(upperm(m) == mu,"");
+
+            ml = 3,0,0,0,
+                 4,3,0,0,
+                 7,8,3,0;
+
+            mu = 4,2,3,4,
+                 0,4,6,7,
+                 0,0,4,0;
+
+            DLIB_CASSERT(lowerm(m,3) == ml,"");
+            DLIB_CASSERT(upperm(m,4) == mu,"");
+
+        }
+
+        {
+            matrix<long> m(3,4), row(1,3), col(2,1);
+            m = 1,2,3,4,
+                4,5,6,7,
+                7,8,9,0;
+
+            row = 4,5,6;
+            col = 3,6;
+
+            DLIB_CASSERT(rowm(m, 1, 3) == row,"");
+            DLIB_CASSERT(colm(m, 2, 2) == col,"");
+
+        }
+
+
+
     }