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
Generated on Thu Apr 19 14:20:36 2007 for IT++ by Doxygen 1.4.6