?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
remove \r
[extl.git] / extl / math / expr_vvector.h
blob11de857ff0e4d9b5e99fd60363449648c5f9e937
1 /* ///////////////////////////////////////////////////////////////////////
2 * File: expr_vvector.h
3 *
4 * Created: 08.08.11
5 * Updated: 09.01.27
6 *
7 * Brief: the expression vvector class - delay to calculate value array expression
8 *
9 * [<Home>]
10 * Copyright (c) 2008-2020, Waruqi All rights reserved.
11 * //////////////////////////////////////////////////////////////////// */
12
13 #ifndef EXTL_MATH_EXPR_VVECTOR_H
14 #define EXTL_MATH_EXPR_VVECTOR_H
15
16 #ifndef EXTL_MATH_EXPR_VVECTOR_SUPPORT
17 # error expr_vvector.h is not supported by the current compiler.
18 #endif
19
20 /*!\file expr_vvector.h
21 * \brief the expression vvector class
22 */
23
24 /* ///////////////////////////////////////////////////////////////////////
25 * Includes
26 */
27 #include "detail/expr_op.h"
28 #include "detail/vvector_expr.h"
29
30 #ifdef EXTL_MATH_VVECTOR_TEST_ENABLE
31 # include "../counter/counter.h"
32 # include "basic_vvector.h"
33 #endif
34 /* ///////////////////////////////////////////////////////////////////////
35 * ::extl namespace
36 */
37 EXTL_BEGIN_NAMESPACE
38
39 /*!\brief expr_vvector
40 *
41 * \param T The value type
42 * \param A The val-array type
43 *
44 * \ingroup extl_group_math
45 */
46 template< typename_param_k T
47 , typename_param_k A
48 >
49 class expr_vvector
50 {
51 /// \name Types
52 /// @{
53 public:
54 typedef A array_type;
55 typedef expr_vvector class_type;
56 typedef typename_type_k array_type::value_type value_type;
57 typedef typename_type_k array_type::pointer pointer;
58 typedef typename_type_k array_type::const_pointer const_pointer;
59 typedef typename_type_k array_type::reference reference;
60 typedef typename_type_k array_type::const_reference const_reference;
61 typedef typename_type_k array_type::size_type size_type;
62 typedef typename_type_k array_type::bool_type bool_type;
63 typedef typename_type_k array_type::difference_type difference_type;
64 typedef typename_type_k array_type::int_type int_type;
65 typedef typename_type_k array_type::index_type index_type;
66 /// @}
67
68 /// \name Members
69 /// @{
70 private:
71 // note: reference
72 array_type& m_array;
73 /// @}
74
75 /// \name Constructors
76 /// @{
77 public:
78 explicit_k expr_vvector(array_type& ar)
79 : m_array(ar)
80 {}
81 /// @}
82
83 private:
84 expr_vvector(class_type const& rhs);
85
86 /// \name Assignment
87 /// @{
88 public:
89 /// expr => array
90 template< typename_param_k T2
91 , typename_param_k E2
92 >
93 class_type& operator =(EXTL_NS_DETAIL(vvector_expr)<T2, E2> const& expr)
94 {
95 EXTL_ASSERT(size() == expr.size());
96 size_type n = size();
97 for (size_type i = 0; i < n; ++i)
98 {
99 m_array[i] = expr[i];
100 }
101 return *this;
102 }
103
104 /// array => array
105 class_type& operator =(class_type const& rhs)
106 {
107 if (this != &rhs)
108 {
109 EXTL_ASSERT(size() == rhs.size());
110 size_type n = size();
111 for (size_type i = 0; i < n; ++i)
112 {
113 m_array[i] = rhs[i];
114 }
115 }
116
117 return *this;
118 }
119
120 /// value => array
121 class_type& operator =(const_reference value)
122 {
123 m_array = value;
124 return *this;
125 }
126 /// @}
127
128 /// \name Attributes
129 /// @{
130 public:
131 size_type size() const { return m_array.size(); }
132 /// @}
133
134 /// \name Accessors
135 /// @{
136 public:
137 reference operator [](index_type index) { return m_array[index]; }
138 const_reference operator [](index_type index) const { return m_array[index]; }
139
140 array_type& array() { return m_array; }
141 array_type const& array() const { return m_array; }
142 /// @}
143
144 };
145
146
147 // array + array
148 template< typename_param_k T
149 , typename_param_k A1
150 , typename_param_k A2
151 >
152 EXTL_NS_DETAIL(vvector_expr) < T
153 , EXTL_NS_DETAIL(eop_add) <T, A1, A2>
154 >
155 operator +(expr_vvector<T, A1> const& ar1, expr_vvector<T, A2> const& ar2)
156 {
157 return EXTL_NS_DETAIL(vvector_expr) < T
158 , EXTL_NS_DETAIL(eop_add) <T, A1, A2>
159 >
160 ( EXTL_NS_DETAIL(eop_add) <T, A1, A2>
161 ( ar1.array()
162 , ar2.array()
163 )
164 );
165 }
166
167 // array + expr
168 template< typename_param_k T
169 , typename_param_k A1
170 , typename_param_k E2
171 >
172 EXTL_NS_DETAIL(vvector_expr) < T
173 , EXTL_NS_DETAIL(eop_add) <T, A1, E2>
174 >
175 operator +(expr_vvector<T, A1> const& ar1, EXTL_NS_DETAIL(vvector_expr)<T, E2> const& expr2)
176 {
177 return EXTL_NS_DETAIL(vvector_expr) < T
178 , EXTL_NS_DETAIL(eop_add) <T, A1, E2>
179 >
180 ( EXTL_NS_DETAIL(eop_add) <T, A1, E2>
181 ( ar1.array()
182 , expr2.expr()
183 )
184 );
185 }
186 // expr + array
187 template< typename_param_k T
188 , typename_param_k E1
189 , typename_param_k A2
190 >
191 EXTL_NS_DETAIL(vvector_expr) < T
192 , EXTL_NS_DETAIL(eop_add) <T, E1, A2>
193 >
194 operator +(EXTL_NS_DETAIL(vvector_expr)<T, E1> const& expr1, expr_vvector<T, A2> const& ar2)
195 {
196 return EXTL_NS_DETAIL(vvector_expr) < T
197 , EXTL_NS_DETAIL(eop_add) <T, E1, A2>
198 >
199 ( EXTL_NS_DETAIL(eop_add) <T, E1, A2>
200 ( expr1.expr()
201 , ar2.array()
202 )
203 );
204 }
205
206 // array - array
207 template< typename_param_k T
208 , typename_param_k A1
209 , typename_param_k A2
210 >
211 EXTL_NS_DETAIL(vvector_expr) < T
212 , EXTL_NS_DETAIL(eop_sub) <T, A1, A2>
213 >
214 operator -(expr_vvector<T, A1> const& ar1, expr_vvector<T, A2> const& ar2)
215 {
216 return EXTL_NS_DETAIL(vvector_expr) < T
217 , EXTL_NS_DETAIL(eop_sub) <T, A1, A2>
218 >
219 ( EXTL_NS_DETAIL(eop_sub) <T, A1, A2>
220 ( ar1.array()
221 , ar2.array()
222 )
223 );
224 }
225
226 // array - expr
227 template< typename_param_k T
228 , typename_param_k A1
229 , typename_param_k E2
230 >
231 EXTL_NS_DETAIL(vvector_expr) < T
232 , EXTL_NS_DETAIL(eop_sub) <T, A1, E2>
233 >
234 operator -(expr_vvector<T, A1> const& ar1, EXTL_NS_DETAIL(vvector_expr)<T, E2> const& expr2)
235 {
236 return EXTL_NS_DETAIL(vvector_expr) < T
237 , EXTL_NS_DETAIL(eop_sub) <T, A1, E2>
238 >
239 ( EXTL_NS_DETAIL(eop_sub) <T, A1, E2>
240 ( ar1.array()
241 , expr2.expr()
242 )
243 );
244 }
245 // expr - array
246 template< typename_param_k T
247 , typename_param_k E1
248 , typename_param_k A2
249 >
250 EXTL_NS_DETAIL(vvector_expr) < T
251 , EXTL_NS_DETAIL(eop_sub) <T, E1, A2>
252 >
253 operator -(EXTL_NS_DETAIL(vvector_expr)<T, E1> const& expr1, expr_vvector<T, A2> const& ar2)
254 {
255 return EXTL_NS_DETAIL(vvector_expr) < T
256 , EXTL_NS_DETAIL(eop_sub) <T, E1, A2>
257 >
258 ( EXTL_NS_DETAIL(eop_sub) <T, E1, A2>
259 ( expr1.expr()
260 , ar2.array()
261 )
262 );
263 }
264
265
266 #ifdef EXTL_MATH_EOP_SCALAR_SUPPORT
267 // array + value
268 template< typename_param_k T
269 , typename_param_k A1
270 >
271 EXTL_NS_DETAIL(vvector_expr) < T
272 , EXTL_NS_DETAIL(eop_add) < T
273 , A1
274 , EXTL_NS_DETAIL(eop_scalar)<T>
275 >
276 >
277 operator +(expr_vvector<T, A1> const& ar1, T const& value)
278 {
279 return EXTL_NS_DETAIL(vvector_expr) < T
280 , EXTL_NS_DETAIL(eop_add) < T
281 , A1
282 , EXTL_NS_DETAIL(eop_scalar)<T>
283 >
284 >
285 ( EXTL_NS_DETAIL(eop_add) < T
286 , A1
287 , EXTL_NS_DETAIL(eop_scalar)<T>
288 >
289 ( ar1.array()
290 , EXTL_NS_DETAIL(eop_scalar)<T>(value) // temporary copy
291 )
292 );
293 }
294 // value + array
295 template< typename_param_k T
296 , typename_param_k A2
297 >
298 EXTL_NS_DETAIL(vvector_expr) < T
299 , EXTL_NS_DETAIL(eop_add) < T
300 , EXTL_NS_DETAIL(eop_scalar)<T>
301 , A2
302 >
303 >
304 operator +(T const& value, expr_vvector<T, A2> const& ar2)
305 {
306 return EXTL_NS_DETAIL(vvector_expr) < T
307 , EXTL_NS_DETAIL(eop_add) < T
308 , EXTL_NS_DETAIL(eop_scalar)<T>
309 , A2
310 >
311 >
312 ( EXTL_NS_DETAIL(eop_add) < T
313 , EXTL_NS_DETAIL(eop_scalar)<T>
314 , A2
315 >
316 ( EXTL_NS_DETAIL(eop_scalar)<T>(value) // temporary copy
317 , ar2.array()
318 )
319 );
320 }
321
322 // array - value
323 template< typename_param_k T
324 , typename_param_k A1
325 >
326 EXTL_NS_DETAIL(vvector_expr) < T
327 , EXTL_NS_DETAIL(eop_sub) < T
328 , A1
329 , EXTL_NS_DETAIL(eop_scalar)<T>
330 >
331 >
332 operator -(expr_vvector<T, A1> const& ar1, T const& value)
333 {
334 return EXTL_NS_DETAIL(vvector_expr) < T
335 , EXTL_NS_DETAIL(eop_sub) < T
336 , A1
337 , EXTL_NS_DETAIL(eop_scalar)<T>
338 >
339 >
340 ( EXTL_NS_DETAIL(eop_sub) < T
341 , A1
342 , EXTL_NS_DETAIL(eop_scalar)<T>
343 >
344 ( ar1.array()
345 , EXTL_NS_DETAIL(eop_scalar)<T>(value) // temporary copy
346 )
347 );
348 }
349 // value - array
350 template< typename_param_k T
351 , typename_param_k A2
352 >
353 EXTL_NS_DETAIL(vvector_expr) < T
354 , EXTL_NS_DETAIL(eop_sub) < T
355 , EXTL_NS_DETAIL(eop_scalar)<T>
356 , A2
357 >
358 >
359 operator -(T const& value, expr_vvector<T, A2> const& ar2)
360 {
361 return EXTL_NS_DETAIL(vvector_expr) < T
362 , EXTL_NS_DETAIL(eop_sub) < T
363 , EXTL_NS_DETAIL(eop_scalar)<T>
364 , A2
365 >
366 >
367 ( EXTL_NS_DETAIL(eop_sub) < T
368 , EXTL_NS_DETAIL(eop_scalar)<T>
369 , A2
370 >
371 ( EXTL_NS_DETAIL(eop_scalar)<T>(value) // temporary copy
372 , ar2.array()
373 )
374 );
375 }
376
377 // array * value
378 template< typename_param_k T
379 , typename_param_k A1
380 >
381 EXTL_NS_DETAIL(vvector_expr) < T
382 , EXTL_NS_DETAIL(eop_mul) < T
383 , A1
384 , EXTL_NS_DETAIL(eop_scalar)<T>
385 >
386 >
387 operator *(expr_vvector<T, A1> const& ar1, T const& value)
388 {
389 return EXTL_NS_DETAIL(vvector_expr) < T
390 , EXTL_NS_DETAIL(eop_mul) < T
391 , A1
392 , EXTL_NS_DETAIL(eop_scalar)<T>
393 >
394 >
395 ( EXTL_NS_DETAIL(eop_mul) < T
396 , A1
397 , EXTL_NS_DETAIL(eop_scalar)<T>
398 >
399 ( ar1.array()
400 , EXTL_NS_DETAIL(eop_scalar)<T>(value) // temporary copy
401 )
402 );
403 }
404 // value * array
405 template< typename_param_k T
406 , typename_param_k A2
407 >
408 EXTL_NS_DETAIL(vvector_expr) < T
409 , EXTL_NS_DETAIL(eop_mul) < T
410 , EXTL_NS_DETAIL(eop_scalar)<T>
411 , A2
412 >
413 >
414 operator *(T const& value, expr_vvector<T, A2> const& ar2)
415 {
416 return EXTL_NS_DETAIL(vvector_expr) < T
417 , EXTL_NS_DETAIL(eop_mul) < T
418 , EXTL_NS_DETAIL(eop_scalar)<T>
419 , A2
420 >
421 >
422 ( EXTL_NS_DETAIL(eop_mul) < T
423 , EXTL_NS_DETAIL(eop_scalar)<T>
424 , A2
425 >
426 ( EXTL_NS_DETAIL(eop_scalar)<T>(value) // temporary copy
427 , ar2.array()
428 )
429 );
430 }
431
432 // array / value
433 template< typename_param_k T
434 , typename_param_k A1
435 >
436 EXTL_NS_DETAIL(vvector_expr) < T
437 , EXTL_NS_DETAIL(eop_div) < T
438 , A1
439 , EXTL_NS_DETAIL(eop_scalar)<T>
440 >
441 >
442 operator /(expr_vvector<T, A1> const& ar1, T const& value)
443 {
444 return EXTL_NS_DETAIL(vvector_expr) < T
445 , EXTL_NS_DETAIL(eop_div) < T
446 , A1
447 , EXTL_NS_DETAIL(eop_scalar)<T>
448 >
449 >
450 ( EXTL_NS_DETAIL(eop_div) < T
451 , A1
452 , EXTL_NS_DETAIL(eop_scalar)<T>
453 >
454 ( ar1.array()
455 , EXTL_NS_DETAIL(eop_scalar)<T>(value) // temporary copy
456 )
457 );
458 }
459 // value / array
460 template< typename_param_k T
461 , typename_param_k A2
462 >
463 EXTL_NS_DETAIL(vvector_expr) < T
464 , EXTL_NS_DETAIL(eop_div) < T
465 , EXTL_NS_DETAIL(eop_scalar)<T>
466 , A2
467 >
468 >
469 operator /(T const& value, expr_vvector<T, A2> const& ar2)
470 {
471 return EXTL_NS_DETAIL(vvector_expr) < T
472 , EXTL_NS_DETAIL(eop_div) < T
473 , EXTL_NS_DETAIL(eop_scalar)<T>
474 , A2
475 >
476 >
477 ( EXTL_NS_DETAIL(eop_div) < T
478 , EXTL_NS_DETAIL(eop_scalar)<T>
479 , A2
480 >
481 ( EXTL_NS_DETAIL(eop_scalar)<T>(value) // temporary copy
482 , ar2.array()
483 )
484 );
485 }
486 #endif
487
488
489 /* ///////////////////////////////////////////////////////////////////////
490 * ::extl namespace
491 */
492 EXTL_END_NAMESPACE
493
494 /* //////////////////////////////////////////////////////////////////// */
495 #endif /* EXTL_MATH_EXPR_VVECTOR_H */
496 /* //////////////////////////////////////////////////////////////////// */
a c++ generic library