boost/lambda/numeric.hpp

   1 // -- numeric.hpp -- Boost Lambda Library -----------------------------------
   2 // Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
   3 // Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
   4 //
   5 // Distributed under the Boost Software License, Version 1.0. (See
   6 // accompanying file LICENSE_1_0.txt or copy at
   7 // http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 // For more information, see http://www.boost.org
  10
  11 #ifndef BOOST_LAMBDA_NUMERIC_HPP
  12 #define BOOST_LAMBDA_NUMERIC_HPP
  13
  14 #include "boost/lambda/core.hpp"
  15
  16 #include <numeric>
  17
  18 namespace boost {
  19   namespace lambda {
  20
  21 namespace ll {
  22
  23 // accumulate ---------------------------------
  24
  25 struct accumulate {
  26
  27   template <class Args>
  28   struct sig {
  29     typedef typename boost::remove_const<
  30         typename boost::tuples::element<3, Args>::type
  31      >::type type;
  32   };
  33
  34   template <class A, class B, class C>
  35   C
  36   operator()(A a, B b, C c) const
  37   { return ::std::accumulate(a, b, c); }
  38
  39   template <class A, class B, class C, class D>
  40   C
  41   operator()(A a, B b, C c, D d) const
  42   { return ::std::accumulate(a, b, c, d); }
  43 };
  44
  45 // inner_product ---------------------------------
  46
  47 struct inner_product {
  48
  49   template <class Args>
  50   struct sig {
  51     typedef typename boost::remove_const<
  52         typename boost::tuples::element<4, Args>::type
  53      >::type type;
  54   };
  55
  56   template <class A, class B, class C, class D>
  57   D
  58   operator()(A a, B b, C c, D d) const
  59   { return ::std::inner_product(a, b, c, d); }
  60
  61   template <class A, class B, class C, class D, class E, class F>
  62   D
  63   operator()(A a, B b, C c, D d, E e, F f) const
  64   { return ::std::inner_product(a, b, c, d, e, f); }
  65 };
  66
  67
  68 // partial_sum ---------------------------------
  69
  70 struct partial_sum {
  71
  72   template <class Args>
  73   struct sig {
  74     typedef typename boost::remove_const<
  75         typename boost::tuples::element<3, Args>::type
  76      >::type type;
  77   };
  78
  79   template <class A, class B, class C>
  80   C
  81   operator()(A a, B b, C c) const
  82   { return ::std::partial_sum(a, b, c); }
  83
  84   template <class A, class B, class C, class D>
  85   C
  86   operator()(A a, B b, C c, D d) const
  87   { return ::std::partial_sum(a, b, c, d); }
  88 };
  89
  90 // adjacent_difference ---------------------------------
  91
  92 struct adjacent_difference {
  93
  94   template <class Args>
  95   struct sig {
  96     typedef typename boost::remove_const<
  97         typename boost::tuples::element<3, Args>::type
  98      >::type type;
  99   };
 100
 101   template <class A, class B, class C>
 102   C
 103   operator()(A a, B b, C c) const
 104   { return ::std::adjacent_difference(a, b, c); }
 105
 106   template <class A, class B, class C, class D>
 107   C
 108   operator()(A a, B b, C c, D d) const
 109   { return ::std::adjacent_difference(a, b, c, d); }
 110 };
 111
 112 } // end of ll namespace
 113
 114 } // end of lambda namespace
 115 } // end of boost namespace
 116
 117
 118
 119 #endif