maths/VarVector.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 VarVector.h
  22  * @brief Resizable vector of values, designed for spacial coordinate vectors.
  23  * @author James Hogan <james@albanarts.com>
  24  * @note Copyright (C) 2008
  25  */
  26
  27 #ifndef _maths_VarVector_h
  28 #define _maths_VarVector_h
  29
  30 #include "TemplateMaths.h"
  31 #include "Vector.h"
  32
  33 #include <QtGlobal>
  34
  35 #include <ostream>
  36 #include <sstream>
  37
  38 namespace maths
  39 {
  40
  41   /// VarVector.
  42   /**
  43    * @param N int Number of components in the vector.
  44    * @param T typename Type of the components of the vector.
  45    */
  46   template <typename T>
  47   class VarVector
  48   {
  49     private:
  50       int m_length;
  51       T* v;
  52
  53     public:
  54       typedef T Scalar;
  55
  56       /// Default constructor (zero length, use setLength before doing anything)
  57       inline explicit VarVector()
  58       : m_length(0)
  59       , v(0)
  60       {
  61       }
  62
  63       /// Default constructor (Does not initialise the values!)
  64       inline explicit VarVector(int components)
  65       : m_length(components)
  66       , v(new T[components])
  67       {
  68       }
  69
  70       inline VarVector(int components, T value)
  71       : m_length(components)
  72       , v(new T[components])
  73       {
  74         for (int i = 0; i < m_length; ++i)
  75         {
  76           v[i] = value;
  77         }
  78       }
  79       inline VarVector(int components, const T * vec)
  80       : m_length(components)
  81       , v(new T[components])
  82       {
  83         for (int i = 0; i < m_length; ++i)
  84         {
  85           v[i] = vec[i];
  86         }
  87       }
  88
  89       /// Copy constructor
  90       inline VarVector(const VarVector & copy)
  91       : m_length(copy.m_length)
  92       , v(new T[m_length])
  93       {
  94         for (int i = 0; i < m_length; ++i)
  95         {
  96           v[i] = copy[i];
  97         }
  98       }
  99       template <typename U> inline explicit VarVector(const VarVector<U> & copy)
 100       : m_length(copy.m_length)
 101       , v(new T[m_length])
 102       {
 103         for (int i = 0; i < m_length; ++i)
 104         {
 105           v[i] = copy[i];
 106         }
 107       }
 108       template <int M, typename U> inline explicit VarVector(const Vector<M,U> & copy)
 109       : m_length(M)
 110       , v(new T[M])
 111       {
 112         for (int i = 0; i < M; ++i)
 113         {
 114           v[i] = copy[i];
 115         }
 116       }
 117
 118       /// Destructor
 119       inline ~VarVector()
 120       {
 121         delete [] v;
 122       }
 123
 124       /// Get the length of the vector.
 125       int length() const
 126       {
 127         return m_length;
 128       }
 129
 130       /// Resize of the vector (values are lost).
 131       void setLength(int newLength)
 132       {
 133         if (newLength != m_length)
 134         {
 135           Q_ASSERT(newLength > 0);
 136           delete [] v;
 137           m_length = newLength;
 138           v = new T [newLength];
 139         }
 140       }
 141
 142       /// Assignment operator.
 143       VarVector& operator = (const VarVector& other)
 144       {
 145         setLength(other.m_length);
 146         for (int i = 0; i < m_length; ++i)
 147         {
 148           v[i] = other.v[i];
 149         }
 150         return *this;
 151       }
 152
 153       /// Assignment operator.
 154       template <typename U>
 155       VarVector& operator = (const VarVector<U>& other)
 156       {
 157         setLength(other.m_length);
 158         for (int i = 0; i < m_length; ++i)
 159         {
 160           v[i] = other.v[i];
 161         }
 162         return *this;
 163       }
 164
 165       /// Setter for specific component.
 166       template <int X>
 167       inline void setComponent(const T newValue)
 168       {
 169         v[X] = newValue;
 170       }
 171
 172       /// Getter for specific component.
 173       template <int X>
 174       inline T getComponent() const
 175       {
 176         return v[X];
 177       }
 178
 179       inline T & operator [] (int index)
 180       {
 181         return v[index];
 182       }
 183       inline const T & operator [] (int index) const
 184       {
 185         return v[index];
 186       }
 187
 188       inline operator T * ()
 189       {
 190         return v;
 191       }
 192       inline operator const T * () const
 193       {
 194         return v;
 195       }
 196
 197       inline VarVector operator - () const
 198       {
 199         VarVector ret(m_length);
 200         for (int i = 0; i < m_length; ++i)
 201         {
 202           ret[i] = -v[i];
 203         }
 204         return ret;
 205       }
 206
 207       template <typename U>
 208       inline VarVector & operator += (const VarVector<U> & rhs)
 209       {
 210         Q_ASSERT(m_length == rhs.m_length);
 211         for (int i = 0; i < m_length; ++i)
 212         {
 213           v[i] += rhs.v[i];
 214         }
 215         return *this;
 216       }
 217       template <typename U>
 218       inline VarVector operator + (const VarVector<U> & rhs) const
 219       {
 220         VarVector ret = *this;
 221         return ret += rhs;
 222       }
 223
 224       inline VarVector & operator -= (const VarVector & rhs)
 225       {
 226         Q_ASSERT(m_length == rhs.m_length);
 227         for (int i = 0; i < m_length; ++i)
 228         {
 229           v[i] -= rhs.v[i];
 230         }
 231         return *this;
 232       }
 233       inline VarVector operator - (const VarVector & rhs) const
 234       {
 235         VarVector ret = *this;
 236         return ret -= rhs;
 237       }
 238
 239       inline VarVector & operator *= (const T rhs)
 240       {
 241         for (int i = 0; i < m_length; ++i)
 242         {
 243           v[i] *= rhs;
 244         }
 245         return *this;
 246       }
 247       inline VarVector operator * (const T rhs) const
 248       {
 249         VarVector ret = *this;
 250         return ret *= rhs;
 251       }
 252       inline friend VarVector operator * (const T lhs, const VarVector & rhs)
 253       {
 254         return rhs * lhs;
 255       }
 256
 257       /// Dot product
 258       inline T operator * (const VarVector & rhs) const
 259       {
 260         Q_ASSERT(m_length == rhs.m_length);
 261         T fDot = maths::zero<T>();
 262         for (int i = 0; i < m_length; ++i)
 263         {
 264           fDot += v[i]*rhs.v[i];
 265         }
 266         return fDot;
 267       }
 268
 269       /// Dot quotient
 270       inline T operator / (const VarVector & rhs) const
 271       {
 272         // a = B/C = (B*C)/(C*C)
 273         return operator * (rhs) / rhs.sqr();
 274       }
 275
 276       inline VarVector & operator /= (const T rhs)
 277       {
 278         for (int i = 0; i < m_length; ++i)
 279         {
 280           v[i] /= rhs;
 281         }
 282         return *this;
 283       }
 284       inline VarVector operator / (const T rhs) const
 285       {
 286         VarVector ret = *this;
 287         return ret /= rhs;
 288       }
 289       inline friend VarVector operator / (const T lhs, const VarVector & rhs)
 290       {
 291         return rhs * (lhs / rhs.sqr());
 292       }
 293
 294       inline T sqr() const
 295       {
 296         return tsqr<T>();
 297       }
 298       template <typename U>
 299       inline U tsqr() const
 300       {
 301         U ret = maths::zero<U>();
 302         for (int i = 0; i < m_length; ++i)
 303         {
 304           ret += maths::sqr<U>(v[i]);
 305         }
 306         return ret;
 307       }
 308
 309       inline VarVector inv() const
 310       {
 311         return *this / sqr();
 312       }
 313
 314       inline T mag() const
 315       {
 316         return tmag<T>();
 317       }
 318       template <typename U>
 319       inline U tmag() const
 320       {
 321         return maths::sqrt<U>(tsqr<U>());
 322       }
 323
 324
 325       inline VarVector & normalize()
 326       {
 327         return operator /= (mag());
 328       }
 329       inline VarVector normalized() const
 330       {
 331         return operator / (mag());
 332       }
 333       inline VarVector & resize(T tLength)
 334       {
 335         return operator *= (tLength / mag());
 336       }
 337       inline VarVector resized(T tLength) const
 338       {
 339         return operator * (tLength / mag());
 340       }
 341
 342
 343       // predicates
 344
 345       /// Equality
 346       inline bool operator == (const VarVector & rhs) const
 347       {
 348         Q_ASSERT(m_length == rhs.m_length);
 349         for (int i = 0; i < m_length; ++i)
 350         {
 351           if (v[i] != rhs.v[i])
 352           {
 353             return false;
 354           }
 355         }
 356         return true;
 357       }
 358       /// Nonequality
 359       inline bool operator != (const VarVector & rhs) const
 360       {
 361         Q_ASSERT(m_length == rhs.m_length);
 362         for (int i = 0; i < m_length; ++i)
 363         {
 364           if (v[i] != rhs.v[i])
 365           {
 366             return true;
 367           }
 368         }
 369         return false;
 370       }
 371
 372       /// Compare the magnitude of vectors.
 373       inline bool operator < (const VarVector & rhs) const
 374       {
 375         return sqr() < rhs.sqr();
 376       }
 377       /// Compare the magnitude of the vector with a scalar magnitude.
 378       inline bool operator < (const T & rhs) const
 379       {
 380         return sqr() < rhs*rhs;
 381       }
 382       /// Compare the magnitude of the vector with a scalar magnitude.
 383       inline friend bool operator < (const T & lhs, const VarVector & rhs)
 384       {
 385         return lhs*lhs < rhs.sqr();
 386       }
 387       /// Compare the magnitude of vectors.
 388       inline bool operator <= (const VarVector & rhs) const
 389       {
 390         return sqr() <= rhs.sqr();
 391       }
 392       /// Compare the magnitude of the vector with a scalar magnitude.
 393       inline bool operator <= (const T & rhs) const
 394       {
 395         return sqr() <= rhs*rhs;
 396       }
 397       /// Compare the magnitude of the vector with a scalar magnitude.
 398       inline friend bool operator <= (const T & lhs, const VarVector & rhs)
 399       {
 400         return lhs*lhs <= rhs.sqr();
 401       }
 402       /// Compare the magnitude of vectors.
 403       inline bool operator > (const VarVector & rhs) const
 404       {
 405         return sqr() > rhs.sqr();
 406       }
 407       /// Compare the magnitude of the vector with a scalar magnitude.
 408       inline bool operator > (const T & rhs) const
 409       {
 410         return sqr() > rhs*rhs;
 411       }
 412       /// Compare the magnitude of the vector with a scalar magnitude.
 413       inline friend bool operator > (const T & lhs, const VarVector & rhs)
 414       {
 415         return lhs*lhs > rhs.sqr();
 416       }
 417       /// Compare the magnitude of vectors.
 418       inline bool operator >= (const VarVector & rhs) const
 419       {
 420         return sqr() >= rhs.sqr();
 421       }
 422       /// Compare the magnitude of the vector with a scalar magnitude.
 423       inline bool operator >= (const T & rhs) const
 424       {
 425         return sqr() >= rhs*rhs;
 426       }
 427       /// Compare the magnitude of the vector with a scalar magnitude.
 428       inline friend bool operator >= (const T & lhs, const VarVector & rhs)
 429       {
 430         return lhs*lhs >= rhs.sqr();
 431       }
 432
 433       /// Find whether the vector zero.
 434       inline bool zero() const
 435       {
 436         for (int i = 0; i < m_length; ++i)
 437         {
 438           if (v[i])
 439           {
 440             return false;
 441           }
 442         }
 443         return true;
 444       }
 445
 446       inline operator std::string() const;
 447   }; // ::maths::VarVector
 448
 449   /// Write a vector to an output stream.
 450   template <typename T>
 451   inline std::ostream & operator << (std::ostream & out, const VarVector<T> & v)
 452   {
 453     out << "(" << v[0];
 454     for (int i = 1; i < v.length(); ++i)
 455     {
 456       out << ", " << v[i];
 457     }
 458     return out << ")";
 459   }
 460   /// Convert to a string using the above stream operator
 461   template <typename T>
 462   inline VarVector<T>::operator std::string() const
 463   {
 464     std::stringstream ss;
 465     ss << v;
 466     return ss.str();
 467   }
 468
 469 } // ::maths
 470
 471 #endif // _maths_VarVector_h