aimstil  5.0.5
TExprConcatenation.h
Go to the documentation of this file.
1 #ifndef TIL_TEXPR_CONCATENATION_H
2 #define TIL_TEXPR_CONCATENATION_H
3 
4 // includes from STL
5 #include <cmath> // sqrt
6 
7 // includes from BOOST
8 #include "boost/type_traits.hpp"
9 
10 // includes from TIL library
11 //#include "til/ImageFunctorTraits.h"
12 #include "til/TExprBasicFunctors.h"
13 #include "til/TExprMacros.h"
14 #include "til/traits.h"
15 
16 namespace til
17 {
18  namespace expr
19  {
20  /*
21  template < typename Expr, typename TDest >
22  class TExprCast
23  {
24  public: // typedefs
25  EXPR_RESULT_TYPE( TDest );
26  public: // constructors & destructor
27  TExprCast(const Expr &e) : m_e(e) {}
28  public: // functions
29  EXPRFUNC_1ARG(operator(), return TDest(m_e(i1)); );
30  EXPRFUNC_2ARG(operator(), return TDest(m_e(i1, i2)); );
31  EXPRFUNC_3ARG(operator(), return TDest(m_e(i1, i2, i3)); );
32  private: // data
33  Expr m_e;
34  };
35  */
36 
37  /*
38  template < typename UnaryImageFunctor, typename Expr >
39  class TExprImageFunctor
40  {
41  public: // typedefs
42  EXPR_RESULT_TYPE(typename functor::ImageFunctorTraits<UnaryImageFunctor>::TypeStruct<typename Expr::IteratorStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type >::Type );
43 
44  public: // constructors & destructor
45  TExprImageFunctor(const UnaryImageFunctor &functor, const Expr &e) : m_functor(functor), m_e(e) {}
46 
47  public: // functions
48 
49  EXPRFUNC_1ARG(operator(), return m_functor(m_e(i1)); );
50  EXPRFUNC_2ARG(operator(), return m_functor(m_e(i1, i2)); );
51  EXPRFUNC_3ARG(operator(), return m_functor(m_e(i1, i2, i3)); );
52 
53  private: // data
54  UnaryImageFunctor m_functor;
55  Expr m_e;
56  };
57  */
58 
60  template < typename Expr, typename UnaryFunctor >
61  class TExprUnaryOperator
62  {
63  public: // typedefs
64  EXPR_RESULT_TYPE(
65 typename UnaryFunctor::template TypeStruct<
66  typename naked_type<
67 // typename boost::remove_const<
68  typename Expr::template TypeStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type
69  >::type
70 >::Type );
71 
72  public: // constructors & destructor
73  TExprUnaryOperator(const Expr &e, const UnaryFunctor &functor) : m_e(e), m_functor(functor) {}
74 
75  public: // functions
76  EXPRFUNC_1ARG(operator(), return m_functor(m_e(i1)); );
77  EXPRFUNC_2ARG(operator(), return m_functor(m_e(i1, i2)); );
78  EXPRFUNC_3ARG(operator(), return m_functor(m_e(i1, i2, i3)); );
79 
80  private: // data
81 
82  Expr m_e;
83  UnaryFunctor m_functor;
84  };
85 
86 
88  template < typename TExpr1, typename TExpr2, typename BinaryOperator >
89  class TExprBinaryOperator
90  {
91  public: //typedefs
92 
93  EXPR_RESULT_TYPE(
94 typename BinaryOperator::template TypeStruct<
95  typename naked_type<
96 // typename boost::remove_const<
97 // typename boost::remove_reference<
98  typename TExpr1::template TypeStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type
99  >::type
100  TIL_COMMA
101  typename naked_type<
102 // typename boost::remove_const<
103 // typename boost::remove_reference<
104  typename TExpr2::template TypeStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type
105  >::type
106 >::Type );
107 
108  public: // constructors & destructor
109 
110  TExprBinaryOperator(const TExpr1 &e1, const TExpr2 &e2, const BinaryOperator &functor)
111  : m_e1(e1), m_e2(e2), m_functor(functor) {}
112 
113  public: // functions
114 
115  //EXPRFUNC_1ARG(operator(), return m_functor.operator()<typename boost::call_traits<typename TExpr1::TypeStruct< Iterator1 >::Type >::value_type>(m_e1(i1), m_e2(i1)););
116  EXPRFUNC_1ARG(operator(), return m_functor(m_e1(i1), m_e2(i1)););
117  EXPRFUNC_2ARG(operator(), return m_functor(m_e1(i1, i2), m_e2(i1, i2)););
118  EXPRFUNC_3ARG(operator(), return m_functor(m_e1(i1, i2, i3), m_e2(i1, i2, i3)););
119 
120  private: // data
121 
122  TExpr1 m_e1;
123  TExpr2 m_e2;
124  BinaryOperator m_functor;
125  };
126 
127 
128  template < typename TExpr1, typename TExpr2, typename BinaryOperator >
129  class TExprBinaryOperator_NoRes
130  {
131  public: //typedefs
132 
133  EXPR_RESULT_TYPE(
134 typename BinaryOperator::template TypeStruct<
135  typename naked_type<
136 // typename boost::remove_const<
137 // typename boost::remove_reference<
138  typename TExpr1::template TypeStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type
139  >::type
140  TIL_COMMA
141  typename naked_type<
142 // typename boost::remove_const<
143 // typename boost::remove_reference<
144  typename TExpr2::template TypeStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type
145  >::type
146 >::Type );
147 
148  public: // constructors & destructor
149 
150  TExprBinaryOperator_NoRes(const TExpr1 &e1, const TExpr2 &e2, const BinaryOperator &functor)
151  : m_e1(e1), m_e2(e2), m_functor(functor) {}
152 
153  public: // functions
154 
155  //EXPRFUNC_1ARG(operator(), return m_functor.operator()<typename boost::call_traits<typename TExpr1::TypeStruct< Iterator1 >::Type >::value_type>(m_e1(i1), m_e2(i1)););
156  EXPRFUNC_1ARG(operator(), m_functor(m_e1(i1), m_e2(i1)););
157  EXPRFUNC_2ARG(operator(), m_functor(m_e1(i1, i2), m_e2(i1, i2)););
158  EXPRFUNC_3ARG(operator(), m_functor(m_e1(i1, i2, i3), m_e2(i1, i2, i3)););
159 
160  private: // data
161 
162  TExpr1 m_e1;
163  TExpr2 m_e2;
164  BinaryOperator m_functor;
165  };
166 
167 
168 
169  /*
171  template < typename TExpr1, typename TExpr2, typename BinaryToOperator >
172  class TExprBinaryToOperator
173  {
174  public: //typedefs
175 
176  EXPR_RESULT_TYPE(typename functor::FunctorTraits<BinaryToOperator>::template TypeStruct<typename TExpr1::template TypeStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type TIL_COMMA typename TExpr2::template TypeStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type >::Type );
177 
178  public: // constructors & destructor
179 
180  TExprBinaryToOperator(const TExpr1 &e1, const TExpr2 &e2, const BinaryToOperator &functor)
181  : m_e1(e1), m_e2(e2), m_functor(functor) {}
182 
183  public: // functions
184 
185  EXPRFUNC_1ARG(operator(), return m_functor(m_e1(i1), m_e2(i1)););
186  EXPRFUNC_2ARG(operator(), return m_functor(m_e1(i1, i2), m_e2(i1, i2)););
187  //EXPRFUNC_2ARG(operator(), if (m_e2(i1, i2) > 0 && *(m_e1.getLValue(i1, i2)) % 1000 == 0) std::cout << *(m_e1.getLValue(i1, i2)) << std::endl;; return m_functor(*(m_e1.getLValue(i1, i2)), m_e2(i1, i2)););
188  //EXPRFUNC_2ARG(operator(), if (*i1 != *i2) std::cout << (int)*i1 << " " << (int)*i2 << " " << m_e2(i1,i2) << std::endl; return m_functor(*(m_e1.getLValue(i1, i2)), m_e2(i1, i2)););
189  EXPRFUNC_3ARG(operator(), return m_functor(m_e1(i1, i2, i3), m_e2(i1, i2, i3)););
190 
191  private: // data
192 
193  TExpr1 m_e1;
194  TExpr2 m_e2;
195  BinaryToOperator m_functor;
196  };
197  */
198 
199 
201  template < typename TExprIf, typename TExprThen >
202  class TExprIfThen
203  {
204  public: // typedefs
205 
206  EXPR_RESULT_TYPE(void);
207 
208  public: // constructors & destructor
209 
210  TExprIfThen(const TExprIf &eIf, const TExprThen &eThen)
211  : m_eIf(eIf), m_eThen(eThen) {};
212 
213  public: // functions
214 
215  EXPRFUNC_1ARG(operator(), if (m_eIf(i1)) m_eThen(i1););
216  EXPRFUNC_2ARG(operator(), if (m_eIf(i1, i2)) m_eThen(i1, i2););
217  EXPRFUNC_3ARG(operator(), if (m_eIf(i1, i2, i3)) m_eThen(i1, i2, i3););
218 
219  private: // data
220 
221  TExprIf m_eIf;
222  TExprThen m_eThen;
223  };
224 
225 
226 
228  template < typename TExprIf, typename TExprThen, typename TExprElse >
229  class TExprIfThenElse
230  {
231  public: // typedefs
232 
233  EXPR_RESULT_TYPE(typename TExprThen::template TypeStruct<Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3>::Type );
234 
235  public: // constructors & destructor
236 
237  TExprIfThenElse(const TExprIf &eIf, const TExprThen &eThen, const TExprElse &eElse)
238  : m_eIf(eIf), m_eThen(eThen), m_eElse(eElse) {};
239 
240  public: // functions
241 
242  EXPRFUNC_1ARG(operator(), if (m_eIf(i1)) return m_eThen(i1); return m_eElse(i1); );
243  EXPRFUNC_2ARG(operator(), if (m_eIf(i1, i2)) return m_eThen(i1, i2); return m_eElse(i1, i2); );
244  EXPRFUNC_3ARG(operator(), if (m_eIf(i1, i2, i3)) return m_eThen(i1, i2, i3); return m_eElse(i1, i2, i3); );
245 
246  private: // data
247 
248  TExprIf m_eIf;
249  TExprThen m_eThen;
250  TExprElse m_eElse;
251  };
252 
253  /*
255  template < typename TExpr1, typename TExpr2 >
256  class TExprAssign
257  {
258  public: // typedefs
259 
260  EXPR_RESULT_TYPE(void);
261 
262  public: // constructors & destructor
263 
264  TExprAssign(const TExpr1 &e1, const TExpr2 &e2)
265  : m_e1(e1), m_e2(e2) {}
266 
267  public: // functions
268 
269  //EXPRFUNC_1ARG(operator(), *(m_e1.getLValue(i1)) = m_e2(i1););
270  //EXPRFUNC_2ARG(operator(), *(m_e1.getLValue(i1, i2)) = m_e2(i1, i2););
271  //EXPRFUNC_3ARG(operator(), *(m_e1.getLValue(i1, i2, i3)) = m_e2(i1, i2, i3););
272  EXPRFUNC_1ARG(operator(), m_e1(i1) = m_e2(i1););
273  EXPRFUNC_2ARG(operator(), m_e1(i1, i2) = m_e2(i1, i2););
274  EXPRFUNC_3ARG(operator(), m_e1(i1, i2, i3) = m_e2(i1, i2, i3););
275 
276  private: // data
277 
278  TExpr1 m_e1;
279  TExpr2 m_e2;
280  };
281  */
282 
283  /*
284  template < typename Expr >
285  class TExprSqrt
286  {
287  public:
288  EXPR_RESULT_TYPE(double);
289  TExprSqrt(const Expr &e) : m_e(e) {}
290  EXPRFUNC_1ARG(operator(), return std::sqrt(m_e(i1)); );
291  EXPRFUNC_2ARG(operator(), return std::sqrt(m_e(i1, i2)); );
292  EXPRFUNC_3ARG(operator(), return std::sqrt(m_e(i1, i2, i3)); );
293 
294  private:
295  Expr m_e;
296  };
297  */
298 
299 
301  template < typename Expr1, typename Expr2 >
302  class TExprCouple
303  {
304  public:
305  // TODO: okay, maybe you want to return the value of the second expression...
306  EXPR_RESULT_TYPE( void );
307  TExprCouple(const Expr1 &e1, const Expr2 &e2) : m_e1(e1), m_e2(e2) {}
308  EXPRFUNC_1ARG(operator(), ( m_e1(i1), m_e2(i1)); );
309  EXPRFUNC_2ARG(operator(), ( m_e1(i1, i2), m_e2(i1, i2)); );
310  EXPRFUNC_3ARG(operator(), ( m_e1(i1, i2, i3), m_e2(i1, i2, i3)); );
311 
312  private:
313  Expr1 m_e1;
314  Expr2 m_e2;
315  };
316 
317  } // namespace expr
318 } // namespace til
319 
320 #endif
321 
til::expr::TExprBinaryOperator
Apply a binary numerical functor to two template expressions.
Definition: TExprConcatenation.h:89
til::expr::TExprIfThen
If/then block using template expressions.
Definition: TExprConcatenation.h:202
til::expr::TExprUnaryOperator::EXPRFUNC_1ARG
EXPRFUNC_1ARG(operator(), return m_functor(m_e(i1));)
til::expr::TExprCouple::TExprCouple
TExprCouple(const Expr1 &e1, const Expr2 &e2)
Definition: TExprConcatenation.h:307
til::expr::TExprUnaryOperator::TExprUnaryOperator
TExprUnaryOperator(const Expr &e, const UnaryFunctor &functor)
Definition: TExprConcatenation.h:73
til::expr::TExprIfThenElse::TExprIfThenElse
TExprIfThenElse(const TExprIf &eIf, const TExprThen &eThen, const TExprElse &eElse)
Definition: TExprConcatenation.h:237
til
Belongs to package Box Do not include directly, include til/Box.h instead.
Definition: Accumulator.h:10
til::expr::TExprUnaryOperator::EXPR_RESULT_TYPE
EXPR_RESULT_TYPE(typename UnaryFunctor::template TypeStruct< typename naked_type< typename Expr::template TypeStruct< Iterator1 TIL_COMMA Iterator2 TIL_COMMA Iterator3 >::Type >::type >::Type)
til::expr::TExprIfThenElse
If/then block using template expressions.
Definition: TExprConcatenation.h:229
til::naked_type
Definition: templateTools.h:85
til::expr::TExprUnaryOperator::EXPRFUNC_2ARG
EXPRFUNC_2ARG(operator(), return m_functor(m_e(i1, i2));)
TExprMacros.h
Some macros to ease the otherwise tedious and unreadable declaration of template expression classes...
til::expr::TExprBinaryOperator_NoRes
Definition: TExprConcatenation.h:129
TIL_COMMA
#define TIL_COMMA
Definition: is_traits.h:38
til::expr::TExprUnaryOperator
Apply a unary numerical functor to a template expression.
Definition: TExprConcatenation.h:61
til::expr::TExprBinaryOperator::TExprBinaryOperator
TExprBinaryOperator(const TExpr1 &e1, const TExpr2 &e2, const BinaryOperator &functor)
Definition: TExprConcatenation.h:110
til::expr::TExprIfThen::TExprIfThen
TExprIfThen(const TExprIf &eIf, const TExprThen &eThen)
Definition: TExprConcatenation.h:210
til::expr::TExprCouple
Evaluate one expression and then the other.
Definition: TExprConcatenation.h:302
til::expr::TExprBinaryOperator_NoRes::TExprBinaryOperator_NoRes
TExprBinaryOperator_NoRes(const TExpr1 &e1, const TExpr2 &e2, const BinaryOperator &functor)
Definition: TExprConcatenation.h:150
til::expr::TExprUnaryOperator::EXPRFUNC_3ARG
EXPRFUNC_3ARG(operator(), return m_functor(m_e(i1, i2, i3));)