Changeset 2274

Timestamp:

Jun 23, 2010, 12:02:30 AM (13 years ago)

Author:

Peter

Message:

adding functor f_gxy and f_gx (similar to f_gx_hy) and adding some tests for all three classes above.

Location:

trunk

Files:

• test/utility_test.cc (modified) (3 diffs)
• yat/utility/stl_utility.h (modified) (4 diffs)

trunk/test/utility_test.cc

@@ -63 +63 @@
 void test_less_nan(test::Suite& suite);
 void test_ptr_compare(test::Suite& suite);
+void test_compose_functors(test::Suite& suite);
 
 int main(int argc, char* argv[])
@@ -175 +176 @@
   test_load2(suite);
 
+  test_compose_functors(suite);
+
   return suite.return_value();
 }
@@ -200 +203 @@
   suite.add(false);
 }
+
+
+void test_compose_functors(test::Suite& suite)
+{
+  typedef utility::abs<double> U1;
+  // we use float here to check conversion from float to double in functors
+  typedef utility::Exp<float> U2;
+  typedef std::plus<double> B;
+  U1 u1;
+  U2 u2;
+  B b;
+
+  utility::compose_f_gx_hy<B, U1, U2> binary = 
+    utility::make_compose_f_gx_hy(b, u1, u2);
+
+  utility::compose_f_gxy<U2, B> binary2 = 
+    utility::make_compose_f_gxy(u2, b);
+
+  utility::compose_f_gx<U1, U2> unary = 
+    utility::make_compose_f_gx(u1, u2);
+}
+
 
 

trunk/yat/utility/stl_utility.h

@@ -106 +106 @@
    */
   template<class F, class G, class H>
-  class compose_f_gx_hy : std::binary_function<typename G::argument_type,
-                                               typename H::argument_type,
-                                               typename F::result_type>
+  class compose_f_gx_hy : 
+    public std::binary_function<typename G::argument_type,
+                                typename H::argument_type,
+                                typename F::result_type>
   {
   public:
@@ -115 +116 @@
      */
     compose_f_gx_hy(F f, G g, H h)
-      : f_(f), g_(g), h_(h) {}
+      : f_(f), g_(g), h_(h) 
+    {
+      BOOST_CONCEPT_ASSERT((boost::Convertible<typename G::result_type
+                            , typename F::first_argument_type>));
+      BOOST_CONCEPT_ASSERT((boost::Convertible<typename H::result_type
+                            , typename F::second_argument_type>));
+
+    }
 
     /**
@@ -136 +144 @@
      Convenient function to create a compose_f_gx_hy.
 
+     \relates compose_f_gx_hy
+
      \see std::make_pair
   */
@@ -143 +153 @@
     return compose_f_gx_hy<F,G,H>(f,g,h);
   }  
+
+
+  /**
+     See The C++ Standard Library - A Tutorial and Reference by
+     Nicolai M. Josuttis
+
+     If f is a unary functor, g is a binary functor, and return type
+     of g is convertible to F's argument type, then
+     compose_f_gxy can be used to create a functor equivalent to
+     \f$ f(g(x,y)) \f$
+
+     F must be an adaptable unary functor
+     G must be an adaptable binary functor
+
+     \since New in yat 0.7
+   */
+  template<class F, class G>
+  class compose_f_gxy : 
+    public std::binary_function<typename G::first_argument_type,
+                                typename G::second_argument_type,
+                                typename F::result_type>
+  {
+  public:
+    /**
+       \brief Constructor
+     */
+    compose_f_gxy(F f, G g)
+      : f_(f), g_(g) 
+    {
+      BOOST_CONCEPT_ASSERT((boost::Convertible<typename G::result_type
+                            , typename F::argument_type>));
+    }
+
+    /**
+       \brief Does the work
+     */
+    typename F::result_type
+    operator()(typename G::first_argument_type x, 
+               typename G::second_argument_type y) const
+    {
+      return f_(g_(x,y));
+    }
+
+  private:
+    F f_;
+    G g_;
+  };
+
+  /**
+     Convenient function to create a compose_f_gxy.
+
+     \relates compose_f_gxy
+
+     \see std::make_pair
+
+     \since New in yat 0.7
+  */
+  template<class F, class G>
+  compose_f_gxy<F, G> make_compose_f_gxy(F f, G g)
+  {
+    return compose_f_gxy<F,G>(f,g);
+  }  
+
+
+  /**
+     See The C++ Standard Library - A Tutorial and Reference by
+     Nicolai M. Josuttis
+
+     If f is a unary functor, g is a unary functor, and return type of
+     g is convertible to F's argument type, then compose_f_gx can be
+     used to create a functor equivalent to \f$ f(g(x)) \f$
+
+     F must be an adaptable binary functor
+     G must be an adaptable unary functor
+
+     \since New in yat 0.7
+   */
+  template<class F, class G>
+  class compose_f_gx : public std::unary_function<typename G::argument_type,
+                                                  typename F::result_type>
+  {
+  public:
+    /**
+       \brief Constructor
+     */
+    compose_f_gx(F f, G g)
+      : f_(f), g_(g) 
+    {
+      BOOST_CONCEPT_ASSERT((boost::Convertible<typename G::result_type
+                            , typename F::argument_type>));
+    }
+
+    /**
+       \brief Does the work
+     */
+    typename F::result_type
+    operator()(typename G::argument_type x) const
+    {
+      return f_(g_(x));
+    }
+
+  private:
+    F f_;
+    G g_;
+  };
+
+  /**
+     Convenient function to create a compose_f_gx.
+
+     \relates compose_f_gx
+
+     \see std::make_pair
+
+     \since New in yat 0.7
+  */
+  template<class F, class G>
+  compose_f_gx<F, G> make_compose_f_gx(F f, G g)
+  {
+    return compose_f_gx<F,G>(f,g);
+  }  
+
 
   /**