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

Generated on Tue Dec 6 2011 16:51:47 for IT++ by Doxygen 1.7.4