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   //-----------  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
SourceForge Logo

Generated on Sat Apr 19 10:41:11 2008 for IT++ by Doxygen 1.5.5