math/src/vector.cc

   1 #include "vector.h"
   2
   3 using namespace std;
   4
   5 Vector::Vector () : m_components ()
   6 {
   7 }
   8
   9 Vector::Vector (const unsigned int dimension) : m_components (dimension, 0)
  10 {
  11 }
  12
  13 Vector::Vector (const double cmp1, const double cmp2, const double cmp3) : m_components(3)
  14 {
  15     m_components.at(0) = cmp1;
  16     m_components.at(1) = cmp2;
  17     m_components.at(2) = cmp3;
  18 }
  19
  20 Vector::Vector (double components[], const unsigned int size) : m_components (size)
  21 {
  22     for (unsigned int i(0) ; i < size ; ++i) {
  23         m_components.at(i) = components[i];
  24     }
  25 }
  26
  27 Vector::Vector (std::vector<double> components) : m_components (components)
  28 {
  29 }
  30
  31 Vector::Vector (const unsigned int dimension, STANDARD_BASIS aVector, const unsigned int i) : m_components (dimension, 0)
  32 {
  33     if (i > dimension or i == 0) {
  34         throw logic_error ("Vector constructor : cannot instantiate vector !");
  35     }
  36     switch (aVector) {
  37         case ei:
  38             m_components.at(i-1) = 1;
  39             break;
  40     }
  41 }
  42
  43 Vector::Vector (const Vector &otherVector) : m_components (otherVector.m_components)
  44 {
  45 }
  46
  47 //===================================================================
  48
  49 unsigned int Vector::dimension () const
  50 {
  51     return m_components.size();
  52 }
  53
  54 //===================================================================
  55
  56 //Operator =
  57 void Vector::operator = (const Vector &otherVector)
  58 {
  59     m_components = otherVector.m_components;
  60 }
  61
  62 //Arithmetic operators +, +=
  63 Vector Vector::operator + (const Vector &otherVector) const
  64 {
  65     return ( Vector(*this) += otherVector );
  66 }
  67
  68 Vector& Vector::operator += (const Vector &otherVector)
  69 {
  70     const unsigned int SIZE (m_components.size());
  71
  72     if (SIZE != otherVector.m_components.size()) {
  73         throw logic_error ("Vectors do not have the same dimension !");
  74     }
  75
  76     for (unsigned int i(0) ; i < SIZE ; ++i) {
  77         m_components.at(i) += otherVector.m_components.at(i);
  78     }
  79
  80     return (*this);
  81 }
  82
  83 //Arithmetic operators -, -=
  84 Vector Vector::operator - (const Vector &otherVector) const
  85 {
  86     return ( Vector(*this) -= otherVector );
  87 }
  88
  89 Vector& Vector::operator -= (const Vector &otherVector)
  90 {
  91     const unsigned int SIZE (m_components.size());
  92
  93     if (SIZE != otherVector.m_components.size()) {
  94         throw logic_error ("Vectors do not have the same dimension !");
  95     }
  96
  97     for (unsigned int i(0) ; i < SIZE ; ++i) {
  98         m_components.at(i) -= otherVector.m_components.at(i);
  99     }
 100
 101     return (*this);
 102 }
 103
 104 //Multiplication by a scalar operators *, *=
 105 Vector Vector::operator * (const double scalar) const
 106 {
 107     return ( Vector(*this) *= scalar );
 108 }
 109
 110 Vector& Vector::operator *= (const double scalar)
 111 {
 112     const unsigned int SIZE (m_components.size());
 113
 114     for (unsigned int i(0) ; i < SIZE ; ++i) {
 115         m_components.at(i) *= scalar;
 116     }
 117     return *this;
 118 }
 119
 120 //Inner product operator
 121 double Vector::operator * (const Vector &otherVector) const
 122 {
 123     return (this->dotProduct(otherVector));
 124 }
 125
 126 Vector Vector::operator / (const double scalar) const
 127 {
 128     return ( Vector(*this) /= scalar );
 129 }
 130
 131 Vector& Vector::operator /= (const double scalar)
 132 {
 133     if (scalar == 0) {
 134         throw domain_error ("Vector::operator /= : Division by zero occured !");
 135     }
 136
 137     const unsigned int SIZE (m_components.size());
 138
 139     for (unsigned int i(0) ; i < SIZE ; ++i) {
 140         m_components.at(i) /= scalar;
 141     }
 142     return *this;
 143 }
 144
 145 /*Cross product operator : /!\ only works for vector in dimension 3 /!\*/
 146 Vector Vector::operator ^ (const Vector &otherVector) const
 147 {
 148     if ( m_components.size() != 3 ) {
 149         throw logic_error ("Cross product only defined in dimension 3");
 150     }
 151     else if ( otherVector.dimension() != 3 ) {
 152         throw logic_error ("Cross product only defined in dimension 3");
 153     }
 154
 155     Vector result;
 156
 157     result.addComponent ( (m_components.at(1) * otherVector.m_components.at(2)) - ((m_components.at(2) * otherVector.m_components.at(1))) );
 158     result.addComponent ( (m_components.at(2) * otherVector.m_components.at(0)) - ((m_components.at(0) * otherVector.m_components.at(2))) );
 159     result.addComponent ( (m_components.at(0) * otherVector.m_components.at(1)) - ((m_components.at(1) * otherVector.m_components.at(0))) );
 160     return result;
 161
 162 }
 163
 164 //Equality operators ==, !=
 165 bool Vector::operator == (const Vector &otherVector) const
 166 {
 167     return (m_components == otherVector.m_components);
 168 }
 169
 170 bool Vector::operator != (const Vector &otherVector) const
 171 {
 172     return not(m_components == otherVector.m_components);
 173 }
 174
 175 /*Index operators [] read-only
 176     /!\ index is understood as a mathematical index, not as a general C++ index /!\
 177                 See method 'at()' for the C++ like getter
 178 */
 179 double Vector::operator [] (const double index) const
 180 {
 181     if (index > m_components.size() or index == 0) {
 182         throw out_of_range ("Vector::operator [] : Index is out of range !");
 183     }
 184     return ( m_components.at(index-1) );
 185 }
 186
 187 /*Index operators [] read-only
 188     /!\ index is understood as a mathematical index, not as a general C++ index /!\
 189                 See method 'at()' for the C++ like getter
 190 */
 191 double& Vector::operator [] (const double index)
 192 {
 193     if (index > m_components.size() or index == 0) {
 194         throw out_of_range ("Vector::operator [] : Index is out of range !");
 195     }
 196     return ( m_components.at(index-1) );
 197 }
 198
 199 ostream& operator << (ostream& os, const Vector& aVector)
 200 {
 201     const unsigned int SIZE (aVector.dimension());
 202
 203     for (unsigned int i(0) ; i < SIZE ; ++i) {
 204         os << aVector.at(i) << ' ';
 205     }
 206     return os;
 207 }
 208
 209 //===================================================================
 210
 211 /*Can throw out_of_range exception
 212     C++ like getter*/
 213 double Vector::at (const unsigned int index) const
 214 {
 215     if (index >= m_components.size()) {
 216         throw out_of_range ("Vector::at () : Index is out of range !");
 217     }
 218     return ( m_components.at(index) );
 219 }
 220
 221 double& Vector::at (const unsigned int index)
 222 {
 223     if (index >= m_components.size() ) {
 224         throw out_of_range ("Vector::at() : Index is out of range !");
 225     }
 226     return ( m_components.at(index) );
 227 }
 228
 229 double Vector::dotProduct (const Vector &otherVector) const
 230 {
 231     double result(0);
 232
 233     const unsigned int SIZE(m_components.size());
 234
 235     if ( SIZE == otherVector.components().size()) {
 236         for (unsigned int i(0) ; i < SIZE ; ++i) {
 237             result += ( m_components.at(i) * otherVector.components().at(i) );
 238         }
 239     }
 240     else {
 241         throw logic_error ("Vectors do not have the same dimension !");
 242     }
 243
 244     return result;
 245 }
 246
 247 //===================================================================
 248
 249 void Vector::addComponent (double value)
 250 {
 251     m_components.push_back (value);
 252 }
 253
 254 double Vector::magnitude () const
 255 {
 256     return sqrt ( dotProduct(*this) );
 257 }
 258
 259 double Vector::magnitude2 () const
 260 {
 261     return ( dotProduct(*this) );
 262 }
 263
 264 void Vector::show () const
 265 {
 266     const unsigned int SIZE(m_components.size());
 267
 268     for (unsigned int i(0) ; i < SIZE ; ++i) {
 269         cout << m_components.at(i) << endl;
 270     }
 271     cout << endl;
 272 }