IT++ Logo
operators.cpp
Go to the documentation of this file.
00001 
00030 #include <itpp/base/operators.h>
00031 
00032 
00033 namespace itpp
00034 {
00035 
00036 //-----------  Scalar and a ivec -----------------
00037 
00038 vec operator+(const double &s, const ivec &v)
00039 {
00040   it_assert_debug(v.size() > 0, "operator+(): Vector of zero length");
00041 
00042   vec temp(v.size());
00043   for (int i = 0;i < v.size();i++) {
00044     temp(i) = s + double(v(i));
00045   }
00046   return temp;
00047 }
00048 
00049 vec operator-(const double &s, const ivec &v)
00050 {
00051   it_assert_debug(v.size() > 0, "operator-(): Vector of zero length");
00052 
00053   vec temp(v.size());
00054   for (int i = 0;i < v.size();i++) {
00055     temp(i) = s - double(v(i));
00056   }
00057   return temp;
00058 }
00059 
00060 vec operator*(const double &s, const ivec &v)
00061 {
00062   it_assert_debug(v.size() > 0, "operator*(): Vector of zero length");
00063 
00064   vec temp(v.size());
00065   for (int i = 0;i < v.size();i++) {
00066     temp(i) = s * double(v(i));
00067   }
00068   return temp;
00069 }
00070 
00071 vec operator/(const double &s, const ivec &v)
00072 {
00073   it_assert_debug(v.size() > 0, "operator/(): Vector of zero length");
00074 
00075   vec temp(v.size());
00076   for (int i = 0;i < v.size();i++) {
00077     temp(i) = s / double(v(i));
00078   }
00079   return temp;
00080 }
00081 
00082 vec operator/(const ivec &v, const double &s)
00083 {
00084   it_assert_debug(v.size() > 0, "operator/(): Vector of zero length");
00085 
00086   vec temp(v.size());
00087   for (int i = 0;i < v.size();i++) {
00088     temp(i) = double(v(i)) / s;
00089   }
00090   return temp;
00091 }
00092 
00093 cvec operator+(const std::complex<double> &s, const ivec &v)
00094 {
00095   it_assert_debug(v.size() > 0, "operator+(): Vector of zero length");
00096 
00097   cvec temp(v.size());
00098   for (int i = 0;i < v.size();i++) {
00099     temp(i) = s + std::complex<double>(v(i));
00100   }
00101   return temp;
00102 }
00103 
00104 cvec operator-(const std::complex<double> &s, const ivec &v)
00105 {
00106   it_assert_debug(v.size() > 0, "operator-(): Vector of zero length");
00107 
00108   cvec temp(v.size());
00109   for (int i = 0;i < v.size();i++) {
00110     temp(i) = s - std::complex<double>(v(i));
00111   }
00112   return temp;
00113 }
00114 
00115 cvec operator*(const std::complex<double> &s, const ivec &v)
00116 {
00117   it_assert_debug(v.size() > 0, "operator*(): Vector of zero length");
00118 
00119   cvec temp(v.size());
00120   for (int i = 0;i < v.size();i++) {
00121     temp(i) = s * std::complex<double>(v(i));
00122   }
00123   return temp;
00124 }
00125 
00126 cvec operator/(const std::complex<double> &s, const ivec &v)
00127 {
00128   it_assert_debug(v.size() > 0, "operator/(): Vector of zero length");
00129 
00130   cvec temp(v.size());
00131   for (int i = 0;i < v.size();i++) {
00132     temp(i) = s / std::complex<double>(v(i));
00133   }
00134   return temp;
00135 }
00136 
00137 cvec operator/(const ivec &v, const std::complex<double> &s)
00138 {
00139   it_assert_debug(v.size() > 0, "operator/(): Vector of zero length");
00140 
00141   cvec temp(v.size());
00142   for (int i = 0;i < v.size();i++) {
00143     temp(i) = std::complex<double>(v(i)) / s;
00144   }
00145   return temp;
00146 }
00147 
00148 //-----------  Scalar and a cvec -----------------
00149 
00150 cvec operator+(const double &s, const cvec &v)
00151 {
00152   it_assert_debug(v.size() > 0, "operator+(): Vector of zero length");
00153 
00154   cvec temp = v;
00155   for (int i = 0;i < v.size();i++) {
00156     temp(i) += s;
00157   }
00158   return temp;
00159 }
00160 
00161 cvec operator-(const double &s, const cvec &v)
00162 {
00163   it_assert_debug(v.size() > 0, "operator-(): Vector of zero length");
00164 
00165   cvec temp(v.size());
00166   for (int i = 0;i < v.size();i++) {
00167     temp(i) = std::complex<double>((double)s - v(i).real(), -v(i).imag());
00168   }
00169   return temp;
00170 }
00171 
00172 cvec operator*(const double &s, const cvec &v)
00173 {
00174   it_assert_debug(v.size() > 0, "operator*(): Vector of zero length");
00175 
00176   cvec temp = v;
00177   for (int i = 0;i < v.size();i++) {
00178     temp(i) *= (double)s;
00179   }
00180   return temp;
00181 }
00182 
00183 cvec operator/(const cvec &v, const double &s)
00184 {
00185   it_assert_debug(v.size() > 0, "operator/(): Vector of zero length");
00186 
00187   cvec temp = v;
00188   for (int i = 0;i < v.size();i++) {
00189     temp(i) /= (double)s;
00190   }
00191   return temp;
00192 }
00193 
00194 cvec operator/(const double &s, const cvec &v)
00195 {
00196   it_assert_debug(v.size() > 0, "operator/(): Vector of zero length");
00197 
00198   cvec temp(v.length());
00199   for (int i = 0;i < v.size();i++) {
00200     temp(i) = s / v(i);
00201   }
00202   return temp;
00203 }
00204 
00205 //-----------  Scalar and a cmat -----------------
00206 
00207 cmat operator+(const double &s, const cmat &m)
00208 {
00209   it_assert_debug(m.rows() > 0 && m.cols() > 0, "operator+(): Matrix of zero length");
00210 
00211   cmat temp = m;
00212   for (int i = 0;i < m._datasize();i++) {
00213     temp._data()[i] += s;
00214   }
00215   return temp;
00216 }
00217 
00218 cmat operator-(const double &s, const cmat &m)
00219 {
00220   it_assert_debug(m.rows() > 0 && m.cols() > 0, "operator-(): Matrix of zero length");
00221 
00222   cmat temp(m.rows(), m.cols());
00223   for (int i = 0;i < m._datasize();i++) {
00224     temp._data()[i] = std::complex<double>((double)s - m(i).real(), -m(i).imag());
00225   }
00226   return temp;
00227 }
00228 
00229 cmat operator*(const double &s, const cmat &m)
00230 {
00231   it_assert_debug(m.rows() > 0 && m.cols() > 0, "operator*(): Matrix of zero length");
00232 
00233   cmat temp = m;
00234   for (int i = 0;i < m._datasize();i++) {
00235     temp._data()[i] *= (double)s;
00236   }
00237   return temp;
00238 }
00239 
00240 cmat operator*(const std::complex<double> &s, const mat &m)
00241 {
00242   it_assert_debug(m.rows() > 0 && m.cols() > 0, "operator*(): Matrix of zero length");
00243 
00244   cmat temp(m.rows(), m.cols());
00245 
00246   for (int i = 0;i < m._datasize();i++) {
00247     temp._data()[i] = s * m._data()[i];
00248   }
00249   return temp;
00250 }
00251 
00252 cmat operator/(const cmat &m, const double &s)
00253 {
00254   it_assert_debug(m.rows() > 0 && m.cols() > 0, "operator/(): Matrix of zero length");
00255 
00256   cmat temp = m;
00257   for (int i = 0;i < m._datasize();i++) {
00258     temp._data()[i] /= (double)s;
00259   }
00260   return temp;
00261 }
00262 
00263 //---------------------- between matrix and scalar --------------------
00264 
00265 //----------- Multiplication of a scalar and a vec -----------------
00266 
00267 cvec operator*(const std::complex<double> &s, const vec &v)
00268 {
00269   cvec temp(v.size());
00270   for (int i = 0;i < v.size();i++) {
00271     temp(i) = s * std::complex<double>(v(i), 0.0);
00272   }
00273   return temp;
00274 }
00275 
00276 cvec operator*(const vec &v, const std::complex<double> &s)
00277 {
00278   cvec temp(v.size());
00279   for (int i = 0;i < v.size();i++) {
00280     temp(i) = s * std::complex<double>(v(i), 0.0);
00281   }
00282   return temp;
00283 }
00284 
00285 // ===============================================================================================
00286 
00287 // ---------------- Addition of vectors ---------------
00288 
00289 
00290 vec operator+(const bvec &a, const vec &b)
00291 {
00292   it_assert_debug(a.size() == b.size(), "operator+(): sizes does not match");
00293   vec temp(a.size());
00294   for (int i = 0;i < a.size();i++) {temp(i) = (double)a(i) + b(i);}
00295   return temp;
00296 }
00297 
00298 vec operator+(const svec &a, const vec &b)
00299 {
00300   it_assert_debug(a.size() == b.size(), "operator+(): sizes does not match");
00301   vec temp(a.size());
00302   for (int i = 0;i < a.size();i++) {temp(i) = (double)a(i) + b(i);}
00303   return temp;
00304 }
00305 
00306 vec operator+(const ivec &a, const vec &b)
00307 {
00308   it_assert_debug(a.size() == b.size(), "operator+(): sizes does not match");
00309   vec temp(a.size());
00310   for (int i = 0;i < a.size();i++) {temp(i) = (double)a(i) + b(i);}
00311   return temp;
00312 }
00313 
00314 cvec operator+(const bvec &a, const cvec &b)
00315 {
00316   it_assert_debug(a.size() == b.size(), "operator+(): sizes does not match");
00317   cvec temp = b;
00318   for (int i = 0;i < a.size();i++) {temp(i) += (double)a(i);}
00319   return temp;
00320 }
00321 
00322 cvec operator+(const svec &a, const cvec &b)
00323 {
00324   it_assert_debug(a.size() == b.size(), "operator+(): sizes does not match");
00325   cvec temp = b;
00326   for (int i = 0;i < a.size();i++) {temp(i) += (double)a(i);}
00327   return temp;
00328 }
00329 
00330 cvec operator+(const ivec &a, const cvec &b)
00331 {
00332   it_assert_debug(a.size() == b.size(), "operator+(): sizes does not match");
00333   cvec temp = b;
00334   for (int i = 0;i < a.size();i++) {temp(i) += (double)a(i);}
00335   return temp;
00336 }
00337 
00338 // ---------------- Multiplication of vectors ---------------
00339 
00340 double operator*(const bvec &a, const vec &b)
00341 {
00342   it_assert_debug(a.size() == b.size(), "operator*(): sizes does not match");
00343   double temp = 0;
00344   for (int i = 0;i < a.size();i++) {temp += (double)a(i) * b(i);}
00345   return temp;
00346 }
00347 
00348 double operator*(const svec &a, const vec &b)
00349 {
00350   it_assert_debug(a.size() == b.size(), "operator*(): sizes does not match");
00351   double temp = 0;
00352   for (int i = 0;i < a.size();i++) {temp += (double)a(i) * b(i);}
00353   return temp;
00354 }
00355 
00356 double operator*(const ivec &a, const vec &b)
00357 {
00358   it_assert_debug(a.size() == b.size(), "operator*(): sizes does not match");
00359   double temp = 0;
00360   for (int i = 0;i < a.size();i++) {temp += (double)a(i) * b(i);}
00361   return temp;
00362 }
00363 
00364 std::complex<double> operator*(const bvec &a, const cvec &b)
00365 {
00366   it_assert_debug(a.size() == b.size(), "operator*(): sizes does not match");
00367   std::complex<double> temp = 0;
00368   for (int i = 0;i < a.size();i++) {temp += (double)a(i) * b(i);}
00369   return temp;
00370 }
00371 
00372 std::complex<double> operator*(const svec &a, const cvec &b)
00373 {
00374   it_assert_debug(a.size() == b.size(), "operator*(): sizes does not match");
00375   std::complex<double> temp = 0;
00376   for (int i = 0;i < a.size();i++) {temp += (double)a(i) * b(i);}
00377   return temp;
00378 }
00379 
00380 std::complex<double> operator*(const ivec &a, const cvec &b)
00381 {
00382   it_assert_debug(a.size() == b.size(), "operator*(): sizes does not match");
00383   std::complex<double> temp = 0;
00384   for (int i = 0;i < a.size();i++) {temp += (double)a(i) * b(i);}
00385   return temp;
00386 }
00387 
00388 // ---------------- Addition of matricies ---------------
00389 
00390 mat operator+(const bmat &a, const mat &b)
00391 {
00392   it_assert_debug(a.cols() == b.cols() && a.rows() == b.rows(), "operator+(): sizes does not match");
00393   mat temp(b);
00394 
00395   for (int i = 0;i < a.rows();i++) {
00396     for (int j = 0;j < a.cols();j++) {
00397       temp(i, j) += (double)a(i, j);
00398     }
00399   }
00400   return temp;
00401 }
00402 
00403 mat operator+(const smat &a, const mat &b)
00404 {
00405   it_assert_debug(a.cols() == b.cols() && a.rows() == b.rows(), "operator+(): sizes does not match");
00406   mat temp(b);
00407 
00408   for (int i = 0;i < a.rows();i++) {
00409     for (int j = 0;j < a.cols();j++) {
00410       temp(i, j) += (double)a(i, j);
00411     }
00412   }
00413   return temp;
00414 }
00415 
00416 mat operator+(const imat &a, const mat &b)
00417 {
00418   it_assert_debug(a.cols() == b.cols() && a.rows() == b.rows(), "operator+(): sizes does not match");
00419   mat temp(b);
00420 
00421   for (int i = 0;i < a.rows();i++) {
00422     for (int j = 0;j < a.cols();j++) {
00423       temp(i, j) += (double)a(i, j);
00424     }
00425   }
00426   return temp;
00427 }
00428 
00429 // ---------------- Addition of cmat and matrices ---------------
00430 
00431 cmat operator+(const bmat &a, const cmat &b)
00432 {
00433   it_assert_debug(a.cols() == b.cols() && a.rows() == b.rows(), "operator+(): sizes does not match");
00434   cmat temp(b);
00435 
00436   for (int i = 0;i < a.rows();i++) {
00437     for (int j = 0;j < a.cols();j++) {
00438       temp(i, j) += std::complex<double>(static_cast<double>(a(i, j)), 0.0);
00439     }
00440   }
00441   return temp;
00442 }
00443 
00444 cmat operator+(const smat &a, const cmat &b)
00445 {
00446   it_assert_debug(a.cols() == b.cols() && a.rows() == b.rows(), "operator+(): sizes does not match");
00447   cmat temp(b);
00448 
00449   for (int i = 0;i < a.rows();i++) {
00450     for (int j = 0;j < a.cols();j++) {
00451       temp(i, j) += (double)a(i, j);
00452     }
00453   }
00454   return temp;
00455 }
00456 
00457 cmat operator+(const imat &a, const cmat &b)
00458 {
00459   it_assert_debug(a.cols() == b.cols() && a.rows() == b.rows(), "operator+(): sizes does not match");
00460   cmat temp(b);
00461 
00462   for (int i = 0;i < a.rows();i++) {
00463     for (int j = 0;j < a.cols();j++) {
00464       temp(i, j) += std::complex<double>(static_cast<double>(a(i, j)), 0.0);
00465     }
00466   }
00467   return temp;
00468 }
00469 
00470 cmat operator+(const mat &a, const cmat &b)
00471 {
00472   it_assert_debug(a.cols() == b.cols() && a.rows() == b.rows(), "operator+(): sizes does not match");
00473   cmat temp(b);
00474 
00475   for (int i = 0;i < a.rows();i++) {
00476     for (int j = 0;j < a.cols();j++) {
00477       temp(i, j) += std::complex<double>(static_cast<double>(a(i, j)), 0.0);
00478     }
00479   }
00480   return temp;
00481 }
00482 
00483 } // namespace itpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SourceForge Logo

Generated on Sat Jul 9 2011 15:21:30 for IT++ by Doxygen 1.7.4