vigra - vigra/tinyvector.hxx Source File

[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

tinyvector.hxx |

1 /************************************************************************/
2 /* */
3 /* Copyright 1998-2002 by Ullrich Koethe */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35
36
37 #ifndef VIGRA_TINYVECTOR_HXX
38 #define VIGRA_TINYVECTOR_HXX
39
40 namespace lemon {
41
42 struct Invalid;
43
44 } // namespace lemon
45
46 #include <cmath> // abs(double)
47 #include <cstdlib> // abs(int)
48 #include <iosfwd> // ostream
49 #include <algorithm>
50 #include "config.hxx"
51 #include "error.hxx"
52 #include "metaprogramming.hxx"
53 #include "numerictraits.hxx"
54 #include "memory.hxx"
55 #include "mathutil.hxx"
56 #include "diff2d.hxx"
57 #include "static_assert.hxx"
58
59 #ifdef VIGRA_CHECK_BOUNDS
60 #define VIGRA_ASSERT_INSIDE(diff) \
61 vigra_precondition(diff >= 0, "Index out of bounds");\
62 vigra_precondition(diff < SIZE, "Index out of bounds");
63 #else
64 #define VIGRA_ASSERT_INSIDE(diff)
65 #endif
66
67 namespace vigra {
68
69 // mask cl.exe shortcomings [begin]
70 #if defined(_MSC_VER)
71 #pragma warning( push )
72 #pragma warning( disable : 4503 )
73 #endif
74
75 using VIGRA_CSTD::abs;
76 using VIGRA_CSTD::ceil;
77 using VIGRA_CSTD::floor;
78 using VIGRA_CSTD::sqrt;
79
80
81 template <class V1, int SIZE, class D1, class D2>
82 class TinyVectorBase;
83
84 template <class V1, int SIZE, class D1, class D2>
85 inline
86 typename TinyVectorBase<V1, SIZE, D1, D2>::SquaredNormType
87 squaredNorm(TinyVectorBase<V1, SIZE, D1, D2> const & t);
88
89
90 namespace detail {
91
92 #define VIGRA_EXEC_LOOP(NAME, OPER) \
93 template <class T1, class T2> \
94 static void NAME(T1 * left, T2 const * right) \
95 { \
96 for(int i=0; i<LEVEL; ++i) \
97 (left[i]) OPER (right[i]); \
98 }
99
100 #define VIGRA_EXEC_LOOP_MINMAX(NAME, OPER) \
101 template <class T1, class T2> \
102 static void NAME(T1 * left, T2 const * right) \
103 { \
104 for(int i=0; i<LEVEL; ++i) \
105 if(left[i] OPER right[i]) \
106 left[i] = right[i]; \
107 }
108
109 #define VIGRA_EXEC_LOOP_SCALAR(NAME, OPER) \
110 template <class T1, class T2> \
111 static void NAME(T1 * left, T2 right) \
112 { \
113 for(int i=0; i<LEVEL; ++i) \
114 (left[i]) = detail::RequiresExplicitCast<T1>::cast((left[i]) OPER (right)); \
115 }
116
117 template <int LEVEL>
118 struct ExecLoop
119 {
120 template <class T1, class T2>
121 static void assignCast(T1 * left, T2 const * right)
122 {
123 for(int i=0; i<LEVEL; ++i)
124 left[i] = detail::RequiresExplicitCast<T1>::cast(right[i]);
125 }
126
127 template <class T1, class T2>
128 static void reverseAssign(T1 * left, T2 const * right)
129 {
130 for(int i=0; i<LEVEL; ++i)
131 left[i] = right[-i];
132 }
133
134 template <class T1, class T2>
135 static void assignScalar(T1 * left, T2 right)
136 {
137 for(int i=0; i<LEVEL; ++i)
138 left[i] = detail::RequiresExplicitCast<T1>::cast(right);
139 }
140
141 template <class T1, class T2>
142 static void power(T1 * left, T2 right)
143 {
144 for(int i=0; i<LEVEL; ++i)
145 left[i] = detail::RequiresExplicitCast<T1>::cast(pow(left, right));
146 }
147
148 VIGRA_EXEC_LOOP(assign, =)
149 VIGRA_EXEC_LOOP(add, +=)
150 VIGRA_EXEC_LOOP(sub, -=)
151 VIGRA_EXEC_LOOP(mul, *=)
152 VIGRA_EXEC_LOOP(div, /=)
153 VIGRA_EXEC_LOOP(mod, %=)
154 VIGRA_EXEC_LOOP(neg, = -)
155 VIGRA_EXEC_LOOP(abs, = vigra::abs)
156 VIGRA_EXEC_LOOP(floor, = vigra::floor)
157 VIGRA_EXEC_LOOP(ceil, = vigra::ceil)
158 VIGRA_EXEC_LOOP(round, = vigra::round)
159 VIGRA_EXEC_LOOP(sqrt, = vigra::sqrt)
160 VIGRA_EXEC_LOOP(fromPromote, = NumericTraits<T1>::fromPromote)
161 VIGRA_EXEC_LOOP(fromRealPromote, = NumericTraits<T1>::fromRealPromote)
162 VIGRA_EXEC_LOOP_SCALAR(addScalar, +)
163 VIGRA_EXEC_LOOP_SCALAR(subScalar, -)
164 VIGRA_EXEC_LOOP_SCALAR(mulScalar, *)
165 VIGRA_EXEC_LOOP_SCALAR(divScalar, /)
166
167 VIGRA_EXEC_LOOP_MINMAX(min, >)
168 VIGRA_EXEC_LOOP_MINMAX(max, <)
169
170 template <class T>
171 static T const & minimum(T const * p)
172 {
173 return *std::min_element(p, p+LEVEL);
174 }
175
176 template <class T>
177 static T const & maximum(T const * p)
178 {
179 return *std::max_element(p, p+LEVEL);
180 }
181
182 template <class T>
183 static bool all(T const * p, T const & zero)
184 {
185 for(int i=0; i<LEVEL; ++i)
186 if(p[i] == zero)
187 return false;
188 return true;
189 }
190
191 template <class T>
192 static bool any(T const * p, T const & zero)
193 {
194 for(int i=0; i<LEVEL; ++i)
195 if(p[i] != zero)
196 return true;
197 return false;
198 }
199
200 template <class T1, class T2>
201 static bool notEqual(T1 const * left, T2 const * right)
202 {
203 for(int i=0; i<LEVEL; ++i)
204 if(left[i] != right[i])
205 return true;
206 return false;
207 }
208
209 template <class T1, class T2>
210 static bool lexicographicLessThan(T1 const * left, T2 const * right)
211 {
212 for(int i=0; i<LEVEL; ++i)
213 {
214 if(left[i] < right[i])
215 return true;
216 if(right[i] < left[i])
217 return false;
218 }
219 return false;
220 }
221
222 template <class T>
223 static bool closeAtTolerance(T const * left, T const * right, T epsilon)
224 {
225 bool res = true;
226 for(int i=0; i<LEVEL; ++i)
227 {
228 res = res && vigra::closeAtTolerance(left[i], right[i], epsilon);
229 }
230 return res;
231 }
232
233 template <class T>
234 static typename NumericTraits<T>::Promote
235 dot(T const * d)
236 {
237 typename NumericTraits<T>::Promote res(*d * *d);
238 for(int i=1; i<LEVEL; ++i)
239 res += d[i] * d[i];
240 return res;
241 }
242
243 template <class T1, class T2>
244 static typename PromoteTraits<T1, T2>::Promote
245 dot(T1 const * left, T2 const * right)
246 {
247 typename PromoteTraits<T1, T2>::Promote res(*left * *right);
248 for(int i=1; i<LEVEL; ++i)
249 res += left[i] * right[i];
250 return res;
251 }
252
253 template <class T>
254 static typename NormTraits<T>::SquaredNormType
255 squaredNorm(T const * d)
256 {
257 typename NormTraits<T>::SquaredNormType res = vigra::squaredNorm(*d);
258 for(int i=1; i<LEVEL; ++i)
259 res += vigra::squaredNorm(d[i]);
260 return res;
261 }
262 };
263
264 template <int LEVEL>
265 struct UnrollScalarResult
266 {
267 template <class T>
268 static typename NumericTraits<T>::Promote
269 dot(T const * d)
270 {
271 return *d * *d + UnrollScalarResult<LEVEL-1>::dot(d+1);
272 }
273
274 template <class T1, class T2>
275 static typename PromoteTraits<T1, T2>::Promote
276 dot(T1 const * left, T2 const * right)
277 {
278 return *left * *right + UnrollScalarResult<LEVEL-1>::dot(left+1, right+1);
279 }
280
281 template <class T>
282 static typename NormTraits<T>::SquaredNormType
283 squaredNorm(T const * d)
284 {
285 return vigra::squaredNorm(*d) + UnrollScalarResult<LEVEL-1>::squaredNorm(d+1);
286 }
287
288 static std::ptrdiff_t
289 squaredNorm(std::ptrdiff_t const * d)
290 {
291 return (*d)*(*d) + UnrollScalarResult<LEVEL-1>::squaredNorm(d+1);
292 }
293
294 template <class T>
295 static T const & minimum(T const * p)
296 {
297 T const & m = UnrollScalarResult<LEVEL - 1>::minimum(p+1);
298 return *p < m
299 ? *p
300 : m;
301 }
302
303 template <class T>
304 static T const & maximum(T const * p)
305 {
306 T const & m = UnrollScalarResult<LEVEL - 1>::maximum(p+1);
307 return *p > m
308 ? *p
309 : m;
310 }
311
312 template <class T>
313 static bool all(T const * p, T const & zero)
314 {
315 return *p != zero && UnrollScalarResult<LEVEL - 1>::all(p+1, zero);
316 }
317
318 template <class T>
319 static bool any(T const * p, T const & zero)
320 {
321 return *p != zero || UnrollScalarResult<LEVEL - 1>::any(p+1, zero);
322 }
323 };
324
325 template <>
326 struct UnrollScalarResult<1>
327 {
328 template <class T>
329 static typename NumericTraits<T>::Promote
330 dot(T const * d)
331 {
332 return *d * *d ;
333 }
334
335 template <class T1, class T2>
336 static typename PromoteTraits<T1, T2>::Promote
337 dot(T1 const * left, T2 const * right)
338 {
339 return *left * *right;
340 }
341
342 template <class T>
343 static typename NormTraits<T>::SquaredNormType
344 squaredNorm(T const * d)
345 {
346 return vigra::squaredNorm(*d);
347 }
348
349 static std::ptrdiff_t
350 squaredNorm(std::ptrdiff_t const * d)
351 {
352 return (*d)*(*d);
353 }
354
355 template <class T>
356 static T const & minimum(T const * p)
357 {
358 return *p;
359 }
360
361 template <class T>
362 static T const & maximum(T const * p)
363 {
364 return *p;
365 }
366
367 template <class T>
368 static bool all(T const * p, T const & zero)
369 {
370 return *p != zero;
371 }
372
373 template <class T>
374 static bool any(T const * p, T const & zero)
375 {
376 return *p != zero;
377 }
378 };
379
380 #undef VIGRA_EXEC_LOOP
381 #undef VIGRA_EXEC_LOOP_MINMAX
382 #undef VIGRA_EXEC_LOOP_SCALAR
383
384 #define VIGRA_UNROLL_LOOP(NAME, OPER) \
385 template <class T1, class T2> \
386 static void NAME(T1 * left, T2 const * right) \
387 { \
388 (*left) OPER (*right); \
389 UnrollLoop<LEVEL-1>::NAME(left+1, right+1); \
390 }
391
392 #define VIGRA_UNROLL_LOOP_MINMAX(NAME, OPER) \
393 template <class T1, class T2> \
394 static void NAME(T1 * left, T2 const * right) \
395 { \
396 if(*left OPER *right) \
397 *left = *right; \
398 UnrollLoop<LEVEL-1>::NAME(left+1, right+1); \
399 }
400
401 #define VIGRA_UNROLL_LOOP_SCALAR(NAME, OPER) \
402 template <class T1, class T2> \
403 static void NAME(T1 * left, T2 right) \
404 { \
405 (*left) = detail::RequiresExplicitCast<T1>::cast((*left) OPER (right)); \
406 UnrollLoop<LEVEL-1>::NAME(left+1, right); \
407 }
408
409
410 template <int LEVEL>
411 struct UnrollLoop
412 {
413 template <class T1, class T2>
414 static void reverseAssign(T1 * left, T2 const * right)
415 {
416 *left = *right;
417 UnrollLoop<LEVEL-1>::reverseAssign(left+1, right-1);
418 }
419
420 template <class T1, class T2>
421 static void assignCast(T1 * left, T2 const * right)
422 {
423 *left = detail::RequiresExplicitCast<T1>::cast(*right);
424 UnrollLoop<LEVEL-1>::assignCast(left+1, right+1);
425 }
426
427 template <class T1, class T2>
428 static void assignScalar(T1 * left, T2 right)
429 {
430 *left = detail::RequiresExplicitCast<T1>::cast(right);
431 UnrollLoop<LEVEL-1>::assignScalar(left+1, right);
432 }
433
434 template <class T1, class T2>
435 static void power(T1 * left, T2 right)
436 {
437 *left = detail::RequiresExplicitCast<T1>::cast(pow(*left, right));
438 UnrollLoop<LEVEL-1>::power(left+1, right);
439 }
440
441 VIGRA_UNROLL_LOOP(assign, =)
442 VIGRA_UNROLL_LOOP(add, +=)
443 VIGRA_UNROLL_LOOP(sub, -=)
444 VIGRA_UNROLL_LOOP(mul, *=)
445 VIGRA_UNROLL_LOOP(div, /=)
446 VIGRA_UNROLL_LOOP(mod, %=)
447 VIGRA_UNROLL_LOOP(neg, = -)
448 VIGRA_UNROLL_LOOP(abs, = vigra::abs)
449 VIGRA_UNROLL_LOOP(floor, = vigra::floor)
450 VIGRA_UNROLL_LOOP(ceil, = vigra::ceil)
451 VIGRA_UNROLL_LOOP(round, = vigra::round)
452 VIGRA_UNROLL_LOOP(sqrt, = vigra::sqrt)
453 VIGRA_UNROLL_LOOP(fromPromote, = NumericTraits<T1>::fromPromote)
454 VIGRA_UNROLL_LOOP(fromRealPromote, = NumericTraits<T1>::fromRealPromote)
455 VIGRA_UNROLL_LOOP_SCALAR(addScalar, +)
456 VIGRA_UNROLL_LOOP_SCALAR(subScalar, -)
457 VIGRA_UNROLL_LOOP_SCALAR(mulScalar, *)
458 VIGRA_UNROLL_LOOP_SCALAR(divScalar, /)
459
460 VIGRA_UNROLL_LOOP_MINMAX(min, >)
461 VIGRA_UNROLL_LOOP_MINMAX(max, <)
462
463 template <class T>
464 static T const & minimum(T const * p)
465 {
466 return UnrollScalarResult<LEVEL>::minimum(p);
467 }
468
469 template <class T>
470 static T const & maximum(T const * p)
471 {
472 return UnrollScalarResult<LEVEL>::maximum(p);
473 }
474
475 template <class T>
476 static bool all(T const * p, T const & zero)
477 {
478 return UnrollScalarResult<LEVEL>::all(p, zero);
479 }
480
481 template <class T>
482 static bool any(T const * p, T const & zero)
483 {
484 return UnrollScalarResult<LEVEL>::any(p, zero);
485 }
486
487 template <class T1, class T2>
488 static bool notEqual(T1 const * left, T2 const * right)
489 {
490 return (*left != *right) || UnrollLoop<LEVEL - 1>::notEqual(left+1, right+1);
491 }
492
493 template <class T1, class T2>
494 static bool lexicographicLessThan(T1 const * left, T2 const * right)
495 {
496 if(*left < *right)
497 return true;
498 if(*right < *left)
499 return false;
500 return UnrollLoop<LEVEL - 1>::lexicographicLessThan(left+1, right+1);
501 }
502
503 template <class T>
504 static bool closeAtTolerance(T const * left, T const * right, T epsilon)
505 {
506 return vigra::closeAtTolerance(*left, *right, epsilon) &&
507 UnrollLoop<LEVEL - 1>::closeAtTolerance(left+1, right+1, epsilon);
508 }
509
510 template <class T>
511 static typename NumericTraits<T>::Promote
512 dot(T const * d)
513 {
514 return UnrollScalarResult<LEVEL>::dot(d);
515 }
516
517 template <class T1, class T2>
518 static typename PromoteTraits<T1, T2>::Promote
519 dot(T1 const * left, T2 const * right)
520 {
521 return UnrollScalarResult<LEVEL>::dot(left, right);
522 }
523
524 template <class T>
525 static typename NormTraits<T>::SquaredNormType
526 squaredNorm(T const * d)
527 {
528 return UnrollScalarResult<LEVEL>::squaredNorm(d);
529 }
530 };
531
532 #undef VIGRA_UNROLL_LOOP
533 #undef VIGRA_UNROLL_LOOP_MINMAX
534 #undef VIGRA_UNROLL_LOOP_SCALAR
535
536 template <>
537 struct UnrollLoop<0>
538 {
539 template <class T1, class T2>
540 static void reverseAssign(T1, T2) {}
541 template <class T1, class T2>
542 static void assignCast(T1, T2) {}
543 template <class T1, class T2>
544 static void assign(T1, T2) {}
545 template <class T1, class T2>
546 static void assignScalar(T1, T2) {}
547 template <class T1, class T2>
548 static void power(T1, T2) {}
549 template <class T1, class T2>
550 static void add(T1, T2) {}
551 template <class T1, class T2>
552 static void addScalar(T1, T2) {}
553 template <class T1, class T2>
554 static void sub(T1, T2) {}
555 template <class T1, class T2>
556 static void subScalar(T1, T2) {}
557 template <class T1, class T2>
558 static void mul(T1, T2) {}
559 template <class T1, class T2>
560 static void mulScalar(T1, T2) {}
561 template <class T1, class T2>
562 static void div(T1, T2) {}
563 template <class T1, class T2>
564 static void mod(T1, T2) {}
565 template <class T1, class T2>
566 static void divScalar(T1, T2) {}
567 template <class T1, class T2>
568 static void fromPromote(T1, T2) {}
569 template <class T1, class T2>
570 static void fromRealPromote(T1, T2) {}
571 template <class T1, class T2>
572 static void neg(T1, T2) {}
573 template <class T1, class T2>
574 static void abs(T1, T2) {}
575 template <class T1, class T2>
576 static void floor(T1, T2) {}
577 template <class T1, class T2>
578 static void ceil(T1, T2) {}
579 template <class T1, class T2>
580 static void round(T1, T2) {}
581 template <class T1, class T2>
582 static void sqrt(T1, T2) {}
583 template <class T1, class T2>
584 static bool notEqual(T1, T2) { return false; }
585 template <class T1, class T2>
586 static bool lexicographicLessThan(T1, T2) { return false; }
587 template <class T1, class T2>
588 static void min(T1, T2) {}
589 template <class T1, class T2>
590 static void max(T1, T2) {}
591 template <class T>
592 static T minimum(T const *) { return NumericTraits<T>::max(); }
593 template <class T>
594 static T maximum(T const *) { return NumericTraits<T>::min(); }
595 template <class T>
596 static bool all(T const *, T const &) { return true; }
597 template <class T>
598 static bool any(T const *, T const &) { return false; }
599 template <class T>
600 static bool closeAtTolerance(T const *, T const *, T) { return true; }
601 };
602
603 template <int SIZE>
604 struct LoopType
605 {
606 static const int MaxUnrollSize = 5;
607 typedef typename IfBool<(SIZE <= MaxUnrollSize), UnrollLoop<SIZE>, ExecLoop<SIZE> >::type type;
608
609 };
610
611 struct DontInit {};
612
613 inline DontInit dontInit() {return DontInit(); }
614
615 } // namespace detail
616
617 template <class T, int SIZE>
618 class TinyVector;
619
620 template <class T, int SIZE>
621 class TinyVectorView;
622
623 /********************************************************/
624 /* */
625 /* TinyVectorBase */
626 /* */
627 /********************************************************/
628
629 /** \brief Base class for fixed size vectors.
630
631 This class contains functionality shared by
632 \ref TinyVector and \ref TinyVectorView, and enables these classes
633 to be freely mixed within expressions. It is typically not used directly.
634
635 <b>\#include</b> <vigra/tinyvector.hxx><br>
636 Namespace: vigra
637 **/
638 template <class VALUETYPE, int SIZE, class DATA, class DERIVED>
639 class TinyVectorBase
640 {
641 TinyVectorBase(TinyVectorBase const &); // do not use
642
643 TinyVectorBase & operator=(TinyVectorBase const & other); // do not use
644
645 protected:
646
647 typedef typename detail::LoopType<SIZE>::type Loop;
648
649 TinyVectorBase()
650 {}
651
652 public:
653 /** STL-compatible definition of valuetype
654 */
655 typedef VALUETYPE value_type;
656
657 /** reference (return of operator[]).
658 */
659 typedef VALUETYPE & reference;
660
661 /** const reference (return of operator[] const).
662 */
663 typedef VALUETYPE const & const_reference;
664
665 /** pointer (return of operator->).
666 */
667 typedef VALUETYPE * pointer;
668
669 /** const pointer (return of operator-> const).
670 */
671 typedef VALUETYPE const * const_pointer;
672
673 /** STL-compatible definition of iterator
674 */
675 typedef value_type * iterator;
676
677 /** STL-compatible definition of const iterator
678 */
679 typedef value_type const * const_iterator;
680
681 /** STL-compatible definition of size_type
682 */
683 typedef unsigned int size_type;
684
685 /** STL-compatible definition of difference_type
686 */
687 typedef std::ptrdiff_t difference_type;
688
689 /** the scalar type for the outer product
690 */
691 typedef double scalar_multiplier;
692
693 /** the vector's squared norm type
694 */
695 typedef typename NormTraits<VALUETYPE>::SquaredNormType SquaredNormType;
696
697 /** the vector's norm type
698 */
699 typedef typename SquareRootTraits<SquaredNormType>::SquareRootResult NormType;
700
701 /** the vector's size
702 */
703 enum { static_size = SIZE };
704
705 /** Initialize from another sequence (must have length SIZE!)
706 */
707 template <class Iterator>
708 void init(Iterator i, Iterator end)
709 {
710 vigra_precondition(end-i == SIZE,
711 "TinyVector::init(): Sequence has wrong size.");
712 Loop::assignCast(data_, i);
713 }
714
715 /** Initialize with constant value
716 */
717 void init(value_type initial)
718 {
719 Loop::assignScalar(data_, initial);
720 }
721
722 /** Component-wise add-assignment
723 */
724 template <class T1, class D1, class D2>
725 DERIVED & operator+=(TinyVectorBase<T1, SIZE, D1, D2> const & r)
726 {
727 Loop::add(data_, r.begin());
728 return static_cast<DERIVED &>(*this);
729 }
730
731 /** Component-wise subtract-assignment
732 */
733 template <class T1, class D1, class D2>
734 DERIVED & operator-=(TinyVectorBase<T1, SIZE, D1, D2> const & r)
735 {
736 Loop::sub(data_, r.begin());
737 return static_cast<DERIVED &>(*this);
738 }
739
740 /** Component-wise multiply-assignment
741 */
742 template <class T1, class D1, class D2>
743 DERIVED & operator*=(TinyVectorBase<T1, SIZE, D1, D2> const & r)
744 {
745 Loop::mul(data_, r.begin());
746 return static_cast<DERIVED &>(*this);
747 }
748
749 /** Component-wise divide-assignment
750 */
751 template <class T1, class D1, class D2>
752 DERIVED & operator/=(TinyVectorBase<T1, SIZE, D1, D2> const & r)
753 {
754 Loop::div(data_, r.begin());
755 return static_cast<DERIVED &>(*this);
756 }
757
758 /** Component-wise modulo-assignment
759 */
760 template <class T1, class D1, class D2>
761 DERIVED & operator%=(TinyVectorBase<T1, SIZE, D1, D2> const & r)
762 {
763 Loop::mod(data_, r.begin());
764 return static_cast<DERIVED &>(*this);
765 }
766
767 /** Component-wise scalar multiply-assignment
768 */
769 DERIVED & operator+=(double r)
770 {
771 Loop::addScalar(data_, r);
772 return static_cast<DERIVED &>(*this);
773 }
774
775 /** Component-wise scalar divide-assignment
776 */
777 DERIVED & operator-=(double r)
778 {
779 Loop::subScalar(data_, r);
780 return static_cast<DERIVED &>(*this);
781 }
782
783 /** Component-wise scalar multiply-assignment
784 */
785 DERIVED & operator*=(double r)
786 {
787 Loop::mulScalar(data_, r);
788 return static_cast<DERIVED &>(*this);
789 }
790
791 /** Component-wise scalar divide-assignment
792 */
793 DERIVED & operator/=(double r)
794 {
795 Loop::divScalar(data_, r);
796 return static_cast<DERIVED &>(*this);
797 }
798
799 /** Calculate magnitude (i.e. 2-norm / Euclidean norm / length).
800 * \see squaredMagnitude()
801 */
802 NormType magnitude() const
803 {
804 return sqrt(static_cast<typename
805 SquareRootTraits<SquaredNormType>::SquareRootArgument>(squaredMagnitude()));
806 }
807
808 /** Calculate squared magnitude (i.e. sum of squared elements).
809 */
810 SquaredNormType squaredMagnitude() const
811 {
812 return Loop::squaredNorm(data_);
813 }
814
815 /** Return the minimal element.
816 */
817 VALUETYPE const & minimum() const
818 {
819 return Loop::minimum(data_);
820 }
821
822 /** Return the maximal element.
823 */
824 VALUETYPE const & maximum() const
825 {
826 return Loop::maximum(data_);
827 }
828
829 /** Check that all elements of this vector are non-zero (or 'true' if T is bool).
830 */
831 bool all() const
832 {
833 return Loop::all(data_, VALUETYPE());
834 }
835
836 /** Check that at least one element of this vector is non-zero (or 'true' if T is bool).
837 */
838 bool any() const
839 {
840 return Loop::any(data_, VALUETYPE());
841 }
842
843 /** Access component by index.
844 */
845 reference operator[](difference_type i)
846 {
847 VIGRA_ASSERT_INSIDE(i);
848 return data_[i];
849 }
850
851 /** Get component by index.
852 */
853 const_reference operator[](difference_type i) const
854 {
855 VIGRA_ASSERT_INSIDE(i);
856 return data_[i];
857 }
858
859 /** Get random access iterator to begin of vector.
860 */
861 iterator begin() { return data_; }
862 /** Get random access iterator past-the-end of vector.
863 */
864 iterator end() { return data_ + SIZE; }
865
866 /** Get const random access iterator to begin of vector.
867 */
868 const_iterator begin() const { return data_; }
869
870 /** Get const random access iterator past-the-end of vector.
871 */
872 const_iterator end() const { return data_ + SIZE; }
873
874 /** Get const random access iterator to begin of vector.
875 */
876 const_iterator cbegin() const { return data_; }
877
878 /** Get const random access iterator past-the-end of vector.
879 */
880 const_iterator cend() const { return data_ + SIZE; }
881
882 /** Get a view to the subarray with length <tt>(TO-FROM)</tt> starting at <tt>FROM</tt>.
883 The bounds must fullfill <tt>0 <= FROM < TO <= SIZE</tt>, but this is only
884 checked when <tt>VIGRA_CHECK_BOUNDS</tt> is \#define'd.
885 */
886 template <int FROM, int TO>
887 TinyVectorView<VALUETYPE, TO-FROM> subarray() const
888 {
889 #ifdef VIGRA_CHECK_BOUNDS
890 vigra_precondition(FROM >= 0, "Index out of bounds");
891 vigra_precondition(FROM < TO, "Index out of bounds");
892 vigra_precondition(TO <=SIZE, "Index out of bounds");
893 #endif
894 return TinyVectorView<VALUETYPE, TO-FROM>(data_+FROM);
895 }
896
897 TinyVector<VALUETYPE, SIZE-1>
898 dropIndex(int m) const
899 {
900 #ifdef VIGRA_CHECK_BOUNDS
901 vigra_precondition(0 <= m && m < SIZE, "Dimension out of bounds");
902 #endif
903 TinyVector<VALUETYPE, SIZE-1> res(SkipInitialization);
904 for(int k=0; k<m; ++k)
905 res[k] = data_[k];
906 for(int k=m; k<SIZE-1; ++k)
907 res[k] = data_[k+1];
908 return res;
909 }
910
911 /** Size of TinyVector vector always equals the template parameter SIZE.
912 */
913 size_type size() const { return SIZE; }
914
915 pointer data() { return data_; }
916
917 const_pointer data() const { return data_; }
918
919 reference front()
920 {
921 return data_[0];
922 }
923
924 const_reference front() const
925 {
926 return data_[0];
927 }
928
929 reference back()
930 {
931 return data_[SIZE-1];
932 }
933
934 const_reference back() const
935 {
936 return data_[SIZE-1];
937 }
938
939 /** \brief Factory function for a unit vector for dimension \a k.
940 */
941 static TinyVector<VALUETYPE, SIZE> unitVector(int k)
942 {
943 VIGRA_ASSERT_INSIDE(k);
944 TinyVector<VALUETYPE, SIZE> ret;
945 ret[k] = 1;
946 return ret;
947 }
948
949 /** \brief Factory function for a linear sequence.
950
951 The result will be initialized as <tt>res[k] = start + k*step</tt>.
952 */
953 static TinyVector<VALUETYPE, SIZE> linearSequence(VALUETYPE start=VALUETYPE(), VALUETYPE step=VALUETYPE(1))
954 {
955 TinyVector<VALUETYPE, SIZE> ret(SkipInitialization);
956 for(int k=0; k<SIZE; ++k, start+=step)
957 ret[k] = start;
958 return ret;
959 }
960
961 protected:
962
963 DATA data_;
964 };
965
966 #ifndef DOXYGEN
967
968 template <int SIZE, int DESIRED_SIZE>
969 struct TinyVector_constructor_has_wrong_number_of_arguments
970 : staticAssert::AssertBool<SIZE == DESIRED_SIZE>
971 {};
972
973 #endif /* DOXYGEN */
974
975 enum ReverseCopyTag { ReverseCopy };
976
977 /** \brief Class for fixed size vectors.
978 \ingroup RangesAndPoints
979
980 This class contains an array of size SIZE of the specified VALUETYPE.
981 The interface conforms to STL vector, except that there are no functions
982 that change the size of a TinyVector.
983
984 \ref TinyVectorOperators "Arithmetic operations"
985 on TinyVectors are defined as component-wise applications of these
986 operations. Addition and subtraction of two TinyVectors
987 (+=, -=, +, -, unary -), multiplication and division of an
988 TinyVector with a double, and NumericTraits/PromoteTraits are defined,
989 so that TinyVector fulfills the requirements of \ref LinearAlgebraConcept "Linear Algebra".
990
991 VIGRA algorithms typically use \ref vigra::VectorAccessor to access
992 TinyVectors as a whole, or specific components of them.
993
994 See also:<br>
995 <UL style="list-style-image:url(documents/bullet.gif)">
996 <LI> \ref vigra::TinyVectorBase
997 <LI> \ref vigra::TinyVectorView
998 <LI> \ref TinyVectorTraits
999 <LI> \ref TinyVectorOperators
1000 </UL>
1001
1002 <b>\#include</b> <vigra/tinyvector.hxx><br>
1003 Namespace: vigra
1004 **/
1005 template <class T, int SIZE>
1006 class TinyVector
1007 : public TinyVectorBase<T, SIZE, T[SIZE], TinyVector<T, SIZE> >
1008 {
1009 typedef TinyVectorBase<T, SIZE, T[SIZE], TinyVector<T, SIZE> > BaseType;
1010 typedef typename BaseType::Loop Loop;
1011
1012 public:
1013
1014 typedef typename BaseType::value_type value_type;
1015 typedef typename BaseType::reference reference;
1016 typedef typename BaseType::const_reference const_reference;
1017 typedef typename BaseType::pointer pointer;
1018 typedef typename BaseType::const_pointer const_pointer;
1019 typedef typename BaseType::iterator iterator;
1020 typedef typename BaseType::const_iterator const_iterator;
1021 typedef typename BaseType::size_type size_type;
1022 typedef typename BaseType::difference_type difference_type;
1023 typedef typename BaseType::scalar_multiplier scalar_multiplier;
1024 typedef typename BaseType::SquaredNormType SquaredNormType;
1025 typedef typename BaseType::NormType NormType;
1026
1027 /** Construction with constant value.
1028
1029 Initializes all vector elements with the given value.
1030 */
1031 explicit TinyVector(value_type const & initial)
1032 : BaseType()
1033 {
1034 Loop::assignScalar(BaseType::begin(), initial);
1035 }
1036
1037 /** Construction from lemon::Invalid.
1038
1039 Initializes all vector elements with -1.
1040 */
1041 TinyVector(lemon::Invalid const &)
1042 : BaseType()
1043 {
1044 Loop::assignScalar(BaseType::begin(), -1);
1045 }
1046
1047 /** Construction with Diff2D.
1048
1049 Use only when <tt>SIZE == 2</tt>.
1050 */
1051 explicit TinyVector(Diff2D const & initial)
1052 : BaseType()
1053 {
1054 BaseType::data_[0] = detail::RequiresExplicitCast<T>::cast(initial.x);
1055 BaseType::data_[1] = detail::RequiresExplicitCast<T>::cast(initial.y);
1056 }
1057
1058 /** Construction with explicit values.
1059 Call only if SIZE == 2
1060 */
1061 TinyVector(value_type const & i1, value_type const & i2)
1062 : BaseType()
1063 {
1064 VIGRA_STATIC_ASSERT((TinyVector_constructor_has_wrong_number_of_arguments<SIZE, 2>));
1065 BaseType::data_[0] = i1;
1066 BaseType::data_[1] = i2;
1067 }
1068
1069 /** Construction with explicit values.
1070 Call only if SIZE == 3
1071 */
1072 TinyVector(value_type const & i1, value_type const & i2, value_type const & i3)
1073 : BaseType()
1074 {
1075 VIGRA_STATIC_ASSERT((TinyVector_constructor_has_wrong_number_of_arguments<SIZE, 3>));
1076 BaseType::data_[0] = i1;
1077 BaseType::data_[1] = i2;
1078 BaseType::data_[2] = i3;
1079 }
1080
1081 /** Construction with explicit values.
1082 Call only if SIZE == 4
1083 */
1084 TinyVector(value_type const & i1, value_type const & i2,
1085 value_type const & i3, value_type const & i4)
1086 : BaseType()
1087 {
1088 VIGRA_STATIC_ASSERT((TinyVector_constructor_has_wrong_number_of_arguments<SIZE, 4>));
1089 BaseType::data_[0] = i1;
1090 BaseType::data_[1] = i2;
1091 BaseType::data_[2] = i3;
1092 BaseType::data_[3] = i4;
1093 }
1094
1095 /** Construction with explicit values.
1096 Call only if SIZE == 5
1097 */
1098 TinyVector(value_type const & i1, value_type const & i2,
1099 value_type const & i3, value_type const & i4,
1100 value_type const & i5)
1101 : BaseType()
1102 {
1103 VIGRA_STATIC_ASSERT((TinyVector_constructor_has_wrong_number_of_arguments<SIZE, 5>));
1104 BaseType::data_[0] = i1;
1105 BaseType::data_[1] = i2;
1106 BaseType::data_[2] = i3;
1107 BaseType::data_[3] = i4;
1108 BaseType::data_[4] = i5;
1109 }
1110
1111 /** Default constructor (initializes all elements with zero).
1112 */
1113 TinyVector()
1114 : BaseType()
1115 {
1116 Loop::assignScalar(BaseType::data_, value_type());
1117 }
1118
1119 /** Construct without initializing the vector elements.
1120 */
1121 explicit TinyVector(SkipInitializationTag)
1122 : BaseType()
1123 {}
1124
1125 explicit TinyVector(detail::DontInit)
1126 : BaseType()
1127 {}
1128
1129 /** Copy constructor.
1130 */
1131 TinyVector(TinyVector const & r)
1132 : BaseType()
1133 {
1134 Loop::assign(BaseType::data_, r.data_);
1135 }
1136
1137 /** Constructor from C array.
1138 */
1139 template <class U>
1140 explicit TinyVector(U const * data)
1141 : BaseType()
1142 {
1143 Loop::assign(BaseType::data_, data);
1144 }
1145
1146 /** Constructor by reverse copy from C array.
1147
1148 Usage:
1149 \code
1150 TinyVector<int, 3> v(1,2,3);
1151 TinyVector<int, 3> reversed(v.begin(), TinyVector<int, 3>::ReverseCopy);
1152 \endcode
1153 */
1154 explicit TinyVector(const_pointer data, ReverseCopyTag)
1155 : BaseType()
1156 {
1157 Loop::reverseAssign(BaseType::data_, data+SIZE-1);
1158 }
1159
1160 /** Copy with type conversion.
1161 */
1162 template <class U, class DATA, class DERIVED>
1163 TinyVector(TinyVectorBase<U, SIZE, DATA, DERIVED> const & r)
1164 : BaseType()
1165 {
1166 Loop::assignCast(BaseType::data_, r.begin());
1167 }
1168
1169 /** Copy assignment.
1170 */
1171 TinyVector & operator=(TinyVector const & r)
1172 {
1173 Loop::assign(BaseType::data_, r.data_);
1174 return *this;
1175 }
1176
1177 /** Copy assignment with type conversion.
1178 */
1179 template <class U, class DATA, class DERIVED>
1180 TinyVector & operator=(TinyVectorBase<U, SIZE, DATA, DERIVED> const & r)
1181 {
1182 Loop::assignCast(BaseType::data_, r.begin());
1183 return *this;
1184 }
1185
1186 /** Assignment from Diff2D.
1187
1188 Use only when <tt>SIZE == 2</tt>.
1189 */
1190 TinyVector & operator=(Diff2D const & r)
1191 {
1192 BaseType::data_[0] = detail::RequiresExplicitCast<T>::cast(r.x);
1193 BaseType::data_[1] = detail::RequiresExplicitCast<T>::cast(r.y);
1194 return *this;
1195 }
1196
1197 /** Assignment from scalar. Will set all entries to the given value.
1198 */
1199 TinyVector & operator=(value_type const & v)
1200 {
1201 Loop::assignScalar(BaseType::begin(), v);
1202 return *this;
1203 }
1204
1205 /** Copy from a TinyVector with a different number of elements.
1206
1207 Only the first <tt>min(SIZE, USIZE)</tt> elements are copied.
1208 */
1209 template <class U, int USIZE, class DATA, class DERIVED>
1210 TinyVector & copy(TinyVectorBase<U, USIZE, DATA, DERIVED> const & r)
1211 {
1212 static const int minSize = USIZE < SIZE
1213 ? USIZE
1214 : SIZE;
1215
1216 typedef typename detail::LoopType<minSize>::type MinLoop;
1217 MinLoop::assignCast(BaseType::data_, r.begin());
1218 return *this;
1219 }
1220 };
1221
1222 /** \brief Wrapper for fixed size vectors.
1223
1224 This class wraps an array of size SIZE of the specified VALUETYPE.
1225 Thus, the array can be accessed with an interface similar to
1226 that of std::vector (except that there are no functions
1227 that change the size of a TinyVectorView). The TinyVectorView
1228 does <em>not</em> assume ownership of the given memory.
1229
1230 \ref TinyVectorOperators "Arithmetic operations"
1231 on TinyVectorViews are defined as component-wise applications of these
1232 operations. Addition and subtraction of two TinyVectorViews
1233 (+=, -=, +, -, unary -), multiplication and division of an
1234 TinyVectorViews with a double, and NumericTraits/PromoteTraits are defined,
1235 so that TinyVectorView fulfills the requirements of \ref LinearAlgebraConcept "Linear Algebra".
1236
1237 VIGRA algorithms typically use \ref vigra::VectorAccessor to access
1238 TinyVectorViews as a whole, or specific components of them.
1239
1240 <b>See also:</b>
1241 <ul>
1242 <li> \ref vigra::TinyVectorBase
1243 <li> \ref vigra::TinyVector
1244 <li> \ref TinyVectorTraits
1245 <li> \ref TinyVectorOperators
1246 </ul>
1247
1248 <b>\#include</b> <vigra/tinyvector.hxx><br>
1249 Namespace: vigra
1250 **/
1251 template <class T, int SIZE>
1252 class TinyVectorView
1253 : public TinyVectorBase<T, SIZE, T *, TinyVectorView<T, SIZE> >
1254 {
1255 typedef TinyVectorBase<T, SIZE, T *, TinyVectorView<T, SIZE> > BaseType;
1256 typedef typename BaseType::Loop Loop;
1257
1258 public:
1259
1260 typedef typename BaseType::value_type value_type;
1261 typedef typename BaseType::reference reference;
1262 typedef typename BaseType::const_reference const_reference;
1263 typedef typename BaseType::pointer pointer;
1264 typedef typename BaseType::const_pointer const_pointer;
1265 typedef typename BaseType::iterator iterator;
1266 typedef typename BaseType::const_iterator const_iterator;
1267 typedef typename BaseType::size_type size_type;
1268 typedef typename BaseType::difference_type difference_type;
1269 typedef typename BaseType::scalar_multiplier scalar_multiplier;
1270 typedef typename BaseType::SquaredNormType SquaredNormType;
1271 typedef typename BaseType::NormType NormType;
1272
1273 /** Default constructor
1274 (pointer to wrapped data is NULL).
1275 */
1276 TinyVectorView()
1277 : BaseType()
1278 {
1279 BaseType::data_ = 0;
1280 }
1281
1282 /** Construct view for given data array
1283 */
1284 TinyVectorView(const_pointer data)
1285 : BaseType()
1286 {
1287 BaseType::data_ = const_cast<pointer>(data);
1288 }
1289
1290 /** Copy constructor (shallow copy).
1291 */
1292 TinyVectorView(TinyVectorView const & other)
1293 : BaseType()
1294 {
1295 BaseType::data_ = const_cast<pointer>(other.data_);
1296 }
1297
1298 /** Construct view from other TinyVector.
1299 */
1300 template <class DATA, class DERIVED>
1301 TinyVectorView(TinyVectorBase<T, SIZE, DATA, DERIVED> const & other)
1302 : BaseType()
1303 {
1304 BaseType::data_ = const_cast<pointer>(other.data());
1305 }
1306
1307 /** Copy the data (not the pointer) of the rhs.
1308 */
1309 TinyVectorView & operator=(TinyVectorView const & r)
1310 {
1311 Loop::assign(BaseType::data_, r.begin());
1312 return *this;
1313 }
1314
1315 /** Copy the data of the rhs with cast.
1316 */
1317 template <class U, class DATA, class DERIVED>
1318 TinyVectorView & operator=(TinyVectorBase<U, SIZE, DATA, DERIVED> const & r)
1319 {
1320 Loop::assignCast(BaseType::data_, r.begin());
1321 return *this;
1322 }
1323 };
1324
1325 /********************************************************/
1326 /* */
1327 /* TinyVector Comparison */
1328 /* */
1329 /********************************************************/
1330
1331 /** \addtogroup TinyVectorOperators Functions for TinyVector
1332
1333 \brief Implement basic arithmetic and equality for TinyVector.
1334
1335 These functions fulfill the requirements of a Linear Space (vector space).
1336 Return types are determined according to \ref TinyVectorTraits.
1337
1338 <b>\#include</b> <vigra/tinyvector.hxx><br>
1339 Namespace: vigra
1340 */
1341 //@{
1342 /// component-wise equal
1343 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1344 inline bool
1345 operator==(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1346 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1347 {
1348 return !(l != r);
1349 }
1350
1351 /// component-wise not equal
1352 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1353 inline bool
1354 operator!=(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1355 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1356 {
1357 typedef typename detail::LoopType<SIZE>::type ltype;
1358 return ltype::notEqual(l.begin(), r.begin());
1359 }
1360
1361 /// lexicographical comparison
1362 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1363 inline bool
1364 operator<(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1365 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1366 {
1367 typedef typename detail::LoopType<SIZE>::type ltype;
1368 return ltype::lexicographicLessThan(l.begin(), r.begin());
1369 }
1370
1371
1372 /// pointwise less-than
1373 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1374 inline bool
1375 allLess(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1376 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1377 {
1378 for(int k=0; k < SIZE; ++k)
1379 if (l[k] >= r[k])
1380 return false;
1381 return true;
1382 }
1383
1384 /// pointwise greater-than
1385 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1386 inline bool
1387 allGreater(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1388 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1389 {
1390 for(int k=0; k < SIZE; ++k)
1391 if(l[k] <= r[k])
1392 return false;
1393 return true;
1394 }
1395
1396 /// pointwise less-equal
1397 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1398 inline bool
1399 allLessEqual(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1400 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1401 {
1402 for(int k=0; k < SIZE; ++k)
1403 if (l[k] > r[k])
1404 return false;
1405 return true;
1406 }
1407
1408 /// pointwise greater-equal
1409 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1410 inline bool
1411 allGreaterEqual(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1412 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1413 {
1414 for(int k=0; k < SIZE; ++k)
1415 if (l[k] < r[k])
1416 return false;
1417 return true;
1418 }
1419
1420 template <class V, int SIZE, class D1, class D2, class D3, class D4>
1421 bool
1422 closeAtTolerance(TinyVectorBase<V, SIZE, D1, D2> const & l,
1423 TinyVectorBase<V, SIZE, D3, D4> const & r,
1424 V epsilon = NumericTraits<V>::epsilon())
1425 {
1426 typedef typename detail::LoopType<SIZE>::type ltype;
1427 return ltype::closeAtTolerance(l.begin(), r.begin(), epsilon);
1428 }
1429
1430 template <class V, int SIZE>
1431 bool
1432 closeAtTolerance(TinyVector<V, SIZE> const & l,
1433 TinyVector<V, SIZE> const & r,
1434 V epsilon = NumericTraits<V>::epsilon())
1435 {
1436 typedef typename detail::LoopType<SIZE>::type ltype;
1437 return ltype::closeAtTolerance(l.begin(), r.begin(), epsilon);
1438 }
1439
1440 /********************************************************/
1441 /* */
1442 /* TinyVector Output */
1443 /* */
1444 /********************************************************/
1445
1446 /// stream output
1447 template <class V1, int SIZE, class DATA, class DERIVED>
1448 std::ostream &
1449 operator<<(std::ostream & out, TinyVectorBase<V1, SIZE, DATA, DERIVED> const & l)
1450 {
1451 out << "(";
1452 int i;
1453 for(i=0; i<SIZE-1; ++i)
1454 out << l[i] << ", ";
1455 out << l[i] << ")";
1456 return out;
1457 }
1458 //@}
1459
1460 /********************************************************/
1461 /* */
1462 /* TinyVector-Traits */
1463 /* */
1464 /********************************************************/
1465
1466 /** \page TinyVectorTraits Numeric and Promote Traits of TinyVector
1467 The numeric and promote traits for TinyVectors follow
1468 the general specifications for \ref NumericPromotionTraits.
1469 They are implemented in terms of the traits of the basic types by
1470 partial template specialization:
1471
1472 \code
1473
1474 template <class T, int SIZE>
1475 struct NumericTraits<TinyVector<T, SIZE> >
1476 {
1477 typedef TinyVector<typename NumericTraits<T>::Promote, SIZE> Promote;
1478 typedef TinyVector<typename NumericTraits<T>::RealPromote, SIZE> RealPromote;
1479
1480 typedef typename NumericTraits<T>::isIntegral isIntegral;
1481 typedef VigraFalseType isScalar;
1482 typedef typename NumericTraits<T>::isSigned isSigned;
1483
1484 // etc.
1485 };
1486
1487 template <class T, int SIZE>
1488 struct NormTraits<TinyVector<T, SIZE> >
1489 {
1490 typedef TinyVector<T, SIZE> Type;
1491 typedef typename Type::SquaredNormType SquaredNormType;
1492 typedef typename Type::NormType NormType;
1493 };
1494
1495 template <class T1, class T2, SIZE>
1496 struct PromoteTraits<TinyVector<T1, SIZE>, TinyVector<T2, SIZE> >
1497 {
1498 typedef TinyVector<typename PromoteTraits<T1, T2>::Promote, SIZE> Promote;
1499 };
1500 \endcode
1501
1502 <b>\#include</b> <vigra/tinyvector.hxx><br>
1503 Namespace: vigra
1504
1505 On compilers that don't support partial template specialization (e.g.
1506 MS VisualC++), the traits classes are explicitly specialized for
1507 <TT>TinyVector<VALUETYPE, SIZE></TT> with
1508 <TT>VALUETYPE = unsigned char | int | float | double</TT> and <TT>SIZE = 2 | 3 | 4</TT>.
1509
1510 */
1511
1512 #if !defined(NO_PARTIAL_TEMPLATE_SPECIALIZATION)
1513
1514 template <class T, int SIZE>
1515 struct NumericTraits<TinyVector<T, SIZE> >
1516 {
1517 typedef TinyVector<T, SIZE> Type;
1518 typedef TinyVector<typename NumericTraits<T>::Promote, SIZE> Promote;
1519 typedef TinyVector<typename NumericTraits<T>::RealPromote, SIZE> RealPromote;
1520 typedef TinyVector<typename NumericTraits<T>::ComplexPromote, SIZE> ComplexPromote;
1521 typedef T ValueType;
1522
1523 typedef typename NumericTraits<T>::isIntegral isIntegral;
1524 typedef VigraFalseType isScalar;
1525 typedef typename NumericTraits<T>::isSigned isSigned;
1526 typedef VigraTrueType isOrdered;
1527 typedef VigraFalseType isComplex;
1528
1529 static TinyVector<T, SIZE> zero()
1530 {
1531 return TinyVector<T, SIZE>(NumericTraits<T>::zero());
1532 }
1533 static TinyVector<T, SIZE> one()
1534 {
1535 return TinyVector<T, SIZE>(NumericTraits<T>::one());
1536 }
1537 static TinyVector<T, SIZE> nonZero()
1538 {
1539 return TinyVector<T, SIZE>(NumericTraits<T>::nonZero());
1540 }
1541
1542 static TinyVector<T, SIZE> min()
1543 {
1544 return TinyVector<T, SIZE>(NumericTraits<T>::min());
1545 }
1546 static TinyVector<T, SIZE> max()
1547 {
1548 return TinyVector<T, SIZE>(NumericTraits<T>::max());
1549 }
1550
1551 template <class D1, class D2>
1552 static Promote toPromote(TinyVectorBase<T, SIZE, D1, D2> const & v)
1553 {
1554 return Promote(v);
1555 }
1556
1557 template <class D1, class D2>
1558 static RealPromote toRealPromote(TinyVectorBase<T, SIZE, D1, D2> const & v)
1559 {
1560 return RealPromote(v);
1561 }
1562
1563 template <class D1, class D2>
1564 static TinyVector<T, SIZE>
1565 fromPromote(TinyVectorBase<typename NumericTraits<T>::Promote, SIZE, D1, D2> const & v)
1566 {
1567 TinyVector<T, SIZE> res(detail::dontInit());
1568 typedef typename detail::LoopType<SIZE>::type ltype;
1569 ltype::fromPromote(res.begin(), v.begin());
1570 return res;
1571 }
1572
1573 template <class D1, class D2>
1574 static TinyVector<T, SIZE>
1575 fromRealPromote(TinyVectorBase<typename NumericTraits<T>::RealPromote, SIZE, D1, D2> const & v)
1576 {
1577 TinyVector<T, SIZE> res(detail::dontInit());
1578 typedef typename detail::LoopType<SIZE>::type ltype;
1579 ltype::fromRealPromote(res.begin(), v.begin());
1580 return res;
1581 }
1582 };
1583
1584 template <class T, int SIZE>
1585 struct NumericTraits<TinyVectorView<T, SIZE> >
1586 : public NumericTraits<TinyVector<T, SIZE> >
1587 {
1588 typedef TinyVector<T, SIZE> Type;
1589 typedef TinyVector<typename NumericTraits<T>::Promote, SIZE> Promote;
1590 typedef TinyVector<typename NumericTraits<T>::RealPromote, SIZE> RealPromote;
1591 typedef TinyVector<typename NumericTraits<T>::ComplexPromote, SIZE> ComplexPromote;
1592 typedef T ValueType;
1593
1594 typedef typename NumericTraits<T>::isIntegral isIntegral;
1595 typedef VigraFalseType isScalar;
1596 typedef typename NumericTraits<T>::isSigned isSigned;
1597 typedef VigraFalseType isOrdered;
1598 typedef VigraFalseType isComplex;
1599 };
1600
1601 template <class T, int SIZE>
1602 struct NormTraits<TinyVector<T, SIZE> >
1603 {
1604 typedef TinyVector<T, SIZE> Type;
1605 typedef typename Type::SquaredNormType SquaredNormType;
1606 typedef typename Type::NormType NormType;
1607 };
1608
1609 template <class T, int SIZE>
1610 struct NormTraits<TinyVectorView<T, SIZE> >
1611 {
1612 typedef TinyVector<T, SIZE> Type;
1613 typedef typename Type::SquaredNormType SquaredNormType;
1614 typedef typename Type::NormType NormType;
1615 };
1616
1617 template <class T1, class T2, int SIZE>
1618 struct PromoteTraits<TinyVector<T1, SIZE>, TinyVector<T2, SIZE> >
1619 {
1620 typedef TinyVector<typename PromoteTraits<T1, T2>::Promote, SIZE> Promote;
1621 };
1622
1623 template <class T1, class T2, int SIZE>
1624 struct PromoteTraits<TinyVectorView<T1, SIZE>, TinyVectorView<T2, SIZE> >
1625 {
1626 typedef TinyVector<typename PromoteTraits<T1, T2>::Promote, SIZE> Promote;
1627 };
1628
1629 template <class T1, class T2, int SIZE>
1630 struct PromoteTraits<TinyVectorView<T1, SIZE>, TinyVector<T2, SIZE> >
1631 {
1632 typedef TinyVector<typename PromoteTraits<T1, T2>::Promote, SIZE> Promote;
1633 };
1634
1635 template <class T1, class T2, int SIZE>
1636 struct PromoteTraits<TinyVector<T1, SIZE>, TinyVectorView<T2, SIZE> >
1637 {
1638 typedef TinyVector<typename PromoteTraits<T1, T2>::Promote, SIZE> Promote;
1639 };
1640
1641 template <class T, int SIZE>
1642 struct PromoteTraits<TinyVector<T, SIZE>, double >
1643 {
1644 typedef TinyVector<typename NumericTraits<T>::RealPromote, SIZE> Promote;
1645 };
1646
1647 template <class T, int SIZE>
1648 struct PromoteTraits<double, TinyVector<T, SIZE> >
1649 {
1650 typedef TinyVector<typename NumericTraits<T>::RealPromote, SIZE> Promote;
1651 };
1652
1653 template <class T, int SIZE>
1654 struct PromoteTraits<TinyVectorView<T, SIZE>, double >
1655 {
1656 typedef TinyVector<typename NumericTraits<T>::RealPromote, SIZE> Promote;
1657 };
1658
1659 template <class T, int SIZE>
1660 struct PromoteTraits<double, TinyVectorView<T, SIZE> >
1661 {
1662 typedef TinyVector<typename NumericTraits<T>::RealPromote, SIZE> Promote;
1663 };
1664
1665 template<class T, int SIZE>
1666 struct CanSkipInitialization<TinyVectorView<T, SIZE> >
1667 {
1668 typedef typename CanSkipInitialization<T>::type type;
1669 static const bool value = type::asBool;
1670 };
1671
1672 template<class T, int SIZE>
1673 struct CanSkipInitialization<TinyVector<T, SIZE> >
1674 {
1675 typedef typename CanSkipInitialization<T>::type type;
1676 static const bool value = type::asBool;
1677 };
1678
1679
1680
1681 #else // NO_PARTIAL_TEMPLATE_SPECIALIZATION
1682
1683
1684 #define TINYVECTOR_NUMTRAITS(T, SIZE) \
1685 template<>\
1686 struct NumericTraits<TinyVector<T, SIZE> >\
1687 {\
1688 typedef TinyVector<T, SIZE> Type;\
1689 typedef TinyVector<NumericTraits<T>::Promote, SIZE> Promote;\
1690 typedef TinyVector<NumericTraits<T>::RealPromote, SIZE> RealPromote;\
1691 typedef TinyVector<NumericTraits<T>::ComplexPromote, SIZE> ComplexPromote;\
1692 typedef T ValueType; \
1693 typedef NumericTraits<T>::isIntegral isIntegral;\
1694 typedef VigraFalseType isScalar;\
1695 typedef NumericTraits<T>::isSigned isSigned; \
1696 typedef VigraFalseType isOrdered;\
1697 typedef VigraFalseType isComplex;\
1698 \
1699 static TinyVector<T, SIZE> zero() { \
1700 return TinyVector<T, SIZE>(NumericTraits<T>::zero()); \
1701 }\
1702 static TinyVector<T, SIZE> one() { \
1703 return TinyVector<T, SIZE>(NumericTraits<T>::one()); \
1704 }\
1705 static TinyVector<T, SIZE> nonZero() { \
1706 return TinyVector<T, SIZE>(NumericTraits<T>::nonZero()); \
1707 }\
1708 \
1709 static Promote toPromote(TinyVector<T, SIZE> const & v) { \
1710 return Promote(v); \
1711 }\
1712 static RealPromote toRealPromote(TinyVector<T, SIZE> const & v) { \
1713 return RealPromote(v); \
1714 }\
1715 static TinyVector<T, SIZE> fromPromote(Promote const & v) { \
1716 TinyVector<T, SIZE> res;\
1717 TinyVector<T, SIZE>::iterator d = res.begin(), dend = res.end();\
1718 Promote::const_iterator s = v.begin();\
1719 for(; d != dend; ++d, ++s)\
1720 *d = NumericTraits<T>::fromPromote(*s);\
1721 return res;\
1722 }\
1723 static TinyVector<T, SIZE> fromRealPromote(RealPromote const & v) {\
1724 TinyVector<T, SIZE> res;\
1725 TinyVector<T, SIZE>::iterator d = res.begin(), dend = res.end();\
1726 RealPromote::const_iterator s = v.begin();\
1727 for(; d != dend; ++d, ++s)\
1728 *d = NumericTraits<T>::fromRealPromote(*s);\
1729 return res;\
1730 }\
1731 }; \
1732 template<>\
1733 struct NormTraits<TinyVector<T, SIZE> >\
1734 {\
1735 typedef TinyVector<T, SIZE> Type;\
1736 typedef Type::SquaredNormType SquaredNormType; \
1737 typedef Type::NormType NormType; \
1738 };
1739
1740 #define TINYVECTOR_PROMTRAITS1(type1, SIZE) \
1741 template<> \
1742 struct PromoteTraits<TinyVector<type1, SIZE>, TinyVector<type1, SIZE> > \
1743 { \
1744 typedef TinyVector<PromoteTraits<type1, type1>::Promote, SIZE> Promote; \
1745 static Promote toPromote(TinyVector<type1, SIZE> const & v) { \
1746 return static_cast<Promote>(v); } \
1747 };
1748
1749 #define TINYVECTOR_PROMTRAITS2(type1, type2, SIZE) \
1750 template<> \
1751 struct PromoteTraits<TinyVector<type1, SIZE>, TinyVector<type2, SIZE> > \
1752 { \
1753 typedef TinyVector<PromoteTraits<type1, type2>::Promote, SIZE> Promote; \
1754 static Promote toPromote(TinyVector<type1, SIZE> const & v) { \
1755 return static_cast<Promote>(v); } \
1756 static Promote toPromote(TinyVector<type2, SIZE> const & v) { \
1757 return static_cast<Promote>(v); } \
1758 };
1759
1760 #define TINYVECTOR_TRAITS(SIZE) \
1761 TINYVECTOR_NUMTRAITS(unsigned char, SIZE)\
1762 TINYVECTOR_NUMTRAITS(int, SIZE)\
1763 TINYVECTOR_NUMTRAITS(float, SIZE)\
1764 TINYVECTOR_NUMTRAITS(double, SIZE)\
1765 TINYVECTOR_PROMTRAITS1(unsigned char, SIZE)\
1766 TINYVECTOR_PROMTRAITS1(int, SIZE)\
1767 TINYVECTOR_PROMTRAITS1(float, SIZE)\
1768 TINYVECTOR_PROMTRAITS1(double, SIZE)\
1769 TINYVECTOR_PROMTRAITS2(float, unsigned char, SIZE)\
1770 TINYVECTOR_PROMTRAITS2(unsigned char, float, SIZE)\
1771 TINYVECTOR_PROMTRAITS2(int, unsigned char, SIZE)\
1772 TINYVECTOR_PROMTRAITS2(unsigned char, int, SIZE)\
1773 TINYVECTOR_PROMTRAITS2(int, float, SIZE)\
1774 TINYVECTOR_PROMTRAITS2(float, int, SIZE)\
1775 TINYVECTOR_PROMTRAITS2(double, unsigned char, SIZE)\
1776 TINYVECTOR_PROMTRAITS2(unsigned char, double, SIZE)\
1777 TINYVECTOR_PROMTRAITS2(int, double, SIZE)\
1778 TINYVECTOR_PROMTRAITS2(double, int, SIZE)\
1779 TINYVECTOR_PROMTRAITS2(double, float, SIZE)\
1780 TINYVECTOR_PROMTRAITS2(float, double, SIZE)
1781
1782 TINYVECTOR_TRAITS(2)
1783 TINYVECTOR_TRAITS(3)
1784 TINYVECTOR_TRAITS(4)
1785
1786 #undef TINYVECTOR_NUMTRAITS
1787 #undef TINYVECTOR_PROMTRAITS1
1788 #undef TINYVECTOR_PROMTRAITS2
1789 #undef TINYVECTOR_TRAITS
1790
1791 #endif // NO_PARTIAL_TEMPLATE_SPECIALIZATION
1792
1793
1794 /********************************************************/
1795 /* */
1796 /* TinyVector-Arithmetic */
1797 /* */
1798 /********************************************************/
1799
1800 /** \addtogroup TinyVectorOperators
1801 */
1802 //@{
1803
1804 /// component-wise addition
1805 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1806 inline
1807 typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2, SIZE> >::Promote
1808 operator+(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1809 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1810 {
1811 return typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2 , SIZE> >::Promote(l) += r;
1812 }
1813
1814 /// component-wise subtraction
1815 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1816 inline
1817 typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2, SIZE> >::Promote
1818 operator-(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1819 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1820 {
1821 return typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2 , SIZE> >::Promote(l) -= r;
1822 }
1823
1824 /// component-wise multiplication
1825 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1826 inline
1827 typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2, SIZE> >::Promote
1828 operator*(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1829 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1830 {
1831 return typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2 , SIZE> >::Promote(l) *= r;
1832 }
1833
1834 /// component-wise division
1835 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1836 inline
1837 typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2, SIZE> >::Promote
1838 operator/(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1839 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1840 {
1841 return typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2 , SIZE> >::Promote(l) /= r;
1842 }
1843
1844 /// component-wise modulo
1845 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
1846 inline
1847 typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2, SIZE> >::Promote
1848 operator%(TinyVectorBase<V1, SIZE, D1, D2> const & l,
1849 TinyVectorBase<V2, SIZE, D3, D4> const & r)
1850 {
1851 return typename PromoteTraits<TinyVector<V1, SIZE>, TinyVector<V2 , SIZE> >::Promote(l) %= r;
1852 }
1853
1854 /// component-wise left scalar addition
1855 template <class V, int SIZE, class D1, class D2>
1856 inline
1857 typename NumericTraits<TinyVector<V, SIZE> >::RealPromote
1858 operator+(double v, TinyVectorBase<V, SIZE, D1, D2> const & r)
1859 {
1860 return typename NumericTraits<TinyVector<V, SIZE> >::RealPromote(r) += v;
1861 }
1862
1863 /// component-wise right scalar addition
1864 template <class V, int SIZE, class D1, class D2>
1865 inline
1866 typename NumericTraits<TinyVector<V, SIZE> >::RealPromote
1867 operator+(TinyVectorBase<V, SIZE, D1, D2> const & l, double v)
1868 {
1869 return typename NumericTraits<TinyVector<V, SIZE> >::RealPromote(l) += v;
1870 }
1871
1872 /// component-wise left scalar subtraction
1873 template <class V, int SIZE, class D1, class D2>
1874 inline
1875 typename NumericTraits<TinyVector<V, SIZE> >::RealPromote
1876 operator-(double v, TinyVectorBase<V, SIZE, D1, D2> const & r)
1877 {
1878 return typename NumericTraits<TinyVector<V, SIZE> >::RealPromote(v) -= r;
1879 }
1880
1881 /// component-wise right scalar subtraction
1882 template <class V, int SIZE, class D1, class D2>
1883 inline
1884 typename NumericTraits<TinyVector<V, SIZE> >::RealPromote
1885 operator-(TinyVectorBase<V, SIZE, D1, D2> const & l, double v)
1886 {
1887 return typename NumericTraits<TinyVector<V, SIZE> >::RealPromote(l) -= v;
1888 }
1889
1890 /// component-wise left scalar multiplication
1891 template <class V, int SIZE, class D1, class D2>
1892 inline
1893 typename NumericTraits<TinyVector<V, SIZE> >::RealPromote
1894 operator*(double v, TinyVectorBase<V, SIZE, D1, D2> const & r)
1895 {
1896 return typename NumericTraits<TinyVector<V, SIZE> >::RealPromote(r) *= v;
1897 }
1898
1899 /// component-wise right scalar multiplication
1900 template <class V, int SIZE, class D1, class D2>
1901 inline
1902 typename NumericTraits<TinyVector<V, SIZE> >::RealPromote
1903 operator*(TinyVectorBase<V, SIZE, D1, D2> const & l, double v)
1904 {
1905 return typename NumericTraits<TinyVector<V, SIZE> >::RealPromote(l) *= v;
1906 }
1907
1908 /// component-wise left scalar division
1909 template <class V, int SIZE, class D1, class D2>
1910 inline
1911 typename NumericTraits<TinyVector<V, SIZE> >::RealPromote
1912 operator/(double v, TinyVectorBase<V, SIZE, D1, D2> const & r)
1913 {
1914 return typename NumericTraits<TinyVector<V, SIZE> >::RealPromote(v) /= r;
1915 }
1916
1917 /// component-wise right scalar division
1918 template <class V, int SIZE, class D1, class D2>
1919 inline
1920 typename NumericTraits<TinyVector<V, SIZE> >::RealPromote
1921 operator/(TinyVectorBase<V, SIZE, D1, D2> const & l, double v)
1922 {
1923 return typename NumericTraits<TinyVector<V, SIZE> >::RealPromote(l) /= v;
1924 }
1925
1926 /// component-wise scalar division without type promotion
1927 template <class V, int SIZE, class D1, class D2>
1928 inline
1929 TinyVector<V, SIZE>
1930 div(TinyVectorBase<V, SIZE, D1, D2> const & l, V v)
1931 {
1932 TinyVector<V, SIZE> result(l);
1933 typedef typename detail::LoopType<SIZE>::type Loop;
1934 Loop::divScalar(result.data(), v);
1935 return result;
1936 }
1937
1938
1939 /** Unary negation (construct TinyVector with negative values)
1940 */
1941 template <class V, int SIZE, class D1, class D2>
1942 inline
1943 TinyVector<V, SIZE>
1944 operator-(TinyVectorBase<V, SIZE, D1, D2> const & v)
1945 {
1946 TinyVector<V, SIZE> res(detail::dontInit());
1947 typedef typename detail::LoopType<SIZE>::type ltype;
1948 ltype::neg(res.begin(), v.begin());
1949 return res;
1950 }
1951
1952 /// component-wise absolute value
1953 template <class V, int SIZE, class D1, class D2>
1954 inline
1955 TinyVector<V, SIZE>
1956 abs(TinyVectorBase<V, SIZE, D1, D2> const & v)
1957 {
1958 TinyVector<V, SIZE> res(detail::dontInit());
1959 typedef typename detail::LoopType<SIZE>::type ltype;
1960 ltype::abs(res.begin(), v.begin());
1961 return res;
1962 }
1963
1964 /** Apply ceil() function to each vector component.
1965 */
1966 template <class V, int SIZE, class D1, class D2>
1967 inline
1968 TinyVector<V, SIZE>
1969 ceil(TinyVectorBase<V, SIZE, D1, D2> const & v)
1970 {
1971 TinyVector<V, SIZE> res(detail::dontInit());
1972 typedef typename detail::LoopType<SIZE>::type ltype;
1973 ltype::ceil(res.begin(), v.begin());
1974 return res;
1975 }
1976
1977 /** Apply floor() function to each vector component.
1978 */
1979 template <class V, int SIZE, class D1, class D2>
1980 inline
1981 TinyVector<V, SIZE>
1982 floor(TinyVectorBase<V, SIZE, D1, D2> const & v)
1983 {
1984 TinyVector<V, SIZE> res(detail::dontInit());
1985 typedef typename detail::LoopType<SIZE>::type ltype;
1986 ltype::floor(res.begin(), v.begin());
1987 return res;
1988 }
1989
1990 /** Apply round() function to each vector component.
1991 */
1992 template <class V, int SIZE, class D1, class D2>
1993 inline
1994 TinyVector<V, SIZE>
1995 round(TinyVectorBase<V, SIZE, D1, D2> const & v)
1996 {
1997 TinyVector<V, SIZE> res(detail::dontInit());
1998 typedef typename detail::LoopType<SIZE>::type ltype;
1999 ltype::round(res.begin(), v.begin());
2000 return res;
2001 }
2002
2003 /** Apply roundi() function to each vector component, i.e. return an integer vector.
2004 */
2005 template <class V, int SIZE, class D1, class D2>
2006 inline
2007 TinyVector<std::ptrdiff_t, SIZE>
2008 roundi(TinyVectorBase<V, SIZE, D1, D2> const & v)
2009 {
2010 TinyVector<V, SIZE> res(detail::dontInit());
2011 for(int k=0; k<SIZE; ++k)
2012 res[k] = roundi(v[k]);
2013 return res;
2014 }
2015
2016 /** Apply sqrt() function to each vector component.
2017 */
2018 template <class V, int SIZE, class D1, class D2>
2019 inline
2020 TinyVector<V, SIZE>
2021 sqrt(TinyVectorBase<V, SIZE, D1, D2> const & v)
2022 {
2023 TinyVector<V, SIZE> res(detail::dontInit());
2024 typedef typename detail::LoopType<SIZE>::type ltype;
2025 ltype::sqrt(res.begin(), v.begin());
2026 return res;
2027 }
2028
2029 using std::pow;
2030
2031 /** Apply pow() function to each vector component.
2032 */
2033 template <class V, int SIZE, class D1, class D2, class E>
2034 inline
2035 TinyVector<V, SIZE>
2036 pow(TinyVectorBase<V, SIZE, D1, D2> const & v, E exponent)
2037 {
2038 TinyVector<V, SIZE> res(v);
2039 typedef typename detail::LoopType<SIZE>::type ltype;
2040 ltype::power(res.begin(), exponent);
2041 return res;
2042 }
2043
2044 /// cross product
2045 template <class V1, class D1, class D2, class V2, class D3, class D4>
2046 inline
2047 TinyVector<typename PromoteTraits<V1, V2>::Promote, 3>
2048 cross(TinyVectorBase<V1, 3, D1, D2> const & r1,
2049 TinyVectorBase<V2, 3, D3, D4> const & r2)
2050 {
2051 typedef TinyVector<typename PromoteTraits<V1, V2>::Promote, 3>
2052 Res;
2053 return Res(r1[1]*r2[2] - r1[2]*r2[1],
2054 r1[2]*r2[0] - r1[0]*r2[2],
2055 r1[0]*r2[1] - r1[1]*r2[0]);
2056 }
2057
2058 /// dot product
2059 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
2060 inline
2061 typename PromoteTraits<V1, V2>::Promote
2062 dot(TinyVectorBase<V1, SIZE, D1, D2> const & l,
2063 TinyVectorBase<V2, SIZE, D3, D4> const & r)
2064 {
2065 typedef typename detail::LoopType<SIZE>::type ltype;
2066 return ltype::dot(l.begin(), r.begin());
2067 }
2068
2069 /// sum of the vector's elements
2070 template <class V, int SIZE, class D1, class D2>
2071 inline
2072 typename NumericTraits<V>::Promote
2073 sum(TinyVectorBase<V, SIZE, D1, D2> const & l)
2074 {
2075 typename NumericTraits<V>::Promote res = l[0];
2076 for(int k=1; k<SIZE; ++k)
2077 res += l[k];
2078 return res;
2079 }
2080
2081 /// cumulative sum of the vector's elements
2082 template <class V, int SIZE, class D1, class D2>
2083 inline
2084 TinyVector<typename NumericTraits<V>::Promote, SIZE>
2085 cumsum(TinyVectorBase<V, SIZE, D1, D2> const & l)
2086 {
2087 TinyVector<typename NumericTraits<V>::Promote, SIZE> res(l);
2088 for(int k=1; k<SIZE; ++k)
2089 res[k] += res[k-1];
2090 return res;
2091 }
2092
2093 /// product of the vector's elements
2094 template <class V, int SIZE, class D1, class D2>
2095 inline
2096 typename NumericTraits<V>::Promote
2097 prod(TinyVectorBase<V, SIZE, D1, D2> const & l)
2098 {
2099 typename NumericTraits<V>::Promote res = l[0];
2100 for(int k=1; k<SIZE; ++k)
2101 res *= l[k];
2102 return res;
2103 }
2104
2105 /// cumulative product of the vector's elements
2106 template <class V, int SIZE, class D1, class D2>
2107 inline
2108 TinyVector<typename NumericTraits<V>::Promote, SIZE>
2109 cumprod(TinyVectorBase<V, SIZE, D1, D2> const & l)
2110 {
2111 TinyVector<typename NumericTraits<V>::Promote, SIZE> res(l);
2112 for(int k=1; k<SIZE; ++k)
2113 res[k] *= res[k-1];
2114 return res;
2115 }
2116
2117 using std::min;
2118
2119 /// element-wise minimum
2120 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
2121 inline
2122 TinyVector<typename PromoteTraits<V1, V2>::Promote, SIZE>
2123 min(TinyVectorBase<V1, SIZE, D1, D2> const & l,
2124 TinyVectorBase<V2, SIZE, D3, D4> const & r)
2125 {
2126 typedef typename detail::LoopType<SIZE>::type ltype;
2127 TinyVector<typename PromoteTraits<V1, V2>::Promote, SIZE> res(l);
2128 ltype::min(res.begin(), r.begin());
2129 return res;
2130 }
2131
2132 // we also have to overload min for like-typed argument to prevent match of std::min()
2133 template <class V1, int SIZE, class D1, class D2>
2134 inline
2135 TinyVector<V1, SIZE>
2136 min(TinyVectorBase<V1, SIZE, D1, D2> const & l,
2137 TinyVectorBase<V1, SIZE, D1, D2> const & r)
2138 {
2139 typedef typename detail::LoopType<SIZE>::type ltype;
2140 TinyVector<V1, SIZE> res(l);
2141 ltype::min(res.begin(), r.begin());
2142 return res;
2143 }
2144
2145 template <class V1, int SIZE>
2146 inline
2147 TinyVector<V1, SIZE>
2148 min(TinyVector<V1, SIZE> const & l,
2149 TinyVector<V1, SIZE> const & r)
2150 {
2151 typedef typename detail::LoopType<SIZE>::type ltype;
2152 TinyVector<V1, SIZE> res(l);
2153 ltype::min(res.begin(), r.begin());
2154 return res;
2155 }
2156
2157 /// minimum element
2158 template <class V, int SIZE, class D1, class D2>
2159 inline
2160 V const &
2161 min(TinyVectorBase<V, SIZE, D1, D2> const & l)
2162 {
2163 return l.minimum();
2164 }
2165
2166 using std::max;
2167
2168 /// element-wise maximum
2169 template <class V1, int SIZE, class D1, class D2, class V2, class D3, class D4>
2170 inline
2171 TinyVector<typename PromoteTraits<V1, V2>::Promote, SIZE>
2172 max(TinyVectorBase<V1, SIZE, D1, D2> const & l,
2173 TinyVectorBase<V2, SIZE, D3, D4> const & r)
2174 {
2175 typedef typename detail::LoopType<SIZE>::type ltype;
2176 TinyVector<typename PromoteTraits<V1, V2>::Promote, SIZE> res(l);
2177 ltype::max(res.begin(), r.begin());
2178 return res;
2179 }
2180
2181 // we also have to overload max for like-typed argument to prevent match of std::max()
2182 template <class V1, int SIZE, class D1, class D2>
2183 inline
2184 TinyVector<V1, SIZE>
2185 max(TinyVectorBase<V1, SIZE, D1, D2> const & l,
2186 TinyVectorBase<V1, SIZE, D1, D2> const & r)
2187 {
2188 typedef typename detail::LoopType<SIZE>::type ltype;
2189 TinyVector<V1, SIZE> res(l);
2190 ltype::max(res.begin(), r.begin());
2191 return res;
2192 }
2193
2194 template <class V1, int SIZE>
2195 inline
2196 TinyVector<V1, SIZE>
2197 max(TinyVector<V1, SIZE> const & l,
2198 TinyVector<V1, SIZE> const & r)
2199 {
2200 typedef typename detail::LoopType<SIZE>::type ltype;
2201 TinyVector<V1, SIZE> res(l);
2202 ltype::max(res.begin(), r.begin());
2203 return res;
2204 }
2205
2206 /// maximum element
2207 template <class V, int SIZE, class D1, class D2>
2208 inline
2209 V const &
2210 max(TinyVectorBase<V, SIZE, D1, D2> const & l)
2211 {
2212 return l.maximum();
2213 }
2214
2215 /// squared norm
2216 template <class V1, int SIZE, class D1, class D2>
2217 inline
2218 typename TinyVectorBase<V1, SIZE, D1, D2>::SquaredNormType
2219 squaredNorm(TinyVectorBase<V1, SIZE, D1, D2> const & t)
2220 {
2221 return t.squaredMagnitude();
2222 }
2223
2224 /// squared norm
2225 template <class V, int SIZE>
2226 inline
2227 typename TinyVector<V, SIZE>::SquaredNormType
2228 squaredNorm(TinyVector<V, SIZE> const & t)
2229 {
2230 return t.squaredMagnitude();
2231 }
2232
2233 using std::reverse;
2234
2235 /// reversed copy
2236 template <class V, int SIZE>
2237 inline
2238 TinyVector<V, SIZE>
2239 reverse(TinyVector<V, SIZE> const & t)
2240 {
2241 return TinyVector<V, SIZE>(t.begin(), ReverseCopy);
2242 }
2243
2244 /** \brief transposed copy
2245
2246 Elements are arranged such that <tt>res[k] = t[permutation[k]]</tt>.
2247 */
2248 template <class V, int SIZE, class T>
2249 inline
2250 TinyVector<V, SIZE>
2251 transpose(TinyVector<V, SIZE> const & t, TinyVector<T, SIZE> const & permutation)
2252 {
2253 TinyVector<V, SIZE> res(SkipInitialization);
2254 for(int k=0; k<SIZE; ++k)
2255 {
2256 VIGRA_ASSERT_INSIDE(permutation[k]);
2257 res[k] = t[permutation[k]];
2258 }
2259 return res;
2260 }
2261
2262 /** \brief Clip negative values.
2263
2264 All elements smaller than 0 are set to zero.
2265 */
2266 template<class V,int SIZE>
2267 inline
2268 TinyVector<V, SIZE> clipLower(TinyVector<V, SIZE> const & t){
2269 return clipLower(t, V(0));
2270 }
2271
2272 /** \brief Clip values below a threshold.
2273
2274 All elements smaller than \a val are set to \a val.
2275 */
2276 template<class V,int SIZE>
2277 inline
2278 TinyVector<V, SIZE> clipLower(TinyVector<V, SIZE> const & t,const V val){
2279 TinyVector<V, SIZE> res(SkipInitialization);
2280 for(int k=0; k<SIZE; ++k){
2281 res[k]=t[k]< val ? val : t[k];
2282 }
2283 return res;
2284 }
2285
2286 /** \brief Clip values above a threshold.
2287
2288 All elements bigger than \a val are set to \a val.
2289 */
2290 template<class V,int SIZE>
2291 inline
2292 TinyVector<V, SIZE> clipUpper(TinyVector<V, SIZE> const & t,const V val){
2293 TinyVector<V, SIZE> res(SkipInitialization);
2294 for(int k=0; k<SIZE; ++k){
2295 res[k]=t[k]> val ? val : t[k];
2296 }
2297 return res;
2298 }
2299
2300 /** \brief Clip values to an interval.
2301
2302 All elements less than \a valLower are set to \a valLower, all elements
2303 bigger than \a valUpper are set to \a valUpper.
2304 */
2305 template<class V,int SIZE>
2306 inline
2307 TinyVector<V, SIZE> clip(TinyVector<V, SIZE> const & t,const V valLower, const V valUpper){
2308 TinyVector<V, SIZE> res(SkipInitialization);
2309 for(int k=0; k<SIZE; ++k){
2310 res[k] = (t[k] < valLower)
2311 ? valLower
2312 : (t[k] > valUpper)
2313 ? valUpper
2314 : t[k];
2315 }
2316 return res;
2317 }
2318
2319 /** \brief Clip values to a vector of intervals.
2320
2321 All elements less than \a valLower are set to \a valLower, all elements
2322 bigger than \a valUpper are set to \a valUpper.
2323 */
2324 template<class V,int SIZE>
2325 inline
2326 TinyVector<V, SIZE> clip(TinyVector<V, SIZE> const & t,
2327 TinyVector<V, SIZE> const & valLower,
2328 TinyVector<V, SIZE> const & valUpper)
2329 {
2330 TinyVector<V, SIZE> res(SkipInitialization);
2331 for(int k=0; k<SIZE; ++k){
2332 res[k] = (t[k] < valLower[k])
2333 ? valLower[k]
2334 : (t[k] > valUpper[k])
2335 ? valUpper[k]
2336 : t[k];
2337 }
2338 return res;
2339 }
2340
2341 /** \brief Round up values to the nearest power of 2.
2342 Implemented only for UInt32
2343 */
2344 template<int SIZE>
2345 inline TinyVector<UInt32,SIZE> ceilPower2(vigra::TinyVector<UInt32,SIZE> const & t)
2346 {
2347 TinyVector<UInt32,SIZE> res(SkipInitialization);
2348 for( size_t k = 0; k < SIZE; k++)
2349 res[k] = ceilPower2(t[k]);
2350 return res;
2351 }
2352
2353 /** \brief Round down values to the nearest power of 2.
2354 Implemented only for UInt32
2355 */
2356 template<int SIZE>
2357 inline TinyVector<UInt32,SIZE> floorPower2(vigra::TinyVector<UInt32,SIZE> const & t)
2358 {
2359 TinyVector<UInt32, SIZE> res(SkipInitialization);
2360 for( size_t k = 0; k < SIZE; k++)
2361 res[k] = floorPower2(t[k]);
2362 return res;
2363 }
2364
2365 template<class V,int SIZE>
2366 inline
2367 bool isZero(TinyVector<V, SIZE> const & t){
2368 for(int k=0; k<SIZE; ++k){
2369 if(t[k]!=static_cast<V>(0))
2370 return false;
2371 }
2372 return true;
2373 }
2374
2375 template<class V,int SIZE>
2376 inline typename NumericTraits<V>::RealPromote
2377 mean(TinyVector<V, SIZE> const & t){
2378 const V sumVal = sum(t);
2379 return static_cast< typename NumericTraits<V>::RealPromote>(sumVal)/SIZE;
2380 }
2381
2382
2383 template<class V,int SIZE>
2384 inline typename NumericTraits<V>::RealPromote
2385 sizeDividedSquaredNorm(TinyVector<V, SIZE> const & t){
2386 return squaredNorm(t)/SIZE;
2387 }
2388
2389 template<class V,int SIZE>
2390 inline typename NumericTraits<V>::RealPromote
2391 sizeDividedNorm(TinyVector<V, SIZE> const & t){
2392 return norm(t)/SIZE;
2393 }
2394
2395
2396
2397 //@}
2398
2399 // mask cl.exe shortcomings [end]
2400 #if defined(_MSC_VER)
2401 #pragma warning( pop )
2402 #endif
2403
2404 } // namespace vigra
2405 #undef VIGRA_ASSERT_INSIDE
2406 #endif // VIGRA_TINYVECTOR_HXX
vigra::TinyVectorBase::linearSequence
static TinyVector< VALUETYPE, SIZE > linearSequence(VALUETYPE start=VALUETYPE(), VALUETYPE step=VALUETYPE(1))
Factory function for a linear sequence.
Definition: tinyvector.hxx:953
vigra::TinyVectorBase::magnitude
NormType magnitude() const
Definition: tinyvector.hxx:802
vigra::TinyVectorBase::operator[]
const_reference operator[](difference_type i) const
Definition: tinyvector.hxx:853
vigra::TinyVectorBase::operator/=
DERIVED & operator/=(double r)
Definition: tinyvector.hxx:793
vigra::dot
PromoteTraits< V1, V2 >::Promote dot(RGBValue< V1, RIDX1, GIDX1, BIDX1 > const &r1, RGBValue< V2, RIDX2, GIDX2, BIDX2 > const &r2)
dot product
Definition: rgbvalue.hxx:906
vigra::cross
PromoteTraits< RGBValue< V1, R, G, B >, RGBValue< V2, R, G, B > >::Promote cross(RGBValue< V1, R, G, B > const &r1, RGBValue< V2, R, G, B > const &r2)
cross product
Definition: rgbvalue.hxx:889
vigra::TinyVectorView::operator=
TinyVectorView & operator=(TinyVectorView const &r)
Definition: tinyvector.hxx:1309
vigra::TinyVectorBase::all
bool all() const
Definition: tinyvector.hxx:831
vigra::TinyVector::TinyVector
TinyVector(value_type const &initial)
Definition: tinyvector.hxx:1031
vigra::Diff2D::y
int y
Definition: diff2d.hxx:392
vigra::roundi
Int32 roundi(FixedPoint16< IntBits, OverflowHandling > v)
rounding to the nearest integer.
Definition: fixedpoint.hxx:1775
vigra::TinyVectorBase::pointer
VALUETYPE * pointer
Definition: tinyvector.hxx:667
vigra::operator-
Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:711
vigra::TinyVectorBase::const_iterator
value_type const * const_iterator
Definition: tinyvector.hxx:679
vigra::TinyVectorBase::scalar_multiplier
double scalar_multiplier
Definition: tinyvector.hxx:691
vigra::TinyVectorBase::operator-=
DERIVED & operator-=(double r)
Definition: tinyvector.hxx:777
vigra::TinyVectorBase::const_pointer
VALUETYPE const * const_pointer
Definition: tinyvector.hxx:671
vigra::TinyVector::TinyVector
TinyVector(TinyVector const &r)
Definition: tinyvector.hxx:1131
vigra::round
TinyVector< V, SIZE > round(TinyVectorBase< V, SIZE, D1, D2 > const &v)
Definition: tinyvector.hxx:1995
vigra::TinyVectorBase::operator+=
DERIVED & operator+=(TinyVectorBase< T1, SIZE, D1, D2 > const &r)
Definition: tinyvector.hxx:725
vigra::TinyVector::TinyVector
TinyVector(TinyVectorBase< U, SIZE, DATA, DERIVED > const &r)
Definition: tinyvector.hxx:1163
vigra::sub
void sub(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
subtraction with enforced result type.
Definition: fixedpoint.hxx:583
vigra::div
TinyVector< V, SIZE > div(TinyVectorBase< V, SIZE, D1, D2 > const &l, V v)
component-wise scalar division without type promotion
Definition: tinyvector.hxx:1930
vigra::clipUpper
TinyVector< V, SIZE > clipUpper(TinyVector< V, SIZE > const &t, const V val)
Clip values above a threshold.
Definition: tinyvector.hxx:2292
vigra::TinyVector::TinyVector
TinyVector(value_type const &i1, value_type const &i2, value_type const &i3, value_type const &i4, value_type const &i5)
Definition: tinyvector.hxx:1098
vigra::TinyVectorBase::operator+=
DERIVED & operator+=(double r)
Definition: tinyvector.hxx:769
vigra::Diff2D::x
int x
Definition: diff2d.hxx:385
vigra::squaredNorm
FFTWComplex< R >::SquaredNormType squaredNorm(const FFTWComplex< R > &a)
squared norm (= squared magnitude)
Definition: fftw3.hxx:1044
vigra::power
V power(const V &x)
Exponentiation to a positive integer power by squaring.
Definition: mathutil.hxx:427
vigra::TinyVectorBase::begin
const_iterator begin() const
Definition: tinyvector.hxx:868
vigra::TinyVectorBase::end
const_iterator end() const
Definition: tinyvector.hxx:872
vigra::round
int round(FixedPoint< IntBits, FracBits > v)
rounding to the nearest integer.
Definition: fixedpoint.hxx:683
vigra::TinyVectorBase::end
iterator end()
Definition: tinyvector.hxx:864
vigra::operator+
Diff2D operator+(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:739
vigra::Diff2D
Two dimensional difference vector.
Definition: diff2d.hxx:185
vigra::add
void add(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
addition with enforced result type.
Definition: fixedpoint.hxx:561
vigra::TinyVectorBase::cbegin
const_iterator cbegin() const
Definition: tinyvector.hxx:876
vigra::ceil
TinyVector< V, SIZE > ceil(TinyVectorBase< V, SIZE, D1, D2 > const &v)
Definition: tinyvector.hxx:1969
vigra::TinyVectorBase::squaredMagnitude
SquaredNormType squaredMagnitude() const
Definition: tinyvector.hxx:810
vigra::allLess
bool allLess(TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
pointwise less-than
Definition: tinyvector.hxx:1375
vigra::TinyVector::TinyVector
TinyVector(Diff2D const &initial)
Definition: tinyvector.hxx:1051
vigra::TinyVector::TinyVector
TinyVector(const_pointer data, ReverseCopyTag)
Definition: tinyvector.hxx:1154
vigra::TinyVectorBase::operator/=
DERIVED & operator/=(TinyVectorBase< T1, SIZE, D1, D2 > const &r)
Definition: tinyvector.hxx:752
vigra::sqrt
TinyVector< V, SIZE > sqrt(TinyVectorBase< V, SIZE, D1, D2 > const &v)
Definition: tinyvector.hxx:2021
vigra::TinyVector::copy
TinyVector & copy(TinyVectorBase< U, USIZE, DATA, DERIVED > const &r)
Definition: tinyvector.hxx:1210
vigra::TinyVectorBase::iterator
value_type * iterator
Definition: tinyvector.hxx:675
vigra::TinyVectorBase::operator*=
DERIVED & operator*=(double r)
Definition: tinyvector.hxx:785
vigra::TinyVectorBase::operator-=
DERIVED & operator-=(TinyVectorBase< T1, SIZE, D1, D2 > const &r)
Definition: tinyvector.hxx:734
vigra::norm
FFTWComplex< R >::NormType norm(const FFTWComplex< R > &a)
norm (= magnitude)
Definition: fftw3.hxx:1037
vigra::TinyVector::operator=
TinyVector & operator=(TinyVector const &r)
Definition: tinyvector.hxx:1171
vigra::TinyVector::TinyVector
TinyVector()
Definition: tinyvector.hxx:1113
vigra::TinyVectorBase::value_type
VALUETYPE value_type
Definition: tinyvector.hxx:655
vigra::clip
TinyVector< V, SIZE > clip(TinyVector< V, SIZE > const &t, const V valLower, const V valUpper)
Clip values to an interval.
Definition: tinyvector.hxx:2307
vigra::mul
void mul(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
multiplication with enforced result type.
Definition: fixedpoint.hxx:605
vigra::prod
NumericTraits< V >::Promote prod(TinyVectorBase< V, SIZE, D1, D2 > const &l)
product of the vector's elements
Definition: tinyvector.hxx:2097
vigra::TinyVectorView::TinyVectorView
TinyVectorView(TinyVectorBase< T, SIZE, DATA, DERIVED > const &other)
Definition: tinyvector.hxx:1301
vigra::sum
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements
Definition: tinyvector.hxx:2073
vigra::TinyVector::TinyVector
TinyVector(value_type const &i1, value_type const &i2, value_type const &i3, value_type const &i4)
Definition: tinyvector.hxx:1084
vigra::TinyVectorView::TinyVectorView
TinyVectorView()
Definition: tinyvector.hxx:1276
vigra::operator!=
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal
Definition: fftw3.hxx:841
vigra::TinyVectorBase::init
void init(value_type initial)
Definition: tinyvector.hxx:717
vigra::TinyVectorBase::reference
VALUETYPE & reference
Definition: tinyvector.hxx:659
vigra::TinyVectorBase::begin
iterator begin()
Definition: tinyvector.hxx:861
vigra::operator==
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal
Definition: fftw3.hxx:825
vigra::TinyVectorBase::size
size_type size() const
Definition: tinyvector.hxx:913
vigra::pow
TinyVector< V, SIZE > pow(TinyVectorBase< V, SIZE, D1, D2 > const &v, E exponent)
Definition: tinyvector.hxx:2036
vigra::TinyVectorBase::const_reference
VALUETYPE const & const_reference
Definition: tinyvector.hxx:663
vigra::TinyVector::operator=
TinyVector & operator=(value_type const &v)
Definition: tinyvector.hxx:1199
vigra::squaredNorm
TinyVector< V, SIZE >::SquaredNormType squaredNorm(TinyVector< V, SIZE > const &t)
squared norm
Definition: tinyvector.hxx:2228
vigra::TinyVectorBase::unitVector
static TinyVector< VALUETYPE, SIZE > unitVector(int k)
Factory function for a unit vector for dimension k.
Definition: tinyvector.hxx:941
vigra::TinyVector::TinyVector
TinyVector(value_type const &i1, value_type const &i2, value_type const &i3)
Definition: tinyvector.hxx:1072
vigra::TinyVector::TinyVector
TinyVector(SkipInitializationTag)
Definition: tinyvector.hxx:1121
vigra::TinyVectorView::operator=
TinyVectorView & operator=(TinyVectorBase< U, SIZE, DATA, DERIVED > const &r)
Definition: tinyvector.hxx:1318
vigra::max
V const & max(TinyVectorBase< V, SIZE, D1, D2 > const &l)
maximum element
Definition: tinyvector.hxx:2210
vigra::cumsum
TinyVector< typename NumericTraits< V >::Promote, SIZE > cumsum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
cumulative sum of the vector's elements
Definition: tinyvector.hxx:2085
vigra::TinyVectorView
Wrapper for fixed size vectors.
Definition: tinyvector.hxx:621
vigra::allGreaterEqual
bool allGreaterEqual(TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
pointwise greater-equal
Definition: tinyvector.hxx:1411
vigra::TinyVector
Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE...
Definition: accessor.hxx:940
vigra::closeAtTolerance
bool closeAtTolerance(T1 l, T2 r, typename PromoteTraits< T1, T2 >::Promote epsilon)
Tolerance based floating-point equality.
Definition: mathutil.hxx:1638
vigra::div
FixedPoint16< IntBits3, OverflowHandling > & div(FixedPoint16< IntBits1, OverflowHandling > l, FixedPoint16< IntBits2, OverflowHandling > r, FixedPoint16< IntBits3, OverflowHandling > &result)
division with enforced result type.
Definition: fixedpoint.hxx:1616
vigra::TinyVectorBase::size_type
unsigned int size_type
Definition: tinyvector.hxx:683
vigra::TinyVectorBase::subarray
TinyVectorView< VALUETYPE, TO-FROM > subarray() const
Definition: tinyvector.hxx:887
vigra::TinyVectorView::TinyVectorView
TinyVectorView(TinyVectorView const &other)
Definition: tinyvector.hxx:1292
vigra::TinyVectorBase
Base class for fixed size vectors.
Definition: tinyvector.hxx:82
vigra::abs
FFTWComplex< R >::NormType abs(const FFTWComplex< R > &a)
absolute value (= magnitude)
Definition: fftw3.hxx:1002
vigra::floor
TinyVector< V, SIZE > floor(TinyVectorBase< V, SIZE, D1, D2 > const &v)
Definition: tinyvector.hxx:1982
vigra::TinyVector::TinyVector
TinyVector(U const *data)
Definition: tinyvector.hxx:1140
vigra::TinyVectorBase::NormType
SquareRootTraits< SquaredNormType >::SquareRootResult NormType
Definition: tinyvector.hxx:699
vigra::TinyVectorBase::maximum
VALUETYPE const & maximum() const
Definition: tinyvector.hxx:824
vigra::TinyVectorBase::difference_type
std::ptrdiff_t difference_type
Definition: tinyvector.hxx:687
vigra::clipLower
TinyVector< V, SIZE > clipLower(TinyVector< V, SIZE > const &t)
Clip negative values.
Definition: tinyvector.hxx:2268
vigra::floorPower2
UInt32 floorPower2(UInt32 x)
Round down to the nearest power of 2.
Definition: mathutil.hxx:317
vigra::TinyVectorBase::any
bool any() const
Definition: tinyvector.hxx:838
vigra::TinyVector::TinyVector
TinyVector(value_type const &i1, value_type const &i2)
Definition: tinyvector.hxx:1061
vigra::allLessEqual
bool allLessEqual(TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
pointwise less-equal
Definition: tinyvector.hxx:1399
vigra::ceilPower2
UInt32 ceilPower2(UInt32 x)
Round up to the nearest power of 2.
Definition: mathutil.hxx:294
vigra::allGreater
bool allGreater(TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
pointwise greater-than
Definition: tinyvector.hxx:1387
vigra::ceil
int ceil(FixedPoint< IntBits, FracBits > v)
rounding up.
Definition: fixedpoint.hxx:675
vigra::TinyVectorBase::cend
const_iterator cend() const
Definition: tinyvector.hxx:880
vigra::reverse
TinyVector< V, SIZE > reverse(TinyVector< V, SIZE > const &t)
reversed copy
Definition: tinyvector.hxx:2239
vigra::TinyVectorView::TinyVectorView
TinyVectorView(const_pointer data)
Definition: tinyvector.hxx:1284
vigra::TinyVector::operator=
TinyVector & operator=(TinyVectorBase< U, SIZE, DATA, DERIVED > const &r)
Definition: tinyvector.hxx:1180
vigra::floor
int floor(FixedPoint< IntBits, FracBits > v)
rounding down.
Definition: fixedpoint.hxx:667
vigra::cumprod
TinyVector< typename NumericTraits< V >::Promote, SIZE > cumprod(TinyVectorBase< V, SIZE, D1, D2 > const &l)
cumulative product of the vector's elements
Definition: tinyvector.hxx:2109
vigra::TinyVectorBase::minimum
VALUETYPE const & minimum() const
Definition: tinyvector.hxx:817
vigra::TinyVectorBase::operator%=
DERIVED & operator%=(TinyVectorBase< T1, SIZE, D1, D2 > const &r)
Definition: tinyvector.hxx:761
vigra::TinyVectorBase::init
void init(Iterator i, Iterator end)
Definition: tinyvector.hxx:708
vigra::abs
TinyVector< V, SIZE > abs(TinyVectorBase< V, SIZE, D1, D2 > const &v)
component-wise absolute value
Definition: tinyvector.hxx:1956
vigra::TinyVectorBase::SquaredNormType
NormTraits< VALUETYPE >::SquaredNormType SquaredNormType
Definition: tinyvector.hxx:695
vigra::TinyVectorBase::operator*=
DERIVED & operator*=(TinyVectorBase< T1, SIZE, D1, D2 > const &r)
Definition: tinyvector.hxx:743
vigra::TinyVector::operator=
TinyVector & operator=(Diff2D const &r)
Definition: tinyvector.hxx:1190
vigra::TinyVectorBase::operator[]
reference operator[](difference_type i)
Definition: tinyvector.hxx:845
vigra::sqrt
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root.
Definition: fixedpoint.hxx:616
vigra::operator%
PromoteTraits< TinyVector< V1, SIZE >, TinyVector< V2, SIZE > >::Promote operator%(TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
component-wise modulo
Definition: tinyvector.hxx:1848
vigra::TinyVector::TinyVector
TinyVector(lemon::Invalid const &)
Definition: tinyvector.hxx:1041
vigra::min
V const & min(TinyVectorBase< V, SIZE, D1, D2 > const &l)
minimum element
Definition: tinyvector.hxx:2161
vigra::dot
PromoteTraits< V1, V2 >::Promote dot(TinyVectorBase< V1, SIZE, D1, D2 > const &l, TinyVectorBase< V2, SIZE, D3, D4 > const &r)
dot product
Definition: tinyvector.hxx:2062

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python vigra 1.11.1 (Fri May 19 2017)