BALL 1.5.0
vector2.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_VECTOR2_H
6#define BALL_MATHS_VECTOR2_H
7
8#ifndef BALL_CONCEPT_PERSISTENCEMANAGER_H
10#endif
11
12#ifndef BALL_COMMON_EXCEPTION_H
14#endif
15
16#ifndef BALL_MATHS_COMMON_H
17# include <BALL/MATHS/common.h>
18#endif
19
20
21namespace BALL
22{
23
31
32 template <typename T>
33 class TVector2;
34
38
42 template <typename T>
44 TVector2<T> operator * (const T& scalar, const TVector2<T>& vector);
45
48 template <typename T>
49 std::istream& operator >> (std::istream& s, TVector2<T>& vector);
50
51 /* Output stream.
52 */
53 template <typename T>
54 std::ostream& operator << (std::ostream& s, const TVector2<T>& vector);
55
57
60 template <typename T>
62 : public PersistentObject
63 {
64 public:
65
67
68
71
72
77
83 explicit TVector2(const T& value);
84
90 TVector2(const T& vx, const T& vy);
91
96 TVector2(const TVector2& vector);
97
104 TVector2(const T* ptr);
105
106
111 virtual ~TVector2();
112
116 virtual void clear();
117
119
123
129 const char* name = 0) const;
130
137
139
143
148 void set(const T& value);
149
154 void set(const T& vx, const T& vy);
155
159 void set(const TVector2& vector);
160
165 TVector2& operator = (const TVector2& v);
166
171 TVector2& operator = (const T& value);
172
178 TVector2& operator = (const T* ptr);
179
185 T getLength() const;
186
193
201
207
210 static const TVector2& getZero();
211
215 static const TVector2& getUnit();
216
220 T& operator [] (Position position);
221
225 const T& operator [] (Position position) const;
226
228
231
234 const TVector2& operator + () const;
235
238 TVector2 operator - () const;
239
242 TVector2 operator + (const TVector2& b) const;
243
246 TVector2 operator - (const TVector2& b) const;
247
253 TVector2& operator += (const TVector2& vector);
254
259 TVector2& operator -= (const TVector2& vector);
260
267 TVector2 operator * (const T& scalar) const;
268
274 TVector2& operator *= (const T& scalar);
275
282 TVector2 operator / (const T& lambda) const;
283
289 TVector2& operator /= (const T& lambda);
290
294 T operator * (const TVector2& vector) const;
295
297
301
304 T getDistance(const TVector2& vector) const;
305
308 T getSquareDistance(const TVector2& vector) const;
309
311
315
321 bool operator == (const TVector2& vector) const;
322
328 bool operator != (const TVector2& vector) const;
329
334 bool isZero() const;
335
338 bool isOrthogonalTo(TVector2& vector) const;
339
341
342
346
353 void dump(std::ostream& s = std::cout, Size depth = 0) const;
354
359 bool isValid() const;
360
362
363
369
372 T x;
373
376 T y;
377
379
380 private:
381
382 };
384
385 template <typename T>
388 x(0),
389 y(0)
390 {
391 }
392
393 template <typename T>
394 TVector2<T>::TVector2(const T& value)
395 : PersistentObject(),
396 x(value),
397 y(value)
398 {
399 }
400
401 template <typename T>
402 TVector2<T>::TVector2(const T& vx, const T& vy)
404 x(vx),
405 y(vy)
406 {
407 }
408
409 template <typename T>
412 x(vector.x),
413 y(vector.y)
414 {
415 }
416
417 template <typename T>
419 {
420 }
421
422 template <typename T>
425 {
426 if (ptr == 0)
427 {
428 throw Exception::NullPointer(__FILE__, __LINE__);
429 }
430
431 x = *ptr++;
432 y = *ptr;
433 }
434
435 template <typename T>
437 {
438 x = y = (T)0;
439 }
440
441 template <typename T>
442 void TVector2<T>::persistentWrite(PersistenceManager& pm, const char* name) const
443 {
444 pm.writeObjectHeader(this, name);
445 pm.writePrimitive(x, "x");
446 pm.writePrimitive(y, "y");
447 pm.writeObjectTrailer(name);
448 }
449
450 template <typename T>
452 {
453 pm.readPrimitive(x, "x");
454 pm.readPrimitive(y, "y");
455 }
456
457 template <typename T>
459 void TVector2<T>::set(const T& value)
460 {
461 x = value;
462 y = value;
463 }
464
465 template <typename T>
467 void TVector2<T>::set(const T& vx, const T& vy)
468 {
469 x = vx;
470 y = vy;
471 }
472
473 template <typename T>
475 void TVector2<T>::set(const TVector2<T>& vector)
476 {
477 x = vector.x;
478 y = vector.y;
479 }
480
481 template <typename T>
484 {
485 x = vector.x;
486 y = vector.y;
487
488 return *this;
489 }
490
491 template <typename T>
494 {
495 if (ptr == 0)
496 {
497 throw Exception::NullPointer(__FILE__, __LINE__);
498 }
499 x = *ptr++;;
500 y = *ptr;;
501
502 return *this;
503 }
504
505 template <typename T>
508 {
509 x = value;
510 y = value;
511
512 return *this;
513 }
514
515 template <typename T>
518 {
519 return (T)sqrt(x * x + y * y);
520 }
521
522 template <typename T>
525 {
526 return (T)(x * x + y * y);
527 }
528
529 template <typename T>
531 {
532 T len = (T)sqrt(x * x + y * y);
533
534 if (Maths::isZero(len))
535 {
536 throw Exception::DivisionByZero(__FILE__, __LINE__);
537 }
538
539 x /= len;
540 y /= len;
541
542 return *this;
543 }
544
545 template <typename T>
547 {
548 x *= -1;
549 y *= -1;
550 return *this;
551 }
552
553 template <typename T>
556 {
557 static TVector2<T> null_vector(0, 0);
558 return null_vector;
559 }
560
561 template <typename T>
564 {
565 static TVector2<T> unit_vector(1, 1);
566 return unit_vector;
567 }
568
569 template <typename T>
572 {
573 if (position > 1)
574 {
575 throw Exception::IndexOverflow(__FILE__, __LINE__);
576 }
577 switch (position)
578 {
579 case 0: return x;
580 case 1:
581 default:
582 return y;
583 }
584 }
585
586 template <typename T>
588 const T& TVector2<T>::operator [] (Position position) const
589 {
590 if (position > 1)
591 {
592 throw Exception::IndexOverflow(__FILE__, __LINE__);
593 }
594 switch (position)
595 {
596 case 0: return x;
597 case 1:
598 default:
599 return y;
600 }
601 }
602
603 template <typename T>
606 {
607 return *this;
608 }
609
610 template <typename T>
613 {
614 return TVector2<T>(-x, -y);
615 }
616
617 template <typename T>
620 {
621 return TVector2<T>(x + b.x, y + b.y);
622 }
623
624 template <typename T>
627 {
628 return TVector2<T>(x - b.x, y - b.y);
629 }
630
631 template <typename T>
634 {
635 x += vector.x;
636 y += vector.y;
637
638 return *this;
639 }
640
641 template <typename T>
644 {
645 x -= vector.x;
646 y -= vector.y;
647
648 return *this;
649 }
650
651 template <typename T>
653 TVector2<T> TVector2<T>::operator * (const T& scalar) const
654 {
655 return TVector2<T>(x * scalar, y * scalar);
656 }
657
658 template <typename T>
661 {
662 x *= scalar;
663 y *= scalar;
664
665 return *this;
666 }
667
668 template <typename T>
670 {
671 if (lambda == (T)0)
672 {
673 throw Exception::DivisionByZero(__FILE__, __LINE__);
674 }
675 return TVector2<T>(x / lambda, y / lambda);
676 }
677
678 template <typename T>
680 {
681 if (lambda == (T)0)
682 {
683 throw Exception::DivisionByZero(__FILE__, __LINE__);
684 }
685 x /= lambda;
686 y /= lambda;
687
688 return *this;
689 }
690
691 template <typename T>
694 {
695 return (x * vector.x + y * vector.y);
696 }
697
698 template <typename T>
701 {
702 T dx = x - v.x;
703 T dy = y - v.y;
704
705 return (T)sqrt(dx * dx + dy * dy);
706 }
707
708 template <typename T>
711 {
712 T dx = x - v.x;
713 T dy = y - v.y;
714
715 return (dx * dx + dy * dy);
716 }
717
718 template <typename T>
721 {
722 return (Maths::isEqual(x, v.x) && Maths::isEqual(y, v.y));
723 }
724
725 template <typename T>
728 {
729 return (Maths::isNotEqual(x, v.x) || Maths::isNotEqual(y, v.y));
730 }
731
732 template <typename T>
735 {
736 return Maths::isZero((*this) * v);
737 }
738
739 template <typename T>
742 {
743 return true;
744 }
745
746 template <typename T>
749 {
750 return (Maths::isZero(x) && Maths::isZero(y));
751 }
752
753 template <typename T>
754 void TVector2<T>::dump(std::ostream& s, Size depth) const
755 {
757
758 BALL_DUMP_HEADER(s, this, this);
759
760 BALL_DUMP_DEPTH(s, depth);
761 s << " (x = " << x << ", y = " << y << ")" << std::endl;
762
764 }
765
772
773 template <typename T>
775 TVector2<T> operator * (const T& scalar, const TVector2<T>& vector)
776 {
777 return TVector2<T>(scalar * vector.x, scalar * vector.y);
778 }
779
780 template <typename T>
781 std::istream& operator >> (std::istream& s, TVector2<T>& v)
782 {
783 char c;
784 s >> c >> v.x >> v.y >> c;
785
786 return s;
787 }
788
789 template <typename T>
790 std::ostream& operator << (std::ostream& s, const TVector2<T>& v)
791 {
792 s << "(" << v.x << ' ' << v.y << ')';
793
794 return s;
795 }
796
797}// namespace BALL
798
799#endif // BALL_MATHS_VECTOR2_H
#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_INLINE
Definition: debug.h:15
#define BALL_CREATE(name)
Definition: create.h:62
BALL_EXPORT std::ostream & operator<<(std::ostream &os, const Exception::GeneralException &e)
TVector2< float > Vector2
Definition: vector2.h:771
STL namespace.
Definition: constants.h:13
BALL_INLINE TAngle< T > operator*(const T &val, const TAngle< T > &angle)
Definition: angle.h:704
std::istream & operator>>(std::istream &is, TRegularData1D< ValueType > &grid)
Input operator.
BALL_EXTERN_VARIABLE const double c
Definition: constants.h:149
bool isNotEqual(const T1 &a, const T2 &b)
Definition: MATHS/common.h:224
bool isZero(const T &t)
Definition: MATHS/common.h:189
bool isEqual(const T1 &a, const T2 &b)
Definition: MATHS/common.h:212
void writeObjectHeader(const T *object, const char *name=0)
void writeObjectTrailer(const char *name=0)
bool readPrimitive(T &t, const char *name)
void writePrimitive(const T &t, const char *name)
void dump(std::ostream &s=std::cout, Size depth=0) const
Definition: vector2.h:754
virtual void persistentRead(PersistenceManager &pm)
Definition: vector2.h:451
void set(const T &value)
Definition: vector2.h:459
virtual ~TVector2()
Definition: vector2.h:418
bool operator==(const TVector2 &vector) const
Definition: vector2.h:720
T getDistance(const TVector2 &vector) const
Definition: vector2.h:700
T getLength() const
Definition: vector2.h:517
TVector2 & operator=(const TVector2 &v)
Definition: vector2.h:483
static const TVector2 & getUnit()
Definition: vector2.h:563
bool operator!=(const TVector2 &vector) const
Definition: vector2.h:727
T & operator[](Position position)
Definition: vector2.h:571
TVector2 operator/(const T &lambda) const
Definition: vector2.h:669
bool isValid() const
Definition: vector2.h:741
TVector2 & operator*=(const T &scalar)
Definition: vector2.h:660
bool isZero() const
Definition: vector2.h:748
const TVector2 & operator+() const
Definition: vector2.h:605
virtual void persistentWrite(PersistenceManager &pm, const char *name=0) const
Definition: vector2.h:442
TVector2 & operator+=(const TVector2 &vector)
Definition: vector2.h:633
bool isOrthogonalTo(TVector2 &vector) const
Definition: vector2.h:734
TVector2 & normalize()
Definition: vector2.h:530
TVector2 & negate()
Definition: vector2.h:546
TVector2 operator*(const T &scalar) const
Definition: vector2.h:653
TVector2 & operator-=(const TVector2 &vector)
Definition: vector2.h:643
T getSquareLength() const
Definition: vector2.h:524
T getSquareDistance(const TVector2 &vector) const
Definition: vector2.h:710
TVector2 & operator/=(const T &lambda)
Definition: vector2.h:679
static const TVector2 & getZero()
Definition: vector2.h:555
TVector2 operator-() const
Definition: vector2.h:612
virtual void clear()
Definition: vector2.h:436