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
Generated on Fri Aug 14 15:28:11 2009 for IT++ by Doxygen 1.5.9