← Back to branch summary

~ubuntu-branches/ubuntu/saucy/deal.ii/saucy

« back to all changes in this revision

Viewing changes to contrib/boost/include/boost/lambda/numeric.hpp

  • Committer: Package Import Robot
  • Author(s): "Adam C. Powell, IV", Adam C. Powell, IV, Christophe Trophime
  • Date: 2012-02-21 06:57:30 UTC
  • mfrom: (3.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20120221065730-r2iz70lg557wcd2e
Tags: 7.1.0-1
http://bugs.debian.org/652057
http://bugs.debian.org/652058
http://bugs.debian.org/637655
http://bugs.debian.org/659245
[ Adam C. Powell, IV ]
* New upstream (closes: #652057).
* Updated to use PETSc and SLEPc 3.2, and forward-ported all patches.
* Removed NetCDF Build-Depends because it uses serial HDF5.
* Made Sacado cmath patch work with new configure.
* Moved -dev package symlink lines in rules to arch all section.

[ Christophe Trophime ]
* debian/rules:
   - add dh_strip --dbg-package to generate dbg package (closes: #652058)
   - add .install files to simplify rules
* Add support for mumps, arpack (closes: #637655)
* Add patch for slepc 3.2 (closes: #659245)

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/boost/include/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