BALL 1.5.0
Loading...
Searching...
No Matches
vector4.h
Go to the documentation of this file.
1// -*- Mode: C++; tab-width: 2; -*-
2// vi: set ts=2:
3//
4
5#ifndef BALL_MATHS_VECTOR4_H
6#define BALL_MATHS_VECTOR4_H
7
8#ifndef BALL_COMMON_EXCEPTION_H
10#endif
11
12#ifndef BALL_MATHS_ANGLE_H
13# include <BALL/MATHS/angle.h>
14#endif
15
16#ifdef BALL_HAS_IEEEFP_H
17# include <ieeefp.h>
18#endif
19
20namespace BALL
21{
26
27 template <typename T>
28 class TVector4;
29
33
34 template <typename T>
36 TVector4<T> operator + (const TVector4<T>& a, const TVector4<T>& b);
37
38 template <typename T>
40 TVector4<T> operator - (const TVector4<T>& a, const TVector4<T>& b);
41
42 template <typename T>
43 std::istream& operator >> (std::istream& s, TVector4<T>& vector);
44
45 template <typename T>
46 std::ostream& operator << (std::ostream& s, const TVector4<T>& vector);
47
51 template <typename T>
53 {
54 public:
55
57
58
61
62
66 TVector4();
67
74 TVector4(const T* ptr);
75
81 explicit TVector4(const T& value);
82
90 TVector4(const T& x, const T& y, const T& z, const T& h = (T)1);
91
96 TVector4(const TVector4& vector);
97
102 virtual ~TVector4();
103
107 virtual void clear()
108 {
109 x = y = z = h = (T)0;
110 }
111
113
116
123 void set(const T* ptr);
124
131 void set(const T& rx, const T& ry, const T& rz, const T& rh = (T)1);
132
136 void set(const TVector4& vector);
137
143 TVector4& operator = (const T* ptr);
144
149 TVector4& operator = (const TVector4& vector);
150
155 TVector4& operator = (T value);
156
163 void get(T* ptr) const;
164
171 void get(T& rx, T& ry, T& rz, T& rh) const;
172
177 void get(TVector4& vector) const;
178
182 void swap(TVector4& vector);
183
185
188
194 T getLength() const;
195
201 T getSquareLength() const;
202
210
213 static const TVector4& getZero();
214
217 static const TVector4& getUnit();
218
222 void set(const T& value = (T)1);
223
227 T& operator [] (Position position);
228
232 const T& operator [] (Position position) const;
233
235
238
241 TVector4 operator + () const;
242
245 TVector4 operator - () const;
246
251 TVector4& operator += (const TVector4& vector);
252
257 TVector4& operator -= (const TVector4& vector);
258
264 TVector4 operator * (const T& scalar);
265
271 TVector4& operator *= (const T& scalar);
272
279 TVector4 operator / (const T& scalar);
280
286 TVector4& operator /= (const T& scalar);
287
292 T operator * (const TVector4& vector) const;
293
298 T getDistance(const TVector4& vector) const;
299
306 T getSquareDistance(const TVector4& vector) const;
307
309
312
318 bool operator == (const TVector4& vector) const;
319
325 bool operator != (const TVector4& vector) const;
326
329 bool isOrthogonalTo(const TVector4& vector) const;
330
332
335
340 bool isValid() const;
341
348 void dump(std::ostream& s = std::cout, Size depth = 0) const;
349
351
355
358 T x;
359
362 T y;
363
366 T z;
367
370 T h;
371
373 };
375
376 template <typename T>
378 : x(0),
379 y(0),
380 z(0),
381 h(0)
382 {
383 }
384
385 template <typename T>
387 {
388 if (ptr == 0)
389 {
390 throw Exception::NullPointer(__FILE__, __LINE__);
391 }
392
393 x = *ptr++;
394 y = *ptr++;
395 z = *ptr++;
396 h = *ptr;
397 }
398
399
400 template <typename T>
401 TVector4<T>::TVector4(const T& value)
402 : x(value),
403 y(value),
404 z(value),
405 h(value)
406 {
407 }
408
409 template <typename T>
410 TVector4<T>::TVector4(const T& x, const T& y, const T& z, const T& h)
411 : x(x),
412 y(y),
413 z(z),
414 h(h)
415 {
416 }
417
418 template <typename T>
420 : x(v.x),
421 y(v.y),
422 z(v.z),
423 h(v.h)
424 {
425 }
426
427 template <typename T>
431
432 template <typename T>
434 void TVector4<T>::set(const T* ptr)
435 {
436 if (ptr == 0)
437 {
438 throw Exception::NullPointer(__FILE__, __LINE__);
439 }
440 x = *ptr++;
441 y = *ptr++;
442 z = *ptr++;
443 h = *ptr;
444 }
445
446 template <typename T>
448 void TVector4<T>::set(const T& rx, const T& ry, const T& rz, const T& rh)
449 {
450 x = rx;
451 y = ry;
452 z = rz;
453 h = rh;
454 }
455
456 template <typename T>
459 {
460 x = v.x;
461 y = v.y;
462 z = v.z;
463 h = v.h;
464 }
465
466 template <typename T>
469 {
470 if (ptr == 0)
471 {
472 throw Exception::NullPointer(__FILE__, __LINE__);
473 }
474 x = *ptr++;
475 y = *ptr++;
476 z = *ptr++;
477 h = *ptr;
478
479 return *this;
480 }
481
482 template <typename T>
485 {
486 x = v.x;
487 y = v.y;
488 z = v.z;
489 h = v.h;
490
491 return *this;
492 }
493
494 template <typename T>
497 {
498 x = value;
499 y = value;
500 z = value;
501 h = value;
502
503 return *this;
504 }
505
506 template <typename T>
508 void TVector4<T>::get(T* ptr) const
509 {
510 if (ptr == 0)
511 {
512 throw Exception::NullPointer(__FILE__, __LINE__);
513 }
514 *ptr++ = x;
515 *ptr++ = y;
516 *ptr++ = z;
517 *ptr = h;
518 }
519
520 template <typename T>
522 void TVector4<T>::get(T& rx, T& ry, T& rz, T& rh) const
523 {
524 rx = x;
525 ry = y;
526 rz = z;
527 rh = h;
528 }
529
530 template <typename T>
533 {
534 v.x = x;
535 v.y = y;
536 v.z = z;
537 v.h = h;
538 }
539
540 template <typename T>
542 {
543 T temp = x;
544 x = v.x;
545 v.x = temp;
546
547 temp = y;
548 y = v.y;
549 v.y = temp;
550
551 temp = z;
552 z = v.z;
553 v.z = temp;
554
555 temp = h;
556 h = v.h;
557 v.h = temp;
558 }
559
560 template <typename T>
563 {
564 return (T)sqrt(x * x + y * y + z * z + h * h);
565 }
566
567 template <typename T>
570 {
571 return (T)(x * x + y * y + z * z + h * h);
572 }
573
574 template <typename T>
577 {
578 T len = (T)sqrt(x * x + y * y + z * z + h * h);
579
580 if (Maths::isZero(len))
581 {
582 throw Exception::DivisionByZero(__FILE__, __LINE__);
583 }
584
585 x /= len;
586 y /= len;
587 z /= len;
588 h /= len;
589
590 return *this;
591 }
592
593 template <typename T>
596 {
597 static const TVector4<T> null4(0, 0, 0, 0);
598 return null4;
599 }
600
601 template <typename T>
604 {
605 static const TVector4<T> unit_vector(1, 1, 1, 1);
606 return unit_vector;
607 }
608
609 template <typename T>
611 void TVector4<T>::set(const T& value)
612 {
613 x = y = z = h = value;
614 }
615
616 template <typename T>
619 {
620 if (pos > 3)
621 {
622 throw Exception::IndexOverflow(__FILE__, __LINE__);
623 }
624 switch (pos)
625 {
626 case 0: return x;
627 case 1: return y;
628 case 2: return z;
629 case 3:
630 default:
631 return h;
632 }
633 }
634
635 template <typename T>
638 {
639 if (pos > 3)
640 {
641 throw Exception::IndexOverflow(__FILE__, __LINE__);
642 }
643 switch (pos)
644 {
645 case 0: return x;
646 case 1: return y;
647 case 2: return z;
648 case 3:
649 default:
650 return h;
651 }
652 }
653
654 template <typename T>
657 {
658 return *this;
659 }
660
661 template <typename T>
664 {
665 return TVector4<T>(-x, -y, -z, -h);
666 }
667
668 template <typename T>
671 {
672 x += v.x;
673 y += v.y;
674 z += v.z;
675 h += v.h;
676
677 return *this;
678 }
679
680 template <typename T>
683 {
684 x -= v.x;
685 y -= v.y;
686 z -= v.z;
687 h -= v.h;
688
689 return *this;
690 }
691
692 template <typename T>
695 {
696 return TVector4<T>(x * scalar, y * scalar, z * scalar, h * scalar);
697 }
698
699 template <typename T>
702 {
703 x *= scalar;
704 y *= scalar;
705 z *= scalar;
706 h *= scalar;
707
708 return *this;
709 }
710
711 template <typename T>
713 {
714 if (Maths::isZero(scalar))
715 {
716 throw Exception::DivisionByZero(__FILE__, __LINE__);
717 }
718 return TVector4<T>(x / scalar, y / scalar, z / scalar, h / scalar);
719 }
720
721 template <typename T>
723 {
724 if (Maths::isZero(scalar))
725 {
726 throw Exception::DivisionByZero(__FILE__, __LINE__);
727 }
728 x /= scalar;
729 y /= scalar;
730 z /= scalar;
731 h /= scalar;
732
733 return *this;
734 }
735
736 template <typename T>
739 {
740 return (x * v.x + y * v.y + z * v.z + h * v.h);
741 }
742
743 template <typename T>
746 {
747 T da = x - v.x;
748 T db = y - v.y;
749 T dc = z - v.z;
750 T dd = h - v.h;
751
752 return (T)sqrt(da * da + db * db + dc * dc + dd * dd);
753 }
754
755 template <typename T>
758 {
759 T da = x - v.x;
760 T db = y - v.y;
761 T dc = z - v.z;
762 T dd = h - v.h;
763
764 return (da * da + db * db + dc * dc + dd * dd);
765 }
766
767 template <typename T>
770 {
771 return (Maths::isEqual(x, v.x) && Maths::isEqual(y, v.y)
772 && Maths::isEqual(z, v.z) && Maths::isEqual(h, v.h));
773 }
774
775 template <typename T>
778 {
779 return (Maths::isNotEqual(x, v.x) || Maths::isNotEqual(y, v.y)
780 || Maths::isNotEqual(z, v.z) || Maths::isNotEqual(h, v.h));
781 }
782
783 template <typename T>
786 {
787 return Maths::isZero(*this * v);
788 }
789
790 template <typename T>
793 {
794 return true;
795 }
796
797 template <typename T>
798 void TVector4<T>::dump(std::ostream& s, Size depth) const
799 {
801
802 BALL_DUMP_HEADER(s, this, this);
803
804 BALL_DUMP_DEPTH(s, depth);
805 s << "x= " << x
806 << ", y = " << y
807 << ", z = " << z
808 << ", h = " << h << std::endl;
809
811 }
812
816
819 template <typename T>
822 {
823 return TVector4<T>(a.x + b.x, a.y + b.y, a.z + b.z, a.h + b.h);
824 }
825
829 template <typename T>
832 {
833 return TVector4<T>(a.x - b.x, a.y - b.y, a.z - b.z, a.h - b.h);
834 }
835
839 template <typename T>
841 TVector4<T> operator * (const T& scalar, const TVector4<T>& v)
842 {
843 return TVector4<T>(scalar * v.x, scalar * v.y, scalar * v.z, scalar * v.h);
844 }
845
849 template <typename T>
851 TVector4<T> operator * (const TVector4<T>& v, const T& scalar)
852 {
853 return TVector4<T>(scalar * v.x, scalar * v.y, scalar * v.z, scalar * v.h);
854 }
855
860 template <typename T>
861 std::istream& operator >> (std::istream& s, TVector4<T>& v)
862 {
863 char c;
864 s >> c >> v.x >> v.y >> v.z >> v.h >>c;
865 return s;
866 }
867
874 template <typename T>
875 std::ostream& operator << (std::ostream& s, const TVector4<T>& v)
876 {
877 s << '(' <<v.x << ' ' << v.y << ' ' << v.z << ' ' << v.h << ')';
878
879 return s;
880 }
881} // namespace BALL
882
883#endif // BALL_MATHS_VECTOR4_H
#define BALL_INLINE
Definition debug.h:15
#define BALL_DUMP_STREAM_PREFIX(os)
Definition macros.h:391
#define BALL_DUMP_STREAM_SUFFIX(os)
Definition macros.h:395
#define BALL_DUMP_DEPTH(os, depth)
Definition macros.h:390
#define BALL_DUMP_HEADER(os, cl, ob)
Definition macros.h:393
#define BALL_CREATE(name)
Definition create.h:62
BALL_EXPORT std::ostream & operator<<(std::ostream &os, const Exception::GeneralException &e)
TVector4< float > Vector4
Definition vector4.h:815
BALL_INLINE TAngle< T > operator*(const T &val, const TAngle< T > &angle)
Definition angle.h:704
ConstRandomAccessIterator< Container, DataType, Position, Traits > operator+(Distance distance, const ConstRandomAccessIterator< Container, DataType, Position, Traits > &iterator)
std::istream & operator>>(std::istream &is, TRegularData1D< ValueType > &grid)
Input operator.
BALL_INLINE TAngle< T > operator-(const T &val, const TAngle< T > &angle)
Definition angle.h:724
bool isNotEqual(const T1 &a, const T2 &b)
bool isZero(const T &t)
bool isEqual(const T1 &a, const T2 &b)
T getLength() const
Definition vector4.h:562
virtual void clear()
Definition vector4.h:107
TVector4 & operator/=(const T &scalar)
Definition vector4.h:722
T getSquareDistance(const TVector4 &vector) const
Definition vector4.h:757
TVector4 & normalize()
Definition vector4.h:576
void get(T *ptr) const
Definition vector4.h:508
void set(const T *ptr)
Definition vector4.h:434
TVector4 operator/(const T &scalar)
Definition vector4.h:712
static const TVector4 & getUnit()
Definition vector4.h:603
TVector4 & operator-=(const TVector4 &vector)
Definition vector4.h:682
T & operator[](Position position)
Definition vector4.h:618
TVector4 & operator=(const T *ptr)
Definition vector4.h:468
T getSquareLength() const
Definition vector4.h:569
T getDistance(const TVector4 &vector) const
Definition vector4.h:745
bool operator!=(const TVector4 &vector) const
Definition vector4.h:777
bool isOrthogonalTo(const TVector4 &vector) const
Definition vector4.h:785
TVector4 operator*(const T &scalar)
Definition vector4.h:694
TVector4 operator+() const
Definition vector4.h:656
virtual ~TVector4()
Definition vector4.h:428
static const TVector4 & getZero()
Definition vector4.h:595
bool operator==(const TVector4 &vector) const
Definition vector4.h:769
TVector4 & operator+=(const TVector4 &vector)
Definition vector4.h:670
void dump(std::ostream &s=std::cout, Size depth=0) const
Definition vector4.h:798
TVector4 operator-() const
Definition vector4.h:663
void swap(TVector4 &vector)
Definition vector4.h:541
TVector4 & operator*=(const T &scalar)
Definition vector4.h:701
bool isValid() const
Definition vector4.h:792