Added the reciprocal_max() function.

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

dlib/matrix/matrix_math_functions.h

@@ -292,6 +292,43 @@ DLIB_MATRIX_SIMPLE_STD_FUNCTION(atan,7)
         return matrix_unary_exp<EXP,op_reciprocal>(m.ref());
     }
 
+// ----------------------------------------------------------------------------------------
+
+    struct op_reciprocal_max
+    {
+        template <typename EXP>
+        struct op : has_nondestructive_aliasing, preserves_dimensions<EXP>
+        {
+            const static long cost = EXP::cost+6;
+            typedef typename EXP::type type;
+            template <typename M>
+            static type apply ( const M& m, long r, long c)
+            { 
+                const type temp = m(r,c);
+                if (temp != static_cast<type>(0))
+                    return static_cast<type>((type)1.0/temp);
+                else
+                    return std::numeric_limits<type>::max();
+            }
+        };
+    };
+
+    template <
+        typename EXP
+        >
+    const matrix_unary_exp<EXP,op_reciprocal_max> reciprocal_max (
+        const matrix_exp<EXP>& m
+    )
+    {
+        // you can only compute reciprocal_max matrices that contain floats, doubles or long doubles.
+        COMPILE_TIME_ASSERT((
+                is_same_type<typename EXP::type,float>::value == true || 
+                is_same_type<typename EXP::type,double>::value == true || 
+                is_same_type<typename EXP::type,long double>::value == true 
+        ));
+        return matrix_unary_exp<EXP,op_reciprocal_max>(m.ref());
+    }
+
 // ----------------------------------------------------------------------------------------
 
     struct op_normalize

dlib/matrix/matrix_math_functions_abstract.h

@@ -188,6 +188,25 @@ namespace dlib
                         - R(r,c) == 0
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    const matrix_exp reciprocal_max (
+        const matrix_exp& m
+    );
+    /*!
+        requires
+            - matrix_exp::type == float, double, long double
+        ensures
+            - returns a matrix R such that:
+                - R::type == the same type that was in m
+                - R has the same dimensions as m
+                - for all valid r and c:
+                    - if (m(r,c) != 0) then
+                        - R(r,c) == 1.0/m(r,c) 
+                    - else
+                        - R(r,c) == std::numeric_limits<R::type>::max() 
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
     const matrix_exp normalize (

dlib/test/matrix.cpp

@@ -1128,6 +1128,24 @@ namespace
             DLIB_TEST(colm(m,5) == c5);
         }
 
+
+        {
+            matrix<double> m(2,2), mr(2,2), mr_max(2,2);
+
+            m = 1, 2,
+                0, 4;
+
+            mr = 1, 1.0/2.0,
+                0,  1.0/4.0;
+
+            mr_max = 1, 1.0/2.0,
+                     std::numeric_limits<double>::max(),  1.0/4.0;
+
+            DLIB_TEST(equal(reciprocal(m), mr));
+            DLIB_TEST(equal(reciprocal_max(m), mr_max));
+
+        }
+
     }