Imported from /home/lorry/working-area/delta_boost-tarball/boost_1_54_0.tar.bz2.boost_1_54_0baserock/morph

1 files changed, 1377 insertions, 0 deletions

diff --git a/boost/lambda/algorithm.hpp b/boost/lambda/algorithm.hpp
new file mode 100644
index 000000000..ced5f4e00
--- /dev/null
+++ b/boost/lambda/algorithm.hpp
@@ -0,0 +1,1377 @@
+// -- algorithm.hpp -- Boost Lambda Library -----------------------------------
+// Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_LAMBDA_ALGORITHM_HPP
+#define BOOST_LAMBDA_ALGORITHM_HPP
+
+#include "boost/lambda/core.hpp"
+
+#include <algorithm>
+#include <iterator>  // for iterator_traits
+#include <utility> // for std::pair
+
+namespace boost {
+  namespace lambda {
+
+namespace ll {
+
+// for_each ---------------------------------
+
+struct for_each {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  C
+  operator()(A a, A b, C c) const
+  { return ::std::for_each(a, b, c); }
+};
+
+// find  ---------------------------------
+
+struct find {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, const C& c) const
+  { return ::std::find(a, b, c); }
+};
+
+
+// find_if  ---------------------------------
+
+struct find_if {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c) const
+  { return ::std::find_if(a, b, c); }
+};
+
+// find_end  ---------------------------------
+
+struct find_end {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c, C d) const
+  { return ::std::find_end(a, b, c, d); }
+
+  template <class A, class C, class E>
+  A
+  operator()(A a, A b, C c, C d, E e) const
+  { return ::std::find_end(a, b, c, d, e); }
+
+};
+
+// find_first_of  ---------------------------------
+
+struct find_first_of {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c, C d) const
+  { return ::std::find_first_of(a, b, c, d); }
+
+  template <class A, class C, class E>
+  A
+  operator()(A a, A b, C c, C d, E e) const
+  { return ::std::find_first_of(a, b, c, d, e); }
+
+};
+
+// adjacent_find  ---------------------------------
+
+struct adjacent_find {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A>
+  A
+  operator()(A a, A b) const
+  { return ::std::adjacent_find(a, b); }
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c) const
+  { return ::std::adjacent_find(a, b, c); }
+
+};
+
+// count  ---------------------------------
+
+struct count {
+
+  template <class Args>
+  struct sig { 
+    typedef typename ::std::iterator_traits<
+      typename boost::remove_const<
+           typename boost::tuples::element<1, Args>::type
+      >::type 
+    >::difference_type type;
+  };
+
+  template <class A, class C >
+  typename ::std::iterator_traits<A>::difference_type
+  operator()(A a, A b, const C& c) const
+  { return ::std::count(a, b, c); }
+};
+
+// count_if  ---------------------------------
+
+struct count_if {
+
+  template <class Args>
+  struct sig { 
+    typedef typename ::std::iterator_traits<
+     typename boost::remove_const<
+           typename boost::tuples::element<1, Args>::type
+       >::type
+    >::difference_type type;
+  };
+
+  template <class A, class C >
+  typename ::std::iterator_traits<A>::difference_type
+  operator()(A a, A b, C c) const
+  { return ::std::count_if(a, b, c); }
+};
+
+
+// mismatch  ---------------------------------
+
+struct mismatch {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type
+     >::type element1_type; 
+
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type
+     >::type element2_type; 
+
+    typedef ::std::pair< element1_type, element2_type > type;
+   };
+
+  template <class A, class C >
+  ::std::pair<A,C>
+  operator()(A a, A b, C c) const
+  { return ::std::mismatch(a, b, c); }
+
+  template <class A, class C, class D>
+  ::std::pair<A,C>
+  operator()(A a, A b, C c, D d) const
+  { return ::std::mismatch(a, b, c, d); }
+
+};
+
+// equal  ---------------------------------
+
+struct equal {
+
+  template <class Args>
+  struct sig { 
+    typedef bool type;
+  };
+
+  template <class A, class C >
+  bool
+  operator()(A a, A b, C c) const
+  { return ::std::equal(a, b, c); }
+
+  template <class A, class C, class D>
+  bool
+  operator()(A a, A b, C c, D d) const
+  { return ::std::equal(a, b, c, d); }
+
+};
+
+// search --------------------------------
+
+struct search {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c, C d) const
+  { return std::search(a, b, c, d);}
+
+  template <class A, class C, class E>
+  A
+  operator()(A a, A b, C c, C d, E e) const
+  { return std::search(a, b, c, d, e);}
+
+};
+
+// copy  ---------------------------------
+
+struct copy {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  C
+  operator()(A a, A b, C c) const
+  { return ::std::copy(a, b, c); }
+
+};
+
+// copy_backward  ---------------------------------
+
+struct copy_backward {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  C
+  operator()(A a, A b, C c) const
+  { return ::std::copy_backward(a, b, c); }
+
+};
+
+// swap  ---------------------------------
+
+struct swap {
+
+  template <class Args>
+  struct sig { 
+    typedef void type; 
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b) const
+  { ::std::swap(a, b); }
+
+};
+
+// swap_ranges  ---------------------------------
+
+struct swap_ranges {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  C
+  operator()(A a, A b, C c) const
+  { return ::std::swap_ranges(a, b, c); }
+
+};
+
+// iter_swap  ---------------------------------
+
+struct iter_swap {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A>
+  void 
+  operator()(A a, A b) const
+  { ::std::iter_swap(a, b); }
+
+};
+
+
+// transform --------------------------------
+
+struct transform {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<
+          boost::tuples::length<Args>::value - 2, 
+          Args
+      >::type
+     >::type type; 
+  };
+
+  template <class A, class C, class D>
+  C
+  operator()(A a, A b, C c, D d) const
+  { return std::transform(a, b, c, d);}
+
+  template <class A, class C, class D, class E>
+  D
+  operator()(A a, A b, C c, D d, E e) const
+  { return std::transform(a, b, c, d, e);}
+
+};
+
+// replace  ---------------------------------
+
+struct replace {
+
+  template <class Args>
+  struct sig {
+    typedef void type;
+  };
+
+  template <class A, class C>
+  void
+  operator()(A a, A b, const C& c, const C& d) const
+  { ::std::replace(a, b, c, d); }
+
+};
+
+// replace_if  ---------------------------------
+
+struct replace_if {
+
+  template <class Args>
+  struct sig {
+    typedef void type;
+  };
+
+  template <class A, class C, class D>
+  void
+  operator()(A a, A b, C c, const D& d) const
+  { ::std::replace_if(a, b, c, d); }
+
+};
+
+// replace_copy  ---------------------------------
+
+struct replace_copy {
+
+ template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C, class D>
+  C
+  operator()(A a, A b, C c, const D& d, const D& e) const
+  { return ::std::replace_copy(a, b, c, d, e); }
+
+};
+
+// replace_copy_if  ---------------------------------
+
+struct replace_copy_if {
+
+ template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C, class D, class E>
+  C
+  operator()(A a, A b, C c, D d, const E& e) const
+  { return ::std::replace_copy_if(a, b, c, d, e); }
+
+};
+
+// fill  ---------------------------------
+
+struct fill {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A, class C>
+  void 
+  operator()(A a, A b, const C& c) const
+  { ::std::fill(a, b, c); }
+
+};
+
+// fill_n  ---------------------------------
+
+struct fill_n {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A, class B, class C>
+  void 
+  operator()(A a, B b, const C& c) const
+  { ::std::fill_n(a, b, c); }
+
+};
+
+// generate  ---------------------------------
+
+struct generate {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A, class C>
+  void 
+  operator()(A a, A b, C c) const
+  { ::std::generate(a, b, c); }
+
+};
+
+// generate_n  ---------------------------------
+
+struct generate_n {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A, class B, class C>
+  void 
+  operator()(A a, B b, C c) const
+  { ::std::generate_n(a, b, c); }
+
+};
+
+// remove  ---------------------------------
+
+struct remove {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C >
+  A
+  operator()(A a, A b, const C& c) const
+  { return ::std::remove(a, b, c); }
+};
+
+// remove_if  ---------------------------------
+
+struct remove_if {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+       typename boost::tuples::element<1, Args>::type
+     >::type type; 
+  };
+
+  template <class A, class C >
+  A
+  operator()(A a, A b, C c) const
+  { return ::std::remove_if(a, b, c); }
+};
+
+// remove_copy  ---------------------------------
+
+struct remove_copy {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+       typename boost::tuples::element<3, Args>::type
+     >::type type; 
+  };
+
+  template <class A, class C, class D >
+  C
+  operator()(A a, A b, C c, const D& d) const
+  { return ::std::remove_copy(a, b, c, d); }
+};
+
+// remove_copy_if  ---------------------------------
+
+struct remove_copy_if {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+       typename boost::tuples::element<3, Args>::type
+     >::type type; 
+  };
+
+  template <class A, class C, class D >
+  C
+  operator()(A a, A b, C c, D d) const
+  { return ::std::remove_copy_if(a, b, c, d); }
+};
+
+// unique  ---------------------------------
+
+struct unique {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A>
+  A
+  operator()(A a, A b) const
+  { return ::std::unique(a, b); }
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c) const
+  { return ::std::unique(a, b, c); }
+
+};
+
+// unique_copy  ---------------------------------
+
+struct unique_copy {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C >
+  C
+  operator()(A a, A b, C c) const
+  { return ::std::unique_copy(a, b, c); }
+
+  template <class A, class C, class D>
+  C
+  operator()(A a, A b, C c, D d) const
+  { return ::std::unique_copy(a, b, c, d); }
+
+};
+
+// reverse  ---------------------------------
+
+struct reverse {
+
+  template <class Args>
+  struct sig { 
+    typedef void type; 
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b) const
+  { ::std::reverse(a, b); }
+
+};
+
+// reverse_copy  ---------------------------------
+
+struct reverse_copy {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C >
+  C
+  operator()(A a, A b, C c) const
+  { return ::std::reverse_copy(a, b, c); }
+
+};
+
+// rotate  ---------------------------------
+
+struct rotate {
+
+  template <class Args>
+  struct sig { 
+    typedef void type; 
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b, A c) const
+  { ::std::rotate(a, b, c); }
+
+};
+
+// rotate_copy  ---------------------------------
+
+struct rotate_copy {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<3, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class D>
+  D
+  operator()(A a, A b, A c, D d) const
+  { return ::std::rotate_copy(a, b, c, d); }
+
+};
+
+// random_shuffle  ---------------------------------
+
+struct random_shuffle {
+
+  template <class Args>
+  struct sig { 
+    typedef void type; 
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b) const
+  { ::std::random_shuffle(a, b); }
+
+  template <class A, class C>
+  void
+  operator()(A a, A b, const C& c) const
+  { ::std::random_shuffle(a, b, c); }
+
+};
+
+
+// partition  ---------------------------------
+
+struct partition {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c) const
+  { return ::std::partition(a, b, c); }
+
+};
+
+// stable_partition  ---------------------------------
+
+struct stable_partition {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c) const
+  { return ::std::stable_partition(a, b, c); }
+
+};
+
+// sort  ---------------------------------
+
+struct sort {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A>
+  void 
+  operator()(A a, A b) const
+  { ::std::sort(a, b); }
+
+  template <class A, class C>
+  void 
+  operator()(A a, A b, C c) const
+  { ::std::sort(a, b, c); }
+
+};
+
+// stable_sort  ---------------------------------
+
+struct stable_sort {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A>
+  void 
+  operator()(A a, A b) const
+  { ::std::stable_sort(a, b); }
+
+  template <class A, class C>
+  void 
+  operator()(A a, A b, C c) const
+  { ::std::stable_sort(a, b, c); }
+
+};
+
+// partial_sort  ---------------------------------
+
+struct partial_sort {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A>
+  void 
+  operator()(A a, A b, A c) const
+  { ::std::partial_sort(a, b, c); }
+
+  template <class A, class D>
+  void 
+  operator()(A a, A b, A c, D d) const
+  { ::std::partial_sort(a, b, c, d); }
+
+};
+
+// partial_sort_copy  ---------------------------------
+
+struct partial_sort_copy {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+       typename boost::tuples::element<3, Args>::type
+     >::type type; 
+  };
+
+  template <class A, class C>
+  C
+  operator()(A a, A b, C c, C d) const
+  { return ::std::partial_sort_copy(a, b, c, d); }
+
+  template <class A, class C, class E >
+  C
+  operator()(A a, A b, C c, C d, E e) const
+  { return ::std::partial_sort_copy(a, b, c, d, e); }
+};
+
+// nth_element  ---------------------------------
+
+struct nth_element {
+
+  template <class Args>
+  struct sig { 
+     typedef void type; 
+  };
+
+  template <class A>
+  void 
+  operator()(A a, A b, A c) const
+  { ::std::nth_element(a, b, c); }
+
+  template <class A, class D>
+  void 
+  operator()(A a, A b, A c, D d) const
+  { ::std::nth_element(a, b, c, d); }
+
+};
+
+// lower_bound  ---------------------------------
+
+struct lower_bound {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, const C& c) const
+  { return ::std::lower_bound(a, b, c); }
+
+  template <class A, class C, class D>
+  A
+  operator()(A a, A b, const C& c, D d) const
+  { return ::std::lower_bound(a, b, c, d); }
+
+};
+
+// upper_bound  ---------------------------------
+
+struct upper_bound {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, const C& c) const
+  { return ::std::upper_bound(a, b, c); }
+
+  template <class A, class C, class D>
+  A
+  operator()(A a, A b, const C& c, D d) const
+  { return ::std::upper_bound(a, b, c, d); }
+
+};
+
+// equal_range  ---------------------------------
+
+struct equal_range {
+
+ template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type
+     >::type element_type; 
+
+    typedef ::std::pair< element_type, element_type > type;
+   };
+
+  template <class A, class C>
+  ::std::pair<A,A>
+  operator()(A a, A b, const C& c) const
+  { return ::std::equal_range(a, b, c); }
+
+  template <class A, class C, class D>
+  ::std::pair<A,A>
+  operator()(A a, A b, const C& c, D d) const
+  { return ::std::equal_range(a, b, c, d); }
+
+};
+
+// binary_search  ---------------------------------
+
+struct binary_search {
+
+  template <class Args>
+  struct sig { 
+    typedef bool type;
+  };
+
+  template <class A, class C >
+  bool
+  operator()(A a, A b, const C& c) const
+  { return ::std::binary_search(a, b, c); }
+
+  template <class A, class C, class D>
+  bool
+  operator()(A a, A b, const C& c, D d) const
+  { return ::std::binary_search(a, b, c, d); }
+
+};
+
+// merge --------------------------------
+
+struct merge {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<5, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C, class E>
+  E
+  operator()(A a, A b, C c, C d, E e) const
+  { return std::merge(a, b, c, d, e);}
+
+  template <class A, class C, class E, class F>
+  E
+  operator()(A a, A b, C c, C d, E e, F f) const
+  { return std::merge(a, b, c, d, e, f);}
+
+};
+
+// inplace_merge  ---------------------------------
+
+struct inplace_merge {
+
+  template <class Args>
+  struct sig {
+    typedef void type;
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b, A c) const
+  { ::std::inplace_merge(a, b, c); }
+
+  template <class A, class D>
+  void
+  operator()(A a, A b, A c, D d) const
+  { ::std::inplace_merge(a, b, c, d); }
+
+};
+
+// includes  ---------------------------------
+
+struct includes {
+
+  template <class Args>
+  struct sig { 
+    typedef bool type;
+  };
+
+  template <class A, class C>
+  bool
+  operator()(A a, A b, C c, C d) const
+  { return ::std::includes(a, b, c, d); }
+
+  template <class A, class C, class E>
+  bool
+  operator()(A a, A b, C c, C d, E e) const
+  { return ::std::includes(a, b, c, d, e); }
+
+};
+
+// set_union --------------------------------
+
+struct set_union {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<5, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C, class E>
+  E
+  operator()(A a, A b, C c, C d, E e) const
+  { return std::set_union(a, b, c, d, e);}
+
+  template <class A, class C, class E, class F>
+  E
+  operator()(A a, A b, C c, C d, E e, F f) const
+  { return std::set_union(a, b, c, d, e, f);}
+
+};
+
+// set_intersection --------------------------------
+
+struct set_intersection {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<5, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C, class E>
+  E
+  operator()(A a, A b, C c, C d, E e) const
+  { return std::set_intersection(a, b, c, d, e);}
+
+  template <class A, class C, class E, class F>
+  E
+  operator()(A a,  A b, C c, C d, E e, F f) const
+  { return std::set_intersection(a, b, c, d, e, f);}
+
+};
+
+// set_difference --------------------------------
+
+struct set_difference {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<5, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C, class E>
+  E
+  operator()(A a, A b, C c, C d, E e) const
+  { return std::set_difference(a, b, c, d, e);}
+
+  template <class A, class C, class E, class F>
+  E
+  operator()(A a, A b, C c, C d, E e, F f) const
+  { return std::set_difference(a, b, c, d, e, f);}
+
+};
+
+
+// set_symmetric_difference --------------------------------
+
+struct set_symmetric_difference {
+  
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<5, Args>::type 
+     >::type type; 
+  };
+
+  template <class A, class C, class E>
+  E
+  operator()(A a, A b, C c, C d, E e) const
+  { return std::set_symmetric_difference(a, b, c, d, e);}
+
+  template <class A, class C, class E, class F>
+  E
+  operator()(A a, A b, C c, C d, E e, F f) const
+  { return std::set_symmetric_difference(a, b, c, d, e, f);}
+
+};
+
+// push_heap  ---------------------------------
+
+struct push_heap {
+
+  template <class Args>
+  struct sig { 
+    typedef void type; 
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b) const
+  { ::std::push_heap(a, b); }
+
+  template <class A, class C>
+  void
+  operator()(A a, A b, C c) const
+  { ::std::push_heap(a, b, c); }
+
+};
+
+// pop_heap  ---------------------------------
+
+struct pop_heap {
+
+  template <class Args>
+  struct sig { 
+    typedef void type; 
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b) const
+  { ::std::pop_heap(a, b); }
+
+  template <class A, class C>
+  void
+  operator()(A a, A b, C c) const
+  { ::std::pop_heap(a, b, c); }
+
+};
+
+
+// make_heap  ---------------------------------
+
+struct make_heap {
+
+  template <class Args>
+  struct sig { 
+    typedef void type; 
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b) const
+  { ::std::make_heap(a, b); }
+
+  template <class A, class C>
+  void
+  operator()(A a, A b, C c) const
+  { ::std::make_heap(a, b, c); }
+
+};
+
+// sort_heap  ---------------------------------
+
+struct sort_heap {
+
+  template <class Args>
+  struct sig { 
+    typedef void type; 
+  };
+
+  template <class A>
+  void
+  operator()(A a, A b) const
+  { ::std::sort_heap(a, b); }
+
+  template <class A, class C>
+  void
+  operator()(A a, A b, C c) const
+  { ::std::sort_heap(a, b, c); }
+
+};
+
+// min  ---------------------------------
+
+struct min {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A>
+  A
+  operator()(const A& a, const A& b) const
+  { return (::std::min)(a, b); }
+
+  template <class A, class C>
+  A
+  operator()(const A& a, const A& b, C c) const
+  { return (::std::min)(a, b, c); }
+
+};
+
+// max  ---------------------------------
+
+struct max {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A>
+  A
+  operator()(const A& a, const A& b) const
+  { return (::std::max)(a, b); }
+
+  template <class A, class C>
+  A
+  operator()(const A& a, const A& b, C c) const
+  { return (::std::max)(a, b, c); }
+
+};
+
+struct min_element {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A>
+  A
+  operator()(A a, A b) const
+  { return ::std::min_element(a, b); }
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c) const
+  { return ::std::min_element(a, b, c); }
+
+};
+
+// max_element  ---------------------------------
+
+struct max_element {
+
+  template <class Args>
+  struct sig { 
+    typedef typename boost::remove_const<
+        typename boost::tuples::element<1, Args>::type 
+     >::type type; 
+  };
+
+  template <class A>
+  A
+  operator()(A a, A b) const
+  { return ::std::max_element(a, b); }
+
+  template <class A, class C>
+  A
+  operator()(A a, A b, C c) const
+  { return ::std::max_element(a, b, c); }
+
+};
+
+
+// lexicographical_compare  ---------------------------------
+
+struct lexicographical_compare {
+
+  template <class Args>
+  struct sig { 
+    typedef bool type;
+  };
+
+  template <class A, class C>
+  bool
+  operator()(A a, A b, C c, C d) const
+  { return ::std::lexicographical_compare(a, b, c, d); }
+
+  template <class A, class C, class E>
+  bool
+  operator()(A a, A b, C c, C d, E e) const
+  { return ::std::lexicographical_compare(a, b, c, d, e); }
+
+};
+
+// next_permutation  ---------------------------------
+
+struct next_permutation {
+
+  template <class Args>
+  struct sig { 
+    typedef bool type;
+  };
+
+  template <class A>
+  bool
+  operator()(A a, A b) const
+  { return ::std::next_permutation(a, b); }
+
+  template <class A, class C >
+  bool
+  operator()(A a, A b, C c) const
+  { return ::std::next_permutation(a, b, c); }
+
+};
+
+// prev_permutation  ---------------------------------
+
+struct prev_permutation {
+
+  template <class Args>
+  struct sig { 
+    typedef bool type;
+  };
+
+  template <class A>
+  bool
+  operator()(A a, A b) const
+  { return ::std::prev_permutation(a, b); }
+
+  template <class A, class C >
+  bool
+  operator()(A a, A b, C c) const
+  { return ::std::prev_permutation(a, b, c); }
+
+};
+
+
+
+
+
+} // end of ll namespace
+
+// There is no good way to call an overloaded member function in a 
+// lambda expression. 
+// The macro below defines a function object class for calling a
+// const_iterator returning member function of a container.
+
+#define CALL_MEMBER(X)                                     \
+struct call_##X {                                          \
+template <class Args>                                      \
+  struct sig {                                             \
+    typedef typename boost::remove_const<                  \
+        typename boost::tuples::element<1, Args>::type     \
+     >::type::const_iterator type;                         \
+  };                                                       \
+                                                           \
+  template<class T>                                        \
+  typename T::const_iterator                               \
+  operator()(const T& t) const                             \
+  {                                                        \
+    return t.X();                                          \
+  }                                                        \
+};
+
+// create call_begin and call_end classes
+CALL_MEMBER(begin)
+CALL_MEMBER(end)
+
+#undef CALL_MEMBER
+
+} // end of lambda namespace
+} // end of boost namespace
+
+
+
+#endif