Statistics
| Revision:

root / tmp / org.txm.statsengine.r.core.win32 / res / win32 / library / BH / include / boost / accumulators / numeric / functional_fwd.hpp @ 2486

History | View | Annotate | Download (9.2 kB)

1
///////////////////////////////////////////////////////////////////////////////
2
/// \file functional_fwd.hpp
3
///
4
//  Copyright 2005 Eric Niebler. Distributed under the Boost
5
//  Software License, Version 1.0. (See accompanying file
6
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7

    
8
#ifndef BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005
9
#define BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005
10

    
11
#include <boost/mpl/if.hpp>
12
#include <boost/mpl/placeholders.hpp>
13
#include <boost/utility/enable_if.hpp>
14
#include <boost/type_traits/is_same.hpp>
15
#include <boost/type_traits/is_const.hpp>
16

    
17
namespace boost { namespace numeric
18
{
19
    // For using directives -- this namespace may be re-opened elsewhere
20
    namespace operators
21
    {}
22

    
23
    namespace op
24
    {
25
        using mpl::_;
26
        using mpl::_1;
27
        using mpl::_2;
28
    }
29

    
30
    namespace functional
31
    {
32
        using namespace operators;
33

    
34
        template<typename T>
35
        struct tag
36
        {
37
            typedef void type;
38
        };
39

    
40
        template<typename T>
41
        struct tag<T const>
42
          : tag<T>
43
        {};
44

    
45
        template<typename T>
46
        struct tag<T volatile>
47
          : tag<T>
48
        {};
49

    
50
        template<typename T>
51
        struct tag<T const volatile>
52
          : tag<T>
53
        {};
54

    
55
        template<typename T>
56
        struct static_;
57

    
58
        template<typename A0, typename A1>
59
        struct are_integral;
60
    }
61

    
62
    /// INTERNAL ONLY
63
    ///
64
#define BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(Name, Op)                                     \
65
    namespace functional                                                                        \
66
    {                                                                                           \
67
        template<typename Arg, typename EnableIf = void>                                        \
68
        struct Name ## _base;                                                                   \
69
        template<typename Arg, typename ArgTag = typename tag<Arg>::type>                       \
70
        struct Name;                                                                            \
71
    }                                                                                           \
72
    namespace op                                                                                \
73
    {                                                                                           \
74
        struct Name;                                                                            \
75
    }                                                                                           \
76
    namespace                                                                                   \
77
    {                                                                                           \
78
        extern op::Name const &Name;                                                            \
79
    }
80

    
81
    /// INTERNAL ONLY
82
    ///
83
#define BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(Name)                                        \
84
    namespace functional                                                                        \
85
    {                                                                                           \
86
        template<typename Left, typename Right, typename EnableIf = void>                       \
87
        struct result_of_ ## Name;                                                              \
88
        template<typename Left, typename Right, typename EnableIf = void>                       \
89
        struct Name ## _base;                                                                   \
90
        template<                                                                               \
91
            typename Left                                                                       \
92
          , typename Right                                                                      \
93
          , typename LeftTag = typename tag<Left>::type                                         \
94
          , typename RightTag = typename tag<Right>::type                                       \
95
        >                                                                                       \
96
        struct Name;                                                                            \
97
    }                                                                                           \
98
    namespace op                                                                                \
99
    {                                                                                           \
100
        struct Name;                                                                            \
101
    }                                                                                           \
102
    namespace                                                                                   \
103
    {                                                                                           \
104
        extern op::Name const &Name;                                                            \
105
    }
106

    
107
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus)
108
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus)
109
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies)
110
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides)
111
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus)
112
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater)
113
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater_equal)
114
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less)
115
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less_equal)
116
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(equal_to)
117
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(not_equal_to)
118

    
119
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(assign)
120
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus_assign)
121
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus_assign)
122
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies_assign)
123
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides_assign)
124
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus_assign)
125

    
126
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_plus, +)
127
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_minus, -)
128
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(complement, ~)
129
    BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(logical_not, !)
130

    
131
#undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP
132
#undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP
133

    
134

    
135
    namespace functional
136
    {
137
        template<typename To, typename From, typename EnableIf = void>
138
        struct promote_base;
139
        template<typename Left, typename Right, typename EnableIf = void>
140
        struct min_assign_base;
141
        template<typename Left, typename Right, typename EnableIf = void>
142
        struct max_assign_base;
143
        template<typename Left, typename Right, typename EnableIf = void>
144
        struct fdiv_base;
145
        template<typename Arg, typename EnableIf = void>
146
        struct as_min_base;
147
        template<typename Arg, typename EnableIf = void>
148
        struct as_max_base;
149
        template<typename Arg, typename EnableIf = void>
150
        struct as_zero_base;
151
        template<typename Arg, typename EnableIf = void>
152
        struct as_one_base;
153

    
154
        template<typename To, typename From, typename ToTag = typename tag<To>::type, typename FromTag = typename tag<From>::type>
155
        struct promote;
156
        template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
157
        struct min_assign;
158
        template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
159
        struct max_assign;
160
        template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
161
        struct fdiv;
162
        template<typename Arg, typename Tag = typename tag<Arg>::type>
163
        struct as_min;
164
        template<typename Arg, typename Tag = typename tag<Arg>::type>
165
        struct as_max;
166
        template<typename Arg, typename Tag = typename tag<Arg>::type>
167
        struct as_zero;
168
        template<typename Arg, typename Tag = typename tag<Arg>::type>
169
        struct as_one;
170
    }
171

    
172
    namespace op
173
    {
174
        template<typename To>
175
        struct promote;
176
        struct min_assign;
177
        struct max_assign;
178
        struct fdiv;
179
        struct as_min;
180
        struct as_max;
181
        struct as_zero;
182
        struct as_one;
183
    }
184

    
185
    namespace
186
    {
187
        extern op::min_assign const &min_assign;
188
        extern op::max_assign const &max_assign;
189
        extern op::fdiv const &fdiv;
190
        extern op::as_min const &as_min;
191
        extern op::as_max const &as_max;
192
        extern op::as_zero const &as_zero;
193
        extern op::as_one const &as_one;
194
    }
195

    
196
    template<typename To, typename From>
197
    typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type
198
    promote(From &from);
199

    
200
    template<typename To, typename From>
201
    typename mpl::if_<is_same<To const, From const>, To const &, To const>::type
202
    promote(From const &from);
203

    
204
    template<typename T>
205
    struct default_;
206

    
207
    template<typename T>
208
    struct one;
209

    
210
    template<typename T>
211
    struct zero;
212

    
213
    template<typename T>
214
    struct one_or_default;
215

    
216
    template<typename T>
217
    struct zero_or_default;
218

    
219
}} // namespace boost::numeric
220

    
221
#endif