00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef O2SCL_OMATRIX_CX_TLATE_H
00024 #define O2SCL_OMATRIX_CX_TLATE_H
00025
00026
00027
00028
00029
00030 #include <iostream>
00031 #include <cstdlib>
00032 #include <string>
00033 #include <fstream>
00034 #include <sstream>
00035 #include <o2scl/err_hnd.h>
00036 #include <gsl/gsl_matrix.h>
00037 #include <gsl/gsl_complex.h>
00038 #include <o2scl/ovector_tlate.h>
00039 #include <o2scl/ovector_cx_tlate.h>
00040
00041 #ifndef DOXYGENP
00042 namespace o2scl {
00043 #endif
00044
00045
00046
00047
00048 template<class data_t, class parent_t, class block_t, class complex_t>
00049 class omatrix_cx_view_tlate :
00050 public parent_t {
00051
00052 public:
00053
00054
00055
00056
00057 omatrix_cx_view_tlate(const omatrix_cx_view_tlate &v) {
00058 parent_t::block=NULL;
00059 parent_t::data=v.data;
00060 parent_t::size1=v.size1;
00061 parent_t::size2=v.size2;
00062 parent_t::tda=v.tda;
00063 parent_t::owner=0;
00064 }
00065
00066
00067 omatrix_cx_view_tlate& operator=(const omatrix_cx_view_tlate &v) {
00068 parent_t::block=NULL;
00069 parent_t::data=v.data;
00070 parent_t::size1=v.size1;
00071 parent_t::size2=v.size2;
00072 parent_t::tda=v.tda;
00073 parent_t::owner=0;
00074
00075 return *this;
00076 }
00077
00078
00079 ~omatrix_cx_view_tlate() {};
00080
00081
00082
00083
00084
00085
00086 complex_t *operator[](size_t i) {
00087 #if GSL_RANGE_CHECK
00088 if (i>=parent_t::size1) {
00089 set_err((((std::string)"Array index ")+itos(i)+" out of bounds"
00090 +" in omatrix_cx_view_tlate::operator[]. Size: "+
00091 itos(parent_t::size1)+
00092 " (index should be less than size).").c_str(),gsl_index);
00093 return (complex_t *)(parent_t::data);
00094 }
00095 #endif
00096 return (complex_t *)(parent_t::data+i*parent_t::tda*2);
00097 }
00098
00099
00100
00101
00102 const complex_t *operator[](size_t i) const {
00103 #if GSL_RANGE_CHECK
00104 if (i>=parent_t::size1) {
00105 set_err((((std::string)"Array index ")+itos(i)+" out of bounds"
00106 +" in omatrix_cx_view_tlate::operator[] const. Size: "+
00107 itos(parent_t::size1)+
00108 " (index should be less than size).").c_str(),gsl_index);
00109 return (const complex_t *)(parent_t::data);
00110 }
00111 #endif
00112 return (const complex_t *)(parent_t::data+i*parent_t::tda*2);
00113 }
00114
00115
00116
00117
00118 complex_t &operator()(size_t i, size_t j) {
00119 #if GSL_RANGE_CHECK
00120 if (i>=parent_t::size1 || j>=parent_t::size2) {
00121 set_err((((std::string)"Array indices ")+itos(i)+
00122 ", "+itos(j)+" out of bounds"
00123 +" in omatrix_cx_view_tlate::operator(). Sizes: "+
00124 itos(parent_t::size1)+","+itos(parent_t::size2)+
00125 " (indices should be less than sizes).").c_str(),
00126 gsl_index);
00127 return *(complex_t *)(parent_t::data);
00128 }
00129 #endif
00130 return *(complex_t *)(parent_t::data+(i*parent_t::tda+j)*2);
00131 }
00132
00133
00134
00135
00136 const complex_t &operator()(size_t i, size_t j) const {
00137 #if GSL_RANGE_CHECK
00138 if (i>=parent_t::size1 || j>=parent_t::size2) {
00139 set_err((((std::string)"Array indices ")+itos(i)+
00140 ", "+itos(j)+" out of bounds"
00141 +" in omatrix_cx_view_tlate::operator() const. Sizes: "+
00142 itos(parent_t::size1)+","+itos(parent_t::size2)+
00143 " (indices should be less than sizes).").c_str(),
00144 gsl_index);
00145 return *(const complex_t *)(parent_t::data);
00146 }
00147 #endif
00148 return *(const complex_t *)(parent_t::data+(i*parent_t::tda+j)*2);
00149 }
00150
00151
00152 complex_t get(size_t i, size_t j) const {
00153 #if GSL_RANGE_CHECK
00154 if (i>=parent_t::size1 || j>=parent_t::size2) {
00155 set_err((((std::string)"Array indices ")+itos(i)+
00156 ", "+itos(j)+" out of bounds"
00157 +" in omatrix_cx_view_tlate::get(). Sizes: "+
00158 itos(parent_t::size1)+","+itos(parent_t::size2)+
00159 " (indices should be less than sizes).").c_str(),
00160 gsl_index);
00161 complex_t zero={{0,0}};
00162 return zero;
00163 }
00164 #endif
00165 return *(complex_t *)(parent_t::data+(i*parent_t::tda+j)*2);
00166 }
00167
00168
00169 std::complex<data_t> get_stl(size_t i, size_t j) const {
00170 #if GSL_RANGE_CHECK
00171 if (i>=parent_t::size1 || j>=parent_t::size2) {
00172 set_err((((std::string)"Array indices ")+itos(i)+
00173 ", "+itos(j)+" out of bounds"
00174 +" in omatrix_cx_view_tlate::get_stl(). Sizes: "+
00175 itos(parent_t::size1)+","+itos(parent_t::size2)+
00176 " (indices should be less than sizes).").c_str(),
00177 gsl_index);
00178 std::complex<data_t> zero=0;
00179 return zero;
00180 }
00181 #endif
00182 return *(std::complex<data_t> *)(parent_t::data+(i*parent_t::tda+j)*2);
00183 }
00184
00185
00186 data_t real(size_t i, size_t j) const {
00187 #if GSL_RANGE_CHECK
00188 if (i>=parent_t::size1 || j>=parent_t::size2) {
00189 set_err((((std::string)"Array indices ")+itos(i)+
00190 ", "+itos(j)+" out of bounds"
00191 +" in omatrix_cx_view_tlate::real(). Sizes: "+
00192 itos(parent_t::size1)+","+itos(parent_t::size2)+
00193 " (indices should be less than sizes).").c_str(),
00194 gsl_index);
00195 return 0;
00196 }
00197 #endif
00198 return *(parent_t::data+(i*parent_t::tda+j)*2);
00199 }
00200
00201
00202 data_t imag(size_t i, size_t j) const {
00203 #if GSL_RANGE_CHECK
00204 if (i>=parent_t::size1 || j>=parent_t::size2) {
00205 set_err((((std::string)"Array indices ")+itos(i)+
00206 ", "+itos(j)+" out of bounds"
00207 +" in omatrix_cx_view_tlate::imag(). Sizes: "+
00208 itos(parent_t::size1)+","+itos(parent_t::size2)+
00209 " (indices should be less than sizes).").c_str(),
00210 gsl_index);
00211 return 0;
00212 }
00213 #endif
00214 return *(parent_t::data+(i*parent_t::tda+j)*2+1);
00215 }
00216
00217
00218 complex_t *get_ptr(size_t i, size_t j) {
00219 #if GSL_RANGE_CHECK
00220 if (i>=parent_t::size1 || j>=parent_t::size2) {
00221 set_err((((std::string)"Array indices ")+itos(i)+
00222 ", "+itos(j)+" out of bounds"
00223 +" in omatrix_cx_view_tlate::get_ptr(). Sizes: "+
00224 itos(parent_t::size1)+","+itos(parent_t::size2)+
00225 " (indices should be less than sizes).").c_str(),
00226 gsl_index);
00227 return (complex_t *)(parent_t::data);
00228 }
00229 #endif
00230 return (complex_t *)(parent_t::data+(i*parent_t::tda+j)*2);
00231 }
00232
00233
00234 const complex_t *get_const_ptr(size_t i, size_t j) const {
00235 #if GSL_RANGE_CHECK
00236 if (i>=parent_t::size1 || j>=parent_t::size2) {
00237 set_err((((std::string)"Array indices ")+itos(i)+
00238 ", "+itos(j)+" out of bounds"
00239 +" in omatrix_cx_view_tlate::get_const_ptr(). Sizes: "+
00240 itos(parent_t::size1)+","+itos(parent_t::size2)+
00241 " (indices should be less than sizes).").c_str(),
00242 gsl_index);
00243 return (const complex_t *)(parent_t::data);
00244 }
00245 #endif
00246 return (const complex_t *)(parent_t::data+(i*parent_t::tda+j)*2);
00247 }
00248
00249
00250 int set(size_t i, size_t j, complex_t &val) {
00251 #if GSL_RANGE_CHECK
00252 if (i>=parent_t::size1 || j>=parent_t::size2) {
00253 set_err_ret((((std::string)"Array indices ")+itos(i)+
00254 ", "+itos(j)+" out of bounds"
00255 +" in omatrix_cx_view_tlate::set(). Sizes: "+
00256 itos(parent_t::size1)+","+itos(parent_t::size2)+
00257 " (indices should be less than sizes).").c_str(),
00258 gsl_index);
00259 }
00260 #endif
00261 parent_t::data[(i*parent_t::tda+j)*2]=GSL_REAL(val);
00262 parent_t::data[(i*parent_t::tda+j)*2+1]=GSL_IMAG(val);
00263 return 0;
00264 }
00265
00266
00267 int set(size_t i, size_t j, data_t vr, data_t vi) {
00268 #if GSL_RANGE_CHECK
00269 if (i>=parent_t::size1 || j>=parent_t::size2) {
00270 set_err_ret((((std::string)"Array indices ")+itos(i)+
00271 ", "+itos(j)+" out of bounds"
00272 +" in omatrix_cx_view_tlate::set(). Sizes: "+
00273 itos(parent_t::size1)+","+itos(parent_t::size2)+
00274 " (indices should be less than sizes).").c_str(),
00275 gsl_index);
00276 }
00277 #endif
00278 parent_t::data[(i*parent_t::tda+j)*2]=vr;
00279 parent_t::data[(i*parent_t::tda+j)*2+1]=vi;
00280 return 0;
00281 }
00282
00283
00284 int set_real(size_t i, size_t j, data_t vr) {
00285 #if GSL_RANGE_CHECK
00286 if (i>=parent_t::size1 || j>=parent_t::size2) {
00287 set_err_ret((((std::string)"Array indices ")+itos(i)+
00288 ", "+itos(j)+" out of bounds"
00289 +" in omatrix_cx_view_tlate::set_real(). Sizes: "+
00290 itos(parent_t::size1)+","+itos(parent_t::size2)+
00291 " (indices should be less than sizes).").c_str(),
00292 gsl_index);
00293 }
00294 #endif
00295 parent_t::data[(i*parent_t::tda+j)*2]=vr;
00296 return 0;
00297 }
00298
00299
00300 int set_imag(size_t i, size_t j, data_t vi) {
00301 #if GSL_RANGE_CHECK
00302 if (i>=parent_t::size1 || j>=parent_t::size2) {
00303 set_err_ret((((std::string)"Array indices ")+itos(i)+
00304 ", "+itos(j)+" out of bounds"
00305 +" in omatrix_cx_view_tlate::set_imag(). Sizes: "+
00306 itos(parent_t::size1)+","+itos(parent_t::size2)+
00307 " (indices should be less than sizes).").c_str(),
00308 gsl_index);
00309 }
00310 #endif
00311 parent_t::data[(i*parent_t::tda+j)*2+1]=vi;
00312 return 0;
00313 }
00314
00315
00316 int set_all(complex_t &val) {
00317 for(size_t i=0;i<parent_t::size1;i++) {
00318 for(size_t j=0;j<parent_t::size2;j++) {
00319 parent_t::data[(i*parent_t::tda+j)*2]=GSL_REAL(val);
00320 parent_t::data[(i*parent_t::tda+j)*2+1]=GSL_IMAG(val);
00321 }
00322 }
00323 return 0;
00324 }
00325
00326
00327
00328
00329
00330
00331
00332 size_t rows() const {
00333 return parent_t::size1;
00334 }
00335
00336
00337
00338
00339
00340
00341
00342 size_t cols() const {
00343 return parent_t::size2;
00344 }
00345
00346
00347
00348
00349
00350
00351
00352 size_t tda() const {
00353 return parent_t::tda;
00354 }
00355
00356
00357
00358
00359
00360 bool is_owner() const {
00361 if (parent_t::owner==1) return true;
00362 return false;
00363 }
00364
00365
00366 #ifndef DOXYGENP
00367
00368 protected:
00369
00370
00371
00372
00373 omatrix_cx_view_tlate() {};
00374
00375 #endif
00376
00377 };
00378
00379
00380
00381
00382
00383 template<class data_t, class parent_t, class block_t, class complex_t>
00384 class omatrix_cx_tlate :
00385 public omatrix_cx_view_tlate<data_t,parent_t,block_t,complex_t> {
00386 public:
00387
00388
00389
00390
00391 omatrix_cx_tlate(size_t r=0, size_t c=0) {
00392
00393 parent_t::data=0;
00394
00395
00396
00397 parent_t::owner=1;
00398
00399 if (r>0 && c>0) {
00400 parent_t::block=(block_t *)malloc(sizeof(block_t));
00401 if (parent_t::block) {
00402 parent_t::block->data=(data_t *)malloc(2*r*c*sizeof(data_t));
00403 if (parent_t::block->data) {
00404 parent_t::block->size=r*c;
00405 parent_t::data=parent_t::block->data;
00406 parent_t::size1=r;
00407 parent_t::size2=c;
00408 parent_t::tda=c;
00409 } else {
00410 std::free(parent_t::block);
00411 set_err("No memory for data in omatrix_cx_tlate constructor",
00412 gsl_enomem);
00413 }
00414 } else {
00415 set_err("No memory for block in omatrix_cx_tlate contructor",
00416 gsl_enomem);
00417 }
00418 } else {
00419 parent_t::size1=0;
00420 parent_t::size2=0;
00421 parent_t::tda=0;
00422 }
00423 }
00424
00425
00426
00427
00428
00429 omatrix_cx_tlate(const omatrix_cx_tlate &v) :
00430 omatrix_cx_view_tlate<data_t,parent_t,block_t,complex_t>() {
00431 size_t n=v.size1;
00432 size_t n2=v.size2;
00433 if (n>0 && n2>0) {
00434 parent_t::block=(block_t *)malloc(sizeof(block_t));
00435 if (parent_t::block) {
00436 parent_t::block->data=(data_t *)malloc(2*n*n2*sizeof(data_t));
00437 if (parent_t::block->data) {
00438 parent_t::block->size=n*n2;
00439 parent_t::data=parent_t::block->data;
00440 parent_t::size1=n;
00441 parent_t::size2=n2;
00442 parent_t::tda=n2;
00443 parent_t::owner=1;
00444 for(size_t i=0;i<n;i++) {
00445 for(size_t j=0;j<n2;j++) {
00446 *(parent_t::data+i*parent_t::tda+j)=*(v.data+i*v.tda+j);
00447 *(parent_t::data+i*parent_t::tda+j+1)=*(v.data+i*v.tda+j+1);
00448 }
00449 }
00450 } else {
00451 std::free(parent_t::block);
00452 set_err("No memory for data in omatrix_cx_tlate constructor",
00453 gsl_enomem);
00454 }
00455 } else {
00456 set_err("No memory for block in omatrix_cx_tlate contructor",
00457 gsl_enomem);
00458 }
00459 } else {
00460 parent_t::size1=0;
00461 parent_t::size2=0;
00462 parent_t::tda=0;
00463 }
00464 }
00465
00466
00467 omatrix_cx_tlate
00468 (const omatrix_cx_view_tlate<data_t,parent_t,block_t,complex_t> &v) :
00469 omatrix_cx_view_tlate<data_t,parent_t,block_t,complex_t>() {
00470 size_t r=v.rows();
00471 size_t c=v.cols();
00472 if (r>0 && c>0) {
00473 parent_t::block=(block_t *)malloc(sizeof(block_t));
00474 if (parent_t::block) {
00475 parent_t::block->data=(data_t *)malloc(2*r*c*sizeof(data_t));
00476 if (parent_t::block->data) {
00477 parent_t::block->size=r*c;
00478 parent_t::data=parent_t::block->data;
00479 parent_t::size1=v.size1;
00480 parent_t::size2=v.size2;
00481 parent_t::tda=v.tda;
00482 parent_t::owner=1;
00483 for(size_t i=0;i<r;i++) {
00484 for(size_t j=0;i<c;j++) {
00485 *(parent_t::data+i*parent_t::tda+j)=*(v.data+i*v.tda+j);
00486 *(parent_t::data+i*parent_t::tda+j+1)=
00487 *(v.data+i*v.tda+j+1);
00488 }
00489 }
00490 } else {
00491 std::free(parent_t::block);
00492 set_err("No memory for data in omatrix_cx_tlate constructor",
00493 gsl_enomem);
00494 }
00495 } else {
00496 set_err("No memory for block in omatrix_cx_tlate contructor",
00497 gsl_enomem);
00498 }
00499 } else {
00500 parent_t::size1=0;
00501 parent_t::size2=0;
00502 parent_t::tda=0;
00503 }
00504 }
00505
00506
00507 ~omatrix_cx_tlate() {
00508 if (parent_t::size1>0) {
00509 if (parent_t::owner==1) {
00510 if (parent_t::block->size>0) {
00511 std::free(parent_t::block->data);
00512 }
00513 std::free(parent_t::block);
00514 parent_t::size1=0;
00515 parent_t::size2=0;
00516 }
00517 }
00518 }
00519
00520
00521
00522
00523
00524
00525
00526 int allocate(size_t nrows, size_t ncols) {
00527 if (parent_t::size1>0 || parent_t::size2>0) free();
00528
00529 if (nrows>0 && ncols>0) {
00530 parent_t::block=(block_t *)malloc(sizeof(block_t));
00531 if (parent_t::block) {
00532 parent_t::block->data=(data_t *)
00533 malloc(2*nrows*ncols*sizeof(data_t));
00534 if (parent_t::block->data) {
00535 parent_t::block->size=nrows*ncols;
00536 parent_t::data=parent_t::block->data;
00537 parent_t::size1=nrows;
00538 parent_t::size2=ncols;
00539 parent_t::tda=ncols;
00540 parent_t::owner=1;
00541 } else {
00542 std::free(parent_t::block);
00543 set_err_ret
00544 ("No memory for data in omatrix_cx_tlate::allocate()",
00545 gsl_enomem);
00546 }
00547 } else {
00548 set_err_ret
00549 ("No memory for block in omatrix_cx_tlate::allocate()",
00550 gsl_enomem);
00551 }
00552 } else {
00553 set_err_ret("Zero size in omatrix::allocate()",gsl_einval);
00554 }
00555 return 0;
00556 }
00557
00558
00559
00560
00561
00562
00563
00564 int free() {
00565 if (parent_t::size1>0) {
00566 if (parent_t::owner==1) {
00567 if (parent_t::block->size>0) {
00568 std::free(parent_t::block->data);
00569 }
00570 std::free(parent_t::block);
00571 }
00572 parent_t::size1=0;
00573 parent_t::size2=0;
00574 parent_t::tda=0;
00575 }
00576 return 0;
00577 }
00578
00579
00580
00581
00582
00583 omatrix_cx_tlate<data_t,parent_t,block_t,complex_t> transpose() {
00584 omatrix_cx_tlate<data_t,parent_t,block_t,complex_t>
00585 result(parent_t::size2,parent_t::size1);
00586 for(size_t i=0;i<parent_t::size1;i++) {
00587 for(size_t j=0;j<parent_t::size2;j++) {
00588 result[j][i]=(*this)[i][j];
00589 }
00590 }
00591 }
00592
00593
00594 omatrix_cx_tlate<data_t,parent_t,block_t,complex_t> htranspose() {
00595 omatrix_cx_tlate<data_t,parent_t,block_t,complex_t>
00596 result(parent_t::size2,parent_t::size1);
00597 for(size_t i=0;i<parent_t::size1;i++) {
00598 for(size_t j=0;j<parent_t::size2;j++) {
00599 result[j][i]=gsl_complex_conjugate((*this)[i][j]);
00600 }
00601 }
00602 }
00603
00604
00605 };
00606
00607
00608
00609 template<class data_t, class mparent_t, class vparent_t, class block_t,
00610 class complex_t> class omatrix_cx_row_tlate :
00611 public ovector_cx_view_tlate<data_t,vparent_t,block_t,complex_t> {
00612 public:
00613
00614 omatrix_cx_row_tlate
00615 (omatrix_cx_view_tlate<data_t,mparent_t,block_t,complex_t> &m,
00616 size_t i) {
00617 if (i<m.size1) {
00618 vparent_t::size=m.size2;
00619 vparent_t::stride=1;
00620 vparent_t::data=m.data+m.tda()*i;
00621 vparent_t::owner=0;
00622 vparent_t::block=NULL;
00623 }
00624 }
00625 };
00626
00627
00628
00629 template<class data_t, class mparent_t, class vparent_t, class block_t,
00630 class complex_t> class omatrix_cx_const_row_tlate :
00631 public ovector_cx_view_tlate<data_t,vparent_t,block_t,complex_t> {
00632 public:
00633
00634 omatrix_cx_const_row_tlate
00635 (const omatrix_cx_view_tlate<data_t,mparent_t,block_t,complex_t> &m,
00636 size_t i) {
00637 if (i<m.size1) {
00638 vparent_t::size=m.size2;
00639 vparent_t::stride=1;
00640 vparent_t::data=m.data+m.tda*i;
00641 vparent_t::owner=0;
00642 vparent_t::block=NULL;
00643 }
00644 }
00645 };
00646
00647
00648
00649 template<class data_t, class mparent_t, class vparent_t, class block_t,
00650 class complex_t> class omatrix_cx_col_tlate :
00651 public ovector_cx_view_tlate<data_t,vparent_t,block_t,complex_t> {
00652 public:
00653
00654 omatrix_cx_col_tlate
00655 (omatrix_cx_view_tlate<data_t,mparent_t,block_t,complex_t> &m,
00656 size_t i) {
00657 if (i<m.size2) {
00658 vparent_t::size=m.size1;
00659 vparent_t::stride=m.tda();
00660 vparent_t::data=m.data+2*i;
00661 vparent_t::owner=0;
00662 vparent_t::block=NULL;
00663 }
00664 }
00665 };
00666
00667
00668
00669 template<class data_t, class mparent_t, class vparent_t, class block_t,
00670 class complex_t> class omatrix_cx_const_col_tlate :
00671 public ovector_cx_view_tlate<data_t,vparent_t,block_t,complex_t> {
00672 public:
00673
00674 omatrix_cx_const_col_tlate
00675 (omatrix_cx_view_tlate<data_t,mparent_t,block_t,complex_t> &m,
00676 size_t i) {
00677 if (i<m.size2) {
00678 vparent_t::size=m.size1;
00679 vparent_t::stride=m.tda();
00680 vparent_t::data=m.data+2*i;
00681 vparent_t::owner=0;
00682 vparent_t::block=NULL;
00683 }
00684 }
00685 };
00686
00687
00688 typedef omatrix_cx_tlate<double,gsl_matrix_complex,gsl_block_complex,
00689 gsl_complex> omatrix_cx;
00690
00691 typedef omatrix_cx_view_tlate<double,gsl_matrix_complex,gsl_block_complex,
00692 gsl_complex> omatrix_cx_view;
00693
00694 typedef omatrix_cx_row_tlate<double,gsl_matrix_complex,gsl_vector_complex,
00695 gsl_block_complex,gsl_complex> omatrix_cx_row;
00696
00697 typedef omatrix_cx_col_tlate<double,gsl_matrix_complex,gsl_vector_complex,
00698 gsl_block_complex,gsl_complex> omatrix_cx_col;
00699
00700 typedef omatrix_cx_const_row_tlate<double,gsl_matrix_complex,
00701 gsl_vector_complex,gsl_block_complex,gsl_complex> omatrix_cx_const_row;
00702
00703 typedef omatrix_cx_const_col_tlate<double,gsl_matrix_complex,
00704 gsl_vector_complex,gsl_block_complex,gsl_complex> omatrix_cx_const_col;
00705
00706 #ifndef DOXYGENP
00707 }
00708 #endif
00709
00710 #endif
00711