maths/Vector.h

   1 /***************************************************************************
   2  *   This file is part of Tecorrec.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   Tecorrec is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   Tecorrec is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with Tecorrec.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 /**
  21  * @file Vector.h
  22  * @brief Vector of values, designed for spacial coordinate vectors.
  23  * @author James Hogan <james@albanarts.com>
  24  * @note Copyright (C) 2007
  25  *
  26  * @version 1 : From Computer Graphics and Visualisation Open Assessment.
  27  */
  28
  29 #ifndef _maths_Vector_h
  30 #define _maths_Vector_h
  31
  32 #include "TemplateMaths.h"
  33
  34 #include <ostream>
  35 #include <sstream>
  36
  37 namespace maths
  38 {
  39
  40   /// Vector.
  41   /**
  42    * @param N int Number of components in the vector.
  43    * @param T typename Type of the components of the vector.
  44    */
  45   template <int N, typename T>
  46   class Vector
  47   {
  48     public:
  49       T v[N];
  50
  51       enum {
  52         length = N
  53       };
  54       typedef T Scalar;
  55
  56       /// Default constructor (Does not initialise the values!)
  57       inline Vector()
  58       {
  59       }
  60
  61       inline explicit Vector(T value)
  62       {
  63         for (int i = 0; i < N; ++i)
  64         {
  65           v[i] = value;
  66         }
  67       }
  68       inline Vector(T x, T y)
  69       {
  70         v[0] = x;
  71         v[1] = y;
  72         if (N > 2)
  73         {
  74           for (int i = 2; i < N; ++i)
  75           {
  76             v[i] = maths::zero<T>();
  77           }
  78         }
  79       }
  80       inline Vector(T x, T y, T z)
  81       {
  82         v[0] = x;
  83         v[1] = y;
  84         if (N > 2)
  85         {
  86           v[2] = z;
  87           if (N > 3)
  88           {
  89             for (int i = 3; i < N; ++i)
  90             {
  91               v[i] = maths::zero<T>();
  92             }
  93           }
  94         }
  95       }
  96       inline Vector(T x, T y, T z, T w)
  97       {
  98         v[0] = x;
  99         v[1] = y;
 100         if (N > 2)
 101         {
 102           v[2] = z;
 103           if (N > 3)
 104           {
 105             v[3] = w;
 106             if (N > 4)
 107             {
 108               for (int i = 4; i < N; ++i)
 109               {
 110                 v[i] = maths::zero<T>();
 111               }
 112             }
 113           }
 114         }
 115       }
 116       inline explicit Vector(const T * vec)
 117       {
 118         for (int i = 0; i < N; ++i)
 119         {
 120           v[i] = vec[i];
 121         }
 122       }
 123       template <int M, typename U> inline explicit Vector(const Vector<M,U> & copy)
 124       {
 125         int i = 0;
 126         for (; i < N && i < M; ++i)
 127         {
 128           v[i] = (T)copy.v[i];
 129         }
 130         for (; i < N; ++i)
 131         {
 132           v[i] = maths::zero<T>();
 133         }
 134       }
 135
 136       inline const Vector & set()
 137       {
 138         for (int i = 0; i < N; ++i)
 139         {
 140           v[i] = maths::zero<T>();
 141         }
 142         return *this;
 143       }
 144       inline const Vector & set(T all)
 145       {
 146         for (int i = 0; i < N; ++i)
 147         {
 148           v[i] = all;
 149         }
 150         return *this;
 151       }
 152       inline const Vector & set(T x, T y)
 153       {
 154         v[0] = x;
 155         v[1] = y;
 156         if (N > 2)
 157         {
 158           for (int i = 2; i < N; ++i)
 159           {
 160             v[i] = maths::zero<T>();
 161           }
 162         }
 163         return *this;
 164       }
 165       inline const Vector & set(T x, T y, T z)
 166       {
 167         v[0] = x;
 168         v[1] = y;
 169         if (N > 2)
 170         {
 171           v[2] = z;
 172           if (N > 3)
 173           {
 174             for (int i = 3; i < N; ++i)
 175             {
 176               v[i] = maths::zero<T>();
 177             }
 178           }
 179         }
 180         return *this;
 181       }
 182       inline const Vector & set(T x, T y, T z, T w)
 183       {
 184         v[0] = x;
 185         v[1] = y;
 186         if (N > 2)
 187         {
 188           v[2] = z;
 189           if (N > 3)
 190           {
 191             v[3] = w;
 192             if (N > 4)
 193             {
 194               for (int i = 4; i < N; ++i)
 195               {
 196                 v[i] = maths::zero<T>();
 197               }
 198             }
 199           }
 200         }
 201         return *this;
 202       }
 203       inline const Vector & set(const Vector<3,T> xyz, T w)
 204       {
 205         v[0] = xyz[0];
 206         v[1] = xyz[1];
 207         if (N > 2)
 208         {
 209           v[2] = xyz[2];
 210           if (N > 3)
 211           {
 212             v[3] = w;
 213             if (N > 4)
 214             {
 215               for (int i = 4; i < N; ++i)
 216               {
 217                 v[i] = maths::zero<T>();
 218               }
 219             }
 220           }
 221         }
 222         return *this;
 223       }
 224
 225       /// Setter for specific component.
 226       template <int X>
 227       inline void setComponent(const T newValue)
 228       {
 229         v[X] = newValue;
 230       }
 231
 232       /// Getter for specific component.
 233       template <int X>
 234       inline T getComponent() const
 235       {
 236         return v[X];
 237       }
 238
 239       /// Concatination operator, append a number.
 240       inline Vector<N+1, T> operator , (T f) const
 241       {
 242         Vector<N+1,T> result;
 243         for (int i = 0; i < N; ++i)
 244         {
 245           result[i] = v[i];
 246         }
 247         result[N] = f;
 248         return result;
 249       }
 250
 251       /// Concatination operator, prepend a number.
 252       inline friend Vector<N+1, T> operator , (T f, const Vector & vector)
 253       {
 254         Vector<N+1,T> result;
 255         result[0] = f;
 256         for (int i = 0; i < N; ++i)
 257         {
 258           result[i+1] = vector[i];
 259         }
 260         return result;
 261       }
 262
 263       /// Concatination operator, append a vector.
 264       template <int M>
 265       inline Vector<N+M, T> operator , (const Vector<M,T> & vector) const
 266       {
 267         Vector<N+M,T> result;
 268         for (int i = 0; i < N; ++i)
 269         {
 270           result[i] = v[i];
 271         }
 272         for (int i = 0; i < M; ++i)
 273         {
 274           result[N+i] = vector[i];
 275         }
 276         return result;
 277       }
 278
 279       /// Slice out of the vector a reference.
 280       template <int S, int L>
 281       inline Vector<L, T> & slice()
 282       {
 283         return *(Vector<L,T>*)(v+S);
 284       }
 285
 286       /// Slice out of the vector a reference.
 287       template <int S, int L>
 288       inline const Vector<L, T> & slice() const
 289       {
 290         return *(Vector<L,T>*)(v+S);
 291       }
 292
 293       inline T & operator [] (int index)
 294       {
 295         return v[index];
 296       }
 297       inline const T & operator [] (int index) const
 298       {
 299         return v[index];
 300       }
 301
 302       inline operator T * ()
 303       {
 304         return v;
 305       }
 306       inline operator const T * () const
 307       {
 308         return v;
 309       }
 310
 311       inline Vector operator - () const
 312       {
 313         Vector ret;
 314         for (int i = 0; i < N; ++i)
 315         {
 316           ret[i] = -v[i];
 317         }
 318         return ret;
 319       }
 320
 321       template <typename U>
 322       inline Vector & operator += (const Vector<N,U> & rhs)
 323       {
 324         for (int i = 0; i < N; ++i)
 325         {
 326           v[i] += rhs.v[i];
 327         }
 328         return *this;
 329       }
 330       template <typename U>
 331       inline Vector operator + (const Vector<N,U> & rhs) const
 332       {
 333         Vector ret = *this;
 334         return ret += rhs;
 335       }
 336
 337       inline Vector & operator -= (const Vector & rhs)
 338       {
 339         for (int i = 0; i < N; ++i)
 340         {
 341           v[i] -= rhs.v[i];
 342         }
 343         return *this;
 344       }
 345       inline Vector operator - (const Vector & rhs) const
 346       {
 347         Vector ret = *this;
 348         return ret -= rhs;
 349       }
 350
 351       inline Vector & operator *= (const T rhs)
 352       {
 353         for (int i = 0; i < N; ++i)
 354         {
 355           v[i] *= rhs;
 356         }
 357         return *this;
 358       }
 359       inline Vector operator * (const T rhs) const
 360       {
 361         Vector ret = *this;
 362         return ret *= rhs;
 363       }
 364       inline friend Vector operator * (const T lhs, const Vector & rhs)
 365       {
 366         return rhs * lhs;
 367       }
 368
 369       /// Dot product
 370       inline T operator * (const Vector & rhs) const
 371       {
 372         T fDot = maths::zero<T>();
 373         for (int i = 0; i < N; ++i)
 374         {
 375           fDot += v[i]*rhs.v[i];
 376         }
 377         return fDot;
 378       }
 379
 380       /// Dot quotient
 381       inline T operator / (const Vector & rhs) const
 382       {
 383         // a = B/C = (B*C)/(C*C)
 384         return operator * (rhs) / rhs.sqr();
 385       }
 386
 387       inline Vector & operator /= (const T rhs)
 388       {
 389         for (int i = 0; i < N; ++i)
 390         {
 391           v[i] /= rhs;
 392         }
 393         return *this;
 394       }
 395       inline Vector operator / (const T rhs) const
 396       {
 397         Vector ret = *this;
 398         return ret /= rhs;
 399       }
 400       inline friend Vector operator / (const T lhs, const Vector & rhs)
 401       {
 402         return rhs * (lhs / rhs.sqr());
 403       }
 404
 405       inline T sqr() const
 406       {
 407         return tsqr<T>();
 408       }
 409       template <typename U>
 410       inline U tsqr() const
 411       {
 412         U ret = maths::zero<U>();
 413         for (int i = 0; i < N; ++i)
 414         {
 415           ret += maths::sqr<U>(v[i]);
 416         }
 417         return ret;
 418       }
 419
 420       inline Vector inv() const
 421       {
 422         return *this / sqr();
 423       }
 424
 425       inline T mag() const
 426       {
 427         return tmag<T>();
 428       }
 429       template <typename U>
 430       inline U tmag() const
 431       {
 432         return maths::sqrt<U>(tsqr<U>());
 433       }
 434
 435
 436       inline Vector & normalize()
 437       {
 438         return operator /= (mag());
 439       }
 440       inline Vector normalized() const
 441       {
 442         return operator / (mag());
 443       }
 444       inline Vector & resize(T tLength)
 445       {
 446         return operator *= (tLength / mag());
 447       }
 448       inline Vector resized(T tLength) const
 449       {
 450         return operator * (tLength / mag());
 451       }
 452
 453
 454       // predicates
 455
 456       /// Equality
 457       inline bool operator == (const Vector & rhs) const
 458       {
 459         for (int i = 0; i < N; ++i)
 460         {
 461           if (v[i] != rhs.v[i])
 462           {
 463             return false;
 464           }
 465         }
 466         return true;
 467       }
 468       /// Nonequality
 469       inline bool operator != (const Vector & rhs) const
 470       {
 471         for (int i = 0; i < N; ++i)
 472         {
 473           if (v[i] != rhs.v[i])
 474           {
 475             return true;
 476           }
 477         }
 478         return false;
 479       }
 480
 481       /// Compare the magnitude of vectors.
 482       inline bool operator < (const Vector & rhs) const
 483       {
 484         return sqr() < rhs.sqr();
 485       }
 486       /// Compare the magnitude of the vector with a scalar magnitude.
 487       inline bool operator < (const T & rhs) const
 488       {
 489         return sqr() < rhs*rhs;
 490       }
 491       /// Compare the magnitude of the vector with a scalar magnitude.
 492       inline friend bool operator < (const T & lhs, const Vector & rhs)
 493       {
 494         return lhs*lhs < rhs.sqr();
 495       }
 496       /// Compare the magnitude of vectors.
 497       inline bool operator <= (const Vector & rhs) const
 498       {
 499         return sqr() <= rhs.sqr();
 500       }
 501       /// Compare the magnitude of the vector with a scalar magnitude.
 502       inline bool operator <= (const T & rhs) const
 503       {
 504         return sqr() <= rhs*rhs;
 505       }
 506       /// Compare the magnitude of the vector with a scalar magnitude.
 507       inline friend bool operator <= (const T & lhs, const Vector & rhs)
 508       {
 509         return lhs*lhs <= rhs.sqr();
 510       }
 511       /// Compare the magnitude of vectors.
 512       inline bool operator > (const Vector & rhs) const
 513       {
 514         return sqr() > rhs.sqr();
 515       }
 516       /// Compare the magnitude of the vector with a scalar magnitude.
 517       inline bool operator > (const T & rhs) const
 518       {
 519         return sqr() > rhs*rhs;
 520       }
 521       /// Compare the magnitude of the vector with a scalar magnitude.
 522       inline friend bool operator > (const T & lhs, const Vector & rhs)
 523       {
 524         return lhs*lhs > rhs.sqr();
 525       }
 526       /// Compare the magnitude of vectors.
 527       inline bool operator >= (const Vector & rhs) const
 528       {
 529         return sqr() >= rhs.sqr();
 530       }
 531       /// Compare the magnitude of the vector with a scalar magnitude.
 532       inline bool operator >= (const T & rhs) const
 533       {
 534         return sqr() >= rhs*rhs;
 535       }
 536       /// Compare the magnitude of the vector with a scalar magnitude.
 537       inline friend bool operator >= (const T & lhs, const Vector & rhs)
 538       {
 539         return lhs*lhs >= rhs.sqr();
 540       }
 541
 542       /// Find whether the vector zero.
 543       inline bool zero() const
 544       {
 545         for (int i = 0; i < N; ++i)
 546         {
 547           if (v[i])
 548           {
 549             return false;
 550           }
 551         }
 552         return true;
 553       }
 554
 555
 556       inline operator std::string() const;
 557   }; // ::maths::Vector
 558
 559   template <int N, typename T>
 560   inline Vector<N,T> & add (Vector<N,T> & dest, const Vector<N,T> & lhs, const Vector<N,T> & rhs)
 561   {
 562     for (int i = 0; i < N; ++i)
 563     {
 564       dest.v[i] = lhs.v[i] + rhs.v[i];
 565     }
 566     return dest;
 567   }
 568
 569   template <int N, typename T>
 570   inline Vector<N,T> & sub (Vector<N,T> & dest, const Vector<N,T> & lhs, const Vector<N,T> & rhs)
 571   {
 572     for (int i = 0; i < N; ++i)
 573     {
 574       dest.v[i] = lhs.v[i] - rhs.v[i];
 575     }
 576     return dest;
 577   }
 578
 579   template <typename T>
 580   inline Vector<3,T> & cross (Vector<3,T> & dest, const Vector<3,T> & lhs, const Vector<3,T> & rhs)
 581   {
 582     dest.v[0] = lhs.v[1]*rhs.v[2] - lhs.v[2]*rhs.v[1];
 583     dest.v[1] = lhs.v[2]*rhs.v[0] - lhs.v[0]*rhs.v[2];
 584     dest.v[2] = lhs.v[0]*rhs.v[1] - lhs.v[1]*rhs.v[0];
 585     return dest;
 586   }
 587
 588   template <typename T>
 589   inline Vector<3,T> cross (const Vector<3,T> & lhs, const Vector<3,T> & rhs)
 590   {
 591     Vector<3, T> dest;
 592     dest.v[0] = lhs.v[1]*rhs.v[2] - lhs.v[2]*rhs.v[1];
 593     dest.v[1] = lhs.v[2]*rhs.v[0] - lhs.v[0]*rhs.v[2];
 594     dest.v[2] = lhs.v[0]*rhs.v[1] - lhs.v[1]*rhs.v[0];
 595     return dest;
 596   }
 597
 598   template <typename T>
 599   inline Vector<4,T> homogenous(Vector<3,T> & vec, T homogenousness = (T)1)
 600   {
 601     Vector<4,T> ret(vec);
 602     ret[3] = homogenousness;
 603     return ret;
 604   }
 605
 606   /// Get the distance from a plane.
 607   template <typename T>
 608   inline T plane(const Vector<4, T> & plane, const Vector<3, T> & point)
 609   {
 610     return plane[0]*point[0] + plane[1]*point[1] + plane[2]*point[2] + plane[3];
 611   }
 612
 613
 614   /// Write a vector to an output stream.
 615   template <int N, typename T>
 616   inline std::ostream & operator << (std::ostream & out, const Vector<N,T> & v)
 617   {
 618     out << "(" << v[0];
 619     for (int i = 1; i < N; ++i)
 620     {
 621       out << ", " << v[i];
 622     }
 623     return out << ")";
 624   }
 625   /// Convert to a string using the above stream operator
 626   template <int N, typename T>
 627   inline Vector<N,T>::operator std::string() const
 628   {
 629     std::stringstream ss;
 630     ss << v;
 631     return ss.str();
 632   }
 633
 634   /// Basic function to create a one dimentional vector (scalar) which can then be expanded by concatination.
 635   template <typename T>
 636   inline maths::Vector<1,T> Scalar(const T a)
 637   {
 638     return maths::Vector<1,T>(a);
 639   }
 640
 641 } // ::maths
 642
 643 #endif // _maths_vector_h