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