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 //Operator =
  37 void Vector::operator = (const Vector &otherVector)
  38 {
  39
  40 }
  41
  42 //Arithmetic operators +, +=
  43 Vector Vector::operator + (const Vector &otherVector) const
  44 {
  45
  46 }
  47
  48 Vector& Vector::operator += (const Vector &otherVector)
  49 {
  50
  51 }
  52
  53 //Arithmetic operators -, -=
  54 Vector Vector::operator - (const Vector &otherVector) const
  55 {
  56
  57 }
  58
  59 Vector& Vector::operator -= (const Vector &otherVector)
  60 {
  61
  62 }
  63
  64 //Multiplication by a scalar operators *, *=
  65 Vector Vector::operator * (const double scalar) const
  66 {
  67
  68 }
  69
  70 Vector& Vector::operator *= (const double scalar)
  71 {
  72
  73 }
  74
  75 //Inner product operator
  76 double Vector::operator * (const Vector &otherVector) const
  77 {
  78
  79 }
  80
  81 Vector Vector::operator / (const double scalar) const
  82 {
  83
  84 }
  85
  86 Vector Vector::operator /= (const double scalar)
  87 {
  88
  89 }
  90
  91 /*Cross product operator : /!\ only works for vector in dimension 3 /!\*/
  92 Vector Vector::operator ^ (const Vector &otherVector) const
  93 {
  94     if ( m_components.size() != 3 ) {
  95         throw logic_error ("Cross product only defined in dimension 3");
  96     }
  97     else if ( otherVector.components().size() != 3 ) {
  98         throw logic_error ("Cross product only defined in dimension 3");
  99     }
 100
 101     Vector result;
 102
 103     result.addComponent ( (m_components.at(1) * otherVector.components().at(2)) - ((m_components.at(2) * otherVector.components().at(1))) );
 104     result.addComponent ( (m_components.at(2) * otherVector.components().at(0)) - ((m_components.at(0) * otherVector.components().at(2))) );
 105     result.addComponent ( (m_components.at(0) * otherVector.components().at(1)) - ((m_components.at(1) * otherVector.components().at(0))) );
 106     return result;
 107
 108 }
 109
 110 //Equality operators ==, !=
 111 Vector Vector::operator == (const Vector &otherVector) const
 112 {
 113
 114 }
 115
 116 Vector Vector::operator != (const Vector &otherVector) const
 117 {
 118
 119 }
 120
 121 /*Index operators [] read-only
 122     /!\ index is understood as a mathematical index, not as a general C++ index /!\
 123                 See method 'at()' for the C++ like getter
 124 */
 125 double Vector::operator [] (const double index) const
 126 {
 127
 128 }
 129
 130 /*Index operators [] read-only
 131     /!\ index is understood as a mathematical index, not as a general C++ index /!\
 132                 See method 'at()' for the C++ like getter
 133 */
 134 double& Vector::operator [] (const double index)
 135 {
 136
 137 }
 138
 139 //===================================================================
 140
 141 /*Can throw out_of_range exception
 142     C++ like getter*/
 143 double Vector::at (const unsigned int index) const
 144 {
 145
 146 }
 147
 148 double& Vector::at (const unsigned int index)
 149 {
 150
 151 }
 152
 153 //===================================================================
 154
 155 void Vector::addComponent (double value)
 156 {
 157     m_components.push_back (value);
 158 }
 159
 160 void Vector::show () const
 161 {
 162     const unsigned int SIZE(m_components.size());
 163
 164     for (unsigned int i(0) ; i < SIZE ; ++i) {
 165         cout << m_components.at(i) << endl;
 166     }
 167     cout << endl;
 168 }
 169
 170 bool Vector::equals (const Vector &otherVector) const
 171 {
 172     return ( m_components == otherVector.components() );
 173 }
 174
 175 double Vector::dotProduct (const Vector &otherVector) const
 176 {
 177     double result(0);
 178
 179     const unsigned int SIZE(m_components.size());
 180
 181     if ( SIZE == otherVector.components().size() ) {
 182         for (unsigned int i(0) ; i < SIZE ; ++i) {
 183             result += ( m_components.at(i) * otherVector.components().at(i) );
 184         }
 185     }
 186     else {
 187         throw logic_error ("Vectors do not have the same dimension !");
 188     }
 189
 190     return result;
 191 }
 192
 193 double Vector::magnitude () const
 194 {
 195     return sqrt ( magnitude2() );
 196 }
 197
 198 double Vector::magnitude2 () const
 199 {
 200     return ( dotProduct(*this) );
 201 }
 202
 203 unsigned int Vector::dimension () const
 204 {
 205     return m_components.size();
 206 }
 207