IT++ Logo Newcom Logo

operators.cpp

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

Generated on Fri Jun 8 01:07:09 2007 for IT++ by Doxygen 1.5.2