IT++ Logo

itmex.h

Go to the documentation of this file.
00001 
00030 #ifndef ITMEX_H
00031 #define ITMEX_H
00032 
00033 #include <itpp/itbase.h>
00034 #include <mex.h>
00035 
00036 
00037 namespace itpp
00038 {
00039 
00040 //--------------------------------------------------------
00041 // mex -> it++
00042 //--------------------------------------------------------
00043 
00089 // --------------------------------------------------------
00090 // mex -> IT++
00091 // --------------------------------------------------------
00092 
00094 bin mxArray2bin(const mxArray *in);
00096 short mxArray2short(const mxArray *in);
00098 int mxArray2int(const mxArray *in);
00100 double mxArray2double(const mxArray *in);
00102 std::complex<double> mxArray2double_complex(const mxArray *in);
00104 std::string mxArray2string(const mxArray *in);
00105 
00107 bvec mxArray2bvec(const mxArray *in);
00109 svec mxArray2svec(const mxArray *in);
00111 ivec mxArray2ivec(const mxArray *in);
00113 vec mxArray2vec(const mxArray *in);
00115 cvec mxArray2cvec(const mxArray *in);
00116 
00118 bmat mxArray2bmat(const mxArray *in);
00120 smat mxArray2smat(const mxArray *in);
00122 imat mxArray2imat(const mxArray *in);
00124 mat mxArray2mat(const mxArray *in);
00126 cmat mxArray2cmat(const mxArray *in);
00127 
00128 // --------------------------------------------------------
00129 // IT++ -> mex
00130 // --------------------------------------------------------
00131 
00133 void bin2mxArray(const bin &in, mxArray *out);
00135 void short2mxArray(const short &in, mxArray *out);
00137 void int2mxArray(const int &in, mxArray *out);
00139 void double2mxArray(const double &in, mxArray *out);
00141 void double_complex2mxArray(const std::complex<double> &in, mxArray *out);
00143 void string2mxArray(const std::string &in, mxArray* &out);
00144 
00146 void bvec2mxArray(const bvec &in, mxArray *out);
00148 void svec2mxArray(const svec &in, mxArray *out);
00150 void ivec2mxArray(const ivec &in, mxArray *out);
00152 void vec2mxArray(const vec &in, mxArray *out);
00154 void cvec2mxArray(const cvec &in, mxArray *out);
00155 
00157 void bmat2mxArray(const bmat &in, mxArray *out);
00159 void smat2mxArray(const smat &in, mxArray *out);
00161 void imat2mxArray(const imat &in, mxArray *out);
00163 void mat2mxArray(const mat &in, mxArray *out);
00165 void cmat2mxArray(const cmat &in, mxArray *out);
00166 
00167 // --------------------------------------------------------
00168 // mex -> C
00169 // --------------------------------------------------------
00170 
00172 void mxArray2Csvec(const mxArray *in, short *out);
00174 void mxArray2Civec(const mxArray *in, int *out);
00176 void mxArray2Cvec(const mxArray *in, double *out);
00178 void mxArray2Ccvec(const mxArray *in, double *out_real, double *out_imag);
00179 
00181 void mxArray2Csmat(const mxArray *in, short **out);
00183 void mxArray2Cimat(const mxArray *in, int **out);
00185 void mxArray2Cmat(const mxArray *in, double **out);
00187 void mxArray2Ccmat(const mxArray *in, double **out_real, double **out_imag);
00188 
00189 // --------------------------------------------------------
00190 // C -> mex
00191 // --------------------------------------------------------
00192 
00194 void Csvec2mxArray(short *in, mxArray *out);
00196 void Civec2mxArray(int *in, mxArray *out);
00198 void Cvec2mxArray(double *in, mxArray *out);
00200 void Ccvec2mxArray(double *in_real, double *in_imag, mxArray *out);
00201 
00203 void Csmat2mxArray(short **in, mxArray *out);
00205 void Cimat2mxArray(int **in, mxArray *out);
00207 void Cmat2mxArray(double **in, mxArray *out);
00209 void Ccmat2mxArray(double **in_real, double **in_imag, mxArray *out);
00210 
00216 bin mxArray2bin(const mxArray *in)
00217 {
00218   int size;
00219   double* temp = (double*) mxGetPr(in);
00220   if (temp == 0) mexErrMsgTxt("mxArray2bin: Pointer to data is NULL");
00221   size = mxGetNumberOfElements(in);
00222   if (size != 1) mexErrMsgTxt("mxArray2bin: Size of data is not equal to one");
00223 
00224   return (((*temp) > 0.0) ? bin(1) : bin(0));
00225 }
00226 
00227 short mxArray2short(const mxArray *in)
00228 {
00229   int size;
00230   double* temp = (double*) mxGetPr(in);
00231   if (temp == 0) mexErrMsgTxt("mxArray2short: Pointer to data is NULL");
00232   size = mxGetNumberOfElements(in);
00233   if (size != 1) mexErrMsgTxt("mxArray2short: Size of data is not equal to one");
00234 
00235   return (short)(*temp);
00236 }
00237 
00238 int mxArray2int(const mxArray *in)
00239 {
00240   int size;
00241   double* temp = (double*) mxGetPr(in);
00242   if (temp == 0) mexErrMsgTxt("mxArray2int: Pointer to data is NULL");
00243   size = mxGetNumberOfElements(in);
00244   if (size != 1) mexErrMsgTxt("mxArray2int: Size of data is not equal to one");
00245 
00246   return (int)(*temp);
00247 }
00248 
00249 double mxArray2double(const mxArray *in)
00250 {
00251   int size;
00252   double* temp = (double*) mxGetPr(in);
00253   if (temp == 0) mexErrMsgTxt("mxArray2double: Pointer to data is NULL");
00254   size = mxGetNumberOfElements(in);
00255   if (size != 1) mexErrMsgTxt("mxArray2double: Size of data is not equal to one");
00256 
00257   return (*temp);
00258 }
00259 
00260 std::complex<double> mxArray2double_complex(const mxArray *in)
00261 {
00262   int size;
00263   double* tempR = (double*) mxGetPr(in);
00264   double* tempI = (double*) mxGetPi(in);
00265 
00266   if ((tempR == 0) && (tempI == 0)) mexErrMsgTxt("mxArray2double_complex: Pointer to data is NULL");
00267 
00268   size = mxGetNumberOfElements(in);
00269   if (size != 1) mexErrMsgTxt("mxArray2double_complex: Size of data is not equal to one");
00270 
00271   if (tempR == 0) {
00272     return std::complex<double>(0.0 , (*tempI));
00273   }
00274   else if (tempI == 0) {
00275     return std::complex<double>((*tempR), 0.0);
00276   }
00277   else {
00278     return std::complex<double>((*tempR), (*tempI));
00279   }
00280 
00281 }
00282 
00283 std::string mxArray2string(const mxArray *in)
00284 {
00285   if (in == 0)
00286     mexErrMsgTxt("mxArray2string: Pointer to data is NULL");
00287   std::string str = mxArrayToString(in);
00288   if (str.data() == 0)
00289     mexErrMsgTxt("mxArray2string: Could not convert mxArray to string");
00290   return str;
00291 }
00292 
00293 bvec mxArray2bvec(const mxArray *in)
00294 {
00295   bvec out;
00296   int i, size;
00297   double* temp = (double*) mxGetPr(in);
00298   if (temp == 0) mexErrMsgTxt("mxArray2bvec: Pointer to data is NULL");
00299 
00300   size = mxGetNumberOfElements(in);
00301   if (size == 0) mexErrMsgTxt("mxArray2bvec: Size of data is zero");
00302 
00303   out.set_size(size, false);
00304 
00305   for (i = 0; i < size; i++) {
00306     out(i) = (((*temp++) > 1e-5) ? bin(1) : bin(0));
00307   }
00308 
00309   return out;
00310 
00311 }
00312 
00313 svec mxArray2svec(const mxArray *in)
00314 {
00315   svec out;
00316   int i, size;
00317   double* temp = (double*) mxGetPr(in);
00318   if (temp == 0) mexErrMsgTxt("mxArray2svec: Pointer to data is NULL");
00319 
00320   size = mxGetNumberOfElements(in);
00321   if (size == 0) mexErrMsgTxt("mxArray2svec: Size of data is zero");
00322 
00323   out.set_size(size, false);
00324 
00325   for (i = 0; i < size; i++) {
00326     out(i) = (short)(*temp++);
00327   }
00328 
00329   return out;
00330 
00331 }
00332 
00333 ivec mxArray2ivec(const mxArray *in)
00334 {
00335   ivec out;
00336   int i, size;
00337   double* temp = (double*) mxGetPr(in);
00338   if (temp == 0) mexErrMsgTxt("mxArray2ivec: Pointer to data is NULL");
00339 
00340   size = mxGetNumberOfElements(in);
00341   if (size == 0) mexErrMsgTxt("mxArray2ivec: Size of data is zero");
00342 
00343   out.set_size(size, false);
00344 
00345   for (i = 0; i < size; i++) {
00346     out(i) = (int)(*temp++);
00347   }
00348 
00349   return out;
00350 
00351 }
00352 
00353 vec mxArray2vec(const mxArray *in)
00354 {
00355   vec out;
00356   int i, size;
00357   double* temp = (double*) mxGetPr(in);
00358   if (temp == 0) mexErrMsgTxt("mxArray2vec: Pointer to data is NULL");
00359 
00360   size = mxGetNumberOfElements(in);
00361   if (size == 0) mexErrMsgTxt("mxArray2vec: Size of data is zero");
00362 
00363   out.set_size(size, false);
00364 
00365   for (i = 0; i < size; i++) {
00366     out(i) = (*temp++);
00367   }
00368 
00369   return out;
00370 
00371 }
00372 
00373 cvec mxArray2cvec(const mxArray *in)
00374 {
00375   cvec out;
00376   int i, size;
00377   double* tempR = (double*) mxGetPr(in);
00378   double* tempI = (double*) mxGetPi(in);
00379 
00380   if ((tempR == 0) && (tempI == 0)) mexErrMsgTxt("mxArray2cvec: Pointer data is NULL");
00381 
00382   size = mxGetNumberOfElements(in);
00383   if (size == 0) mexErrMsgTxt("mxArray2cvec: Size of data is zero");
00384 
00385   out.set_size(size, false);
00386 
00387   if (tempR == 0) {
00388     for (i = 0; i < size; i++) { out(i) = std::complex<double>(0.0, (*tempI++)); }
00389   }
00390   else if (tempI == 0) {
00391     for (i = 0; i < size; i++) { out(i) = std::complex<double>((*tempR++), 0.0); }
00392   }
00393   else {
00394     for (i = 0; i < size; i++) { out(i) = std::complex<double>((*tempR++), (*tempI++)); }
00395   }
00396 
00397   return out;
00398 
00399 }
00400 
00401 bmat mxArray2bmat(const mxArray *in)
00402 {
00403   bmat out;
00404   int r, c, rows, cols;
00405   double* temp = (double*) mxGetPr(in);
00406   if (temp == 0) mexErrMsgTxt("mxArray2bmat: Pointer to data is NULL");
00407 
00408   rows = mxGetM(in);
00409   if (rows == 0) mexErrMsgTxt("mxArray2bmat: Data has zero rows");
00410   cols = mxGetN(in);
00411   if (cols == 0) mexErrMsgTxt("mxArray2bmat: Data has zero columns");
00412 
00413   out.set_size(rows, cols, false);
00414 
00415   for (c = 0; c < cols; c++) {
00416     for (r = 0; r < rows; r++) {
00417       out(r, c) = (((*temp++) > 0.0) ? bin(1) : bin(0));
00418     }
00419   }
00420 
00421   return out;
00422 
00423 }
00424 
00425 smat mxArray2smat(const mxArray *in)
00426 {
00427   smat out;
00428   int r, c, rows, cols;
00429   double* temp = (double*) mxGetPr(in);
00430   if (temp == 0) mexErrMsgTxt("mxArray2smat: Pointer to data is NULL");
00431 
00432   rows = mxGetM(in);
00433   if (rows == 0) mexErrMsgTxt("mxArray2smat: Data has zero rows");
00434   cols = mxGetN(in);
00435   if (cols == 0) mexErrMsgTxt("mxArray2smat: Data has zero columns");
00436 
00437   out.set_size(rows, cols, false);
00438 
00439   for (c = 0; c < cols; c++) {
00440     for (r = 0; r < rows; r++) {
00441       out(r, c) = (short)(*temp++);
00442     }
00443   }
00444 
00445   return out;
00446 
00447 }
00448 
00449 imat mxArray2imat(const mxArray *in)
00450 {
00451   imat out;
00452   int r, c, rows, cols;
00453   double* temp = (double*) mxGetPr(in);
00454   if (temp == 0) mexErrMsgTxt("mxArray2imat: Pointer to data is NULL");
00455 
00456   rows = mxGetM(in);
00457   if (rows == 0) mexErrMsgTxt("mxArray2imat: Data has zero rows");
00458   cols = mxGetN(in);
00459   if (cols == 0) mexErrMsgTxt("mxArray2imat: Data has zero columns");
00460   out.set_size(rows, cols, false);
00461 
00462   for (c = 0; c < cols; c++) {
00463     for (r = 0; r < rows; r++) {
00464       out(r, c) = (int)(*temp++);
00465     }
00466   }
00467 
00468   return out;
00469 
00470 }
00471 
00472 mat mxArray2mat(const mxArray *in)
00473 {
00474   mat out;
00475   int r, c, rows, cols;
00476   double* temp = (double*) mxGetPr(in);
00477   if (temp == 0) mexErrMsgTxt("mxArray2mat: Pointer to data is NULL");
00478 
00479   rows = mxGetM(in);
00480   if (rows == 0) mexErrMsgTxt("mxArray2mat: Data has zero rows");
00481   cols = mxGetN(in);
00482   if (cols == 0) mexErrMsgTxt("mxArray2mat: Data has zero columns");
00483   out.set_size(rows, cols, false);
00484 
00485   for (c = 0; c < cols; c++) {
00486     for (r = 0; r < rows; r++) {
00487       out(r, c) = (*temp++);
00488     }
00489   }
00490 
00491   return out;
00492 
00493 }
00494 
00495 cmat mxArray2cmat(const mxArray *in)
00496 {
00497   cmat out;
00498   int r, c, rows, cols;
00499   double* tempR = (double*) mxGetPr(in);
00500   double* tempI = (double*) mxGetPi(in);
00501 
00502   if ((tempR == 0) && (tempI == 0)) mexErrMsgTxt("mxArray2cmat: Pointer to data is NULL");
00503 
00504   rows = mxGetM(in);
00505   if (rows == 0) mexErrMsgTxt("mxArray2cmat: Data has zero rows");
00506   cols = mxGetN(in);
00507   if (cols == 0) mexErrMsgTxt("mxArray2cmat: Data has zero columns");
00508   out.set_size(rows, cols, false);
00509 
00510   if (tempR == 0) {
00511     for (c = 0; c < cols; c++) { for (r = 0; r < rows; r++) { out(r, c) = std::complex<double>(0.0 , (*tempI++)); } }
00512   }
00513   else if (tempI == 0) {
00514     for (c = 0; c < cols; c++) { for (r = 0; r < rows; r++) { out(r, c) = std::complex<double>((*tempR++), 0.0); } }
00515   }
00516   else {
00517     for (c = 0; c < cols; c++) { for (r = 0; r < rows; r++) { out(r, c) = std::complex<double>((*tempR++), (*tempI++)); } }
00518   }
00519 
00520   return out;
00521 
00522 }
00523 
00524 void double2mxArray(const double &in, mxArray *out)
00525 {
00526   double* temp = (double *) mxGetPr(out);
00527   if (temp == 0) mexErrMsgTxt("double2mxArray: Pointer to data is NULL");
00528 
00529   *temp = (double) in;
00530 }
00531 
00532 void double_complex2mxArray(const std::complex<double> &in, mxArray *out)
00533 {
00534   double* tempR = (double *) mxGetPr(out);
00535   double* tempI = (double *) mxGetPi(out);
00536   if (tempR == 0) mexErrMsgTxt("double_complex2mxArray: Pointer to real valued part is NULL");
00537   if (tempI == 0) mexErrMsgTxt("double_complex2mxArray: Pointer to imaginary valued part is NULL");
00538 
00539   *tempR = (double) in.real();
00540   *tempI = (double) in.imag();
00541 }
00542 
00543 void string2mxArray(const std::string &in, mxArray* &out)
00544 {
00545   if (in.data() == 0)
00546     mexErrMsgTxt("string2mxArray: Pointer to string is NULL");
00547   out = mxCreateString(in.data());
00548   if (out == 0)
00549     mexErrMsgTxt("string2mxArray: Could not convert string to mxArray");
00550 }
00551 
00552 void bvec2mxArray(const bvec &in, mxArray *out)
00553 {
00554   double* temp = (double *) mxGetPr(out);
00555   if (temp == 0) mexErrMsgTxt("bvec2mxArray: Pointer to data is NULL");
00556   if (in.size() == 0) mexErrMsgTxt("bvec2mxArray: Size of data is zero");
00557   for (int i = 0; i < in.size(); i++) {
00558     if (in(i))
00559       *temp++ = 1.0;
00560     else
00561       *temp++ = 0.0;
00562   }
00563 }
00564 
00565 void ivec2mxArray(const ivec &in, mxArray *out)
00566 {
00567   double* temp = (double *) mxGetPr(out);
00568   if (temp == 0) mexErrMsgTxt("ivec2mxArray: Pointer to data is NULL");
00569   if (in.size() == 0) mexErrMsgTxt("ivec2mxArray: Size of data is zero");
00570 
00571   for (int i = 0; i < in.size(); i++) {
00572     *temp++ = (double) in(i);
00573   }
00574 }
00575 
00576 void vec2mxArray(const vec &in, mxArray *out)
00577 {
00578   double* temp = (double *) mxGetPr(out);
00579   if (temp == 0) mexErrMsgTxt("vec2mxArray: Pointer to data is NULL");
00580   if (in.size() == 0) mexErrMsgTxt("vec2mxArray: Size of data is zero");
00581 
00582   for (int i = 0; i < in.size(); i++) {
00583     *temp++ = (double) in(i);
00584   }
00585 }
00586 
00587 void cvec2mxArray(const cvec &in, mxArray *out)
00588 {
00589   double* tempR = (double *) mxGetPr(out);
00590   double* tempI = (double *) mxGetPi(out);
00591   if (tempR == 0) mexErrMsgTxt("cvec2mxArray: Pointer to real valued part is NULL");
00592   if (tempI == 0) mexErrMsgTxt("cvec2mxArray: Pointer to imaginary valued part is NULL");
00593   if (in.size() == 0) mexErrMsgTxt("cvec2mxArray: Size of data is zero");
00594 
00595   for (int i = 0; i < in.size(); i++) {
00596     *tempR++ = (double) in(i).real();
00597     *tempI++ = (double) in(i).imag();
00598   }
00599 }
00600 
00601 void bmat2mxArray(const bmat &in, mxArray *out)
00602 {
00603   int rows, cols, r, c;
00604 
00605   double* temp = (double *) mxGetPr(out);
00606   if (temp == 0) mexErrMsgTxt("bmat2mxArray: Pointer to data is NULL");
00607 
00608   rows = in.rows();
00609   cols = in.cols();
00610   if (rows == 0) mexErrMsgTxt("bmat2mxArray: Data has zero rows");
00611   if (cols == 0) mexErrMsgTxt("bmat2mxArray: Data has zero columns");
00612 
00613   for (c = 0; c < cols; c++) {
00614     for (r = 0; r < rows; r++) {
00615       if (in(r, c))
00616         *temp++ = 1.0;
00617       else
00618         *temp++ = 0.0;
00619     }
00620   }
00621 
00622 }
00623 
00624 void smat2mxArray(const smat &in, mxArray *out)
00625 {
00626   int rows, cols, r, c;
00627 
00628   double* temp = (double *) mxGetPr(out);
00629   if (temp == 0) mexErrMsgTxt("smat2mxArray: Pointer to data is NULL");
00630 
00631   rows = in.rows();
00632   cols = in.cols();
00633   if (rows == 0) mexErrMsgTxt("smat2mxArray: Data has zero rows");
00634   if (cols == 0) mexErrMsgTxt("smat2mxArray: Data has zero columns");
00635 
00636   for (c = 0; c < cols; c++) {
00637     for (r = 0; r < rows; r++) {
00638       *temp++ = (double) in(r, c);
00639     }
00640   }
00641 
00642 }
00643 
00644 void imat2mxArray(const imat &in, mxArray *out)
00645 {
00646   int rows, cols, r, c;
00647 
00648   double* temp = (double *) mxGetPr(out);
00649   if (temp == 0) mexErrMsgTxt("imat2mxArray: Pointer to data is NULL");
00650 
00651   rows = in.rows();
00652   cols = in.cols();
00653   if (rows == 0) mexErrMsgTxt("imat2mxArray: Data has zero rows");
00654   if (cols == 0) mexErrMsgTxt("imat2mxArray: Data has zero columns");
00655 
00656   for (c = 0; c < cols; c++) {
00657     for (r = 0; r < rows; r++) {
00658       *temp++ = (double) in(r, c);
00659     }
00660   }
00661 
00662 }
00663 
00664 void mat2mxArray(const mat &in, mxArray *out)
00665 {
00666   int rows, cols, r, c;
00667 
00668   double* temp = (double *) mxGetPr(out);
00669   if (temp == 0) mexErrMsgTxt("mat2mxArray: Pointer to data is NULL");
00670 
00671   rows = in.rows();
00672   cols = in.cols();
00673   if (rows == 0) mexErrMsgTxt("mat2mxArray: Data has zero rows");
00674   if (cols == 0) mexErrMsgTxt("mat2mxArray: Data has zero columns");
00675 
00676   for (c = 0; c < cols; c++) {
00677     for (r = 0; r < rows; r++) {
00678       *temp++ = in(r, c);
00679     }
00680   }
00681 
00682 }
00683 
00684 void cmat2mxArray(const cmat &in, mxArray *out)
00685 {
00686   int rows, cols, r, c;
00687 
00688   double* tempR = (double *) mxGetPr(out);
00689   double* tempI = (double *) mxGetPi(out);
00690   if (tempR == 0) mexErrMsgTxt("cvec2mxArray: Pointer to real valued part is NULL");
00691   if (tempI == 0) mexErrMsgTxt("cvec2mxArray: Pointer to imaginary valued part is NULL");
00692 
00693   rows = in.rows();
00694   cols = in.cols();
00695   if (rows == 0) mexErrMsgTxt("cvec2mxArray: Data has zero rows");
00696   if (cols == 0) mexErrMsgTxt("cvec2mxArray: Data has zero columns");
00697 
00698   for (c = 0; c < cols; c++) {
00699     for (r = 0; r < rows; r++) {
00700       *tempR++ = (double) in(r, c).real();
00701       *tempI++ = (double) in(r, c).imag();
00702     }
00703   }
00704 
00705 }
00706 
00707 void mxArray2Csvec(const mxArray *in, short *out)
00708 {
00709   double* temp = (double*) mxGetPr(in);
00710   if (temp == 0) mexErrMsgTxt("mxArray2Csvec: Pointer to data is NULL");
00711   int size = mxGetNumberOfElements(in);
00712   if (size == 0) mexErrMsgTxt("mxArray2Csvec: Size of data is zero");
00713   for (int i = 0; i < size; i++) { out[i] = (short)(*temp++); }
00714 }
00715 
00716 void mxArray2Civec(const mxArray *in, int *out)
00717 {
00718   double* temp = (double*) mxGetPr(in);
00719   if (temp == 0) mexErrMsgTxt("mxArray2Civec: Pointer to data is NULL");
00720   int size = mxGetNumberOfElements(in);
00721   if (size == 0) mexErrMsgTxt("mxArray2Civec: Size of data is zero");
00722   for (int i = 0; i < size; i++) { out[i] = (int)(*temp++); }
00723 }
00724 
00725 void mxArray2Cvec(const mxArray *in, double *out)
00726 {
00727   double* temp = (double*) mxGetPr(in);
00728   if (temp == 0) mexErrMsgTxt("mxArray2Cvec: Pointer to data is NULL");
00729   int size = mxGetNumberOfElements(in);
00730   if (size == 0) mexErrMsgTxt("mxArray2Cvec: Size of data is zero");
00731   for (int i = 0; i < size; i++) { out[i] = (*temp++); }
00732 }
00733 
00734 void mxArray2Ccvec(const mxArray *in, double *out_real, double *out_imag)
00735 {
00736   double* tempR = (double*) mxGetPr(in);
00737   double* tempI = (double*) mxGetPi(in);
00738   if (tempR == 0) mexErrMsgTxt("mxArray2Ccvec: Pointer to real valued part is NULL");
00739   if (tempI == 0) mexErrMsgTxt("mxArray2Ccvec: Pointer to imaginary valued part is NULL");
00740   int size = mxGetNumberOfElements(in);
00741   if (size == 0) mexErrMsgTxt("mxArray2Ccvec: Size of data is zero");
00742   for (int i = 0; i < size; i++) { out_real[i] = (*tempR++); out_imag[i] = (*tempI++); }
00743 }
00744 
00745 void mxArray2Csmat(const mxArray *in, short **out)
00746 {
00747   int r, c;
00748   double* temp = (double*) mxGetPr(in);
00749   if (temp == 0) mexErrMsgTxt("mxArray2Csmat: Pointer to data is NULL");
00750   int rows = mxGetM(in);
00751   if (rows == 0) mexErrMsgTxt("mxArray2Csmat: Data has zero rows");
00752   int cols = mxGetN(in);
00753   if (cols == 0) mexErrMsgTxt("mxArray2Csmat: Data has zero columns");
00754   for (c = 0; c < cols; c++) {
00755     for (r = 0; r < rows; r++) {
00756       out[r][c] = (short)(*temp++);
00757     }
00758   }
00759 }
00760 
00761 void mxArray2Cimat(const mxArray *in, int **out)
00762 {
00763   int r, c;
00764   double* temp = (double*) mxGetPr(in);
00765   if (temp == 0) mexErrMsgTxt("mxArray2Cimat: Pointer to data is NULL");
00766   int rows = mxGetM(in);
00767   if (rows == 0) mexErrMsgTxt("mxArray2Cimat: Data has zero rows");
00768   int cols = mxGetN(in);
00769   if (cols == 0) mexErrMsgTxt("mxArray2Cimat: Data has zero columns");
00770   for (c = 0; c < cols; c++) {
00771     for (r = 0; r < rows; r++) {
00772       out[r][c] = (int)(*temp++);
00773     }
00774   }
00775 }
00776 
00777 void mxArray2Cmat(const mxArray *in, double **out)
00778 {
00779   int r, c;
00780   double* temp = (double*) mxGetPr(in);
00781   if (temp == 0) mexErrMsgTxt("mxArray2Cmat: Pointer to data is NULL");
00782   int rows = mxGetM(in);
00783   if (rows == 0) mexErrMsgTxt("mxArray2Cmat: Data has zero rows");
00784   int cols = mxGetN(in);
00785   if (cols == 0) mexErrMsgTxt("mxArray2Cmat: Data has zero columns");
00786   for (c = 0; c < cols; c++) {
00787     for (r = 0; r < rows; r++) {
00788       out[r][c] = (*temp++);
00789     }
00790   }
00791 }
00792 
00793 void mxArray2Ccmat(const mxArray *in, double **out_real, double **out_imag)
00794 {
00795   int r, c;
00796   double* tempR = (double*) mxGetPr(in);
00797   double* tempI = (double*) mxGetPi(in);
00798   if (tempR == 0) mexErrMsgTxt("mxArray2Cmat: Pointer to real valued part is NULL");
00799   if (tempI == 0) mexErrMsgTxt("mxArray2Cmat: Pointer to imaginary valued part is NULL");
00800   int rows = mxGetM(in);
00801   if (rows == 0) mexErrMsgTxt("mxArray2Cmat: Data has zero rows");
00802   int cols = mxGetN(in);
00803   if (cols == 0) mexErrMsgTxt("mxArray2Cmat: Data has zero columns");
00804   for (c = 0; c < cols; c++) {
00805     for (r = 0; r < rows; r++) {
00806       out_real[r][c] = (*tempR++);
00807       out_imag[r][c] = (*tempI++);
00808     }
00809   }
00810 }
00811 
00812 void Csvec2mxArray(short *in, mxArray *out)
00813 {
00814   double* temp = (double *) mxGetPr(out);
00815   if (temp == 0) mexErrMsgTxt("Csvec2mxArray: Pointer to data is NULL");
00816   int size = mxGetNumberOfElements(out);
00817   if (size == 0) mexErrMsgTxt("Csvec2mxArray: Size of data is zero");
00818   for (int i = 0; i < size; i++) { *temp++ = (double) in[i]; }
00819 }
00820 
00821 void Civec2mxArray(int *in, mxArray *out)
00822 {
00823   double* temp = (double *) mxGetPr(out);
00824   if (temp == 0) mexErrMsgTxt("Civec2mxArray: Pointer to data is NULL");
00825   int size = mxGetNumberOfElements(out);
00826   if (size == 0) mexErrMsgTxt("Civec2mxArray: Size of data is zero");
00827   for (int i = 0; i < size; i++) { *temp++ = (double) in[i]; }
00828 }
00829 
00830 void Cvec2mxArray(double *in, mxArray *out)
00831 {
00832   double* temp = (double *) mxGetPr(out);
00833   if (temp == 0) mexErrMsgTxt("Cvec2mxArray: Pointer to data is NULL");
00834   int size = mxGetNumberOfElements(out);
00835   if (size == 0) mexErrMsgTxt("Cvec2mxArray: Size of data is zero");
00836   for (int i = 0; i < size; i++) { *temp++ = in[i]; }
00837 }
00838 
00839 void Ccvec2mxArray(double *in_real, double *in_imag, mxArray *out)
00840 {
00841   double* tempR = (double *) mxGetPr(out);
00842   double* tempI = (double *) mxGetPi(out);
00843   if (tempR == 0) mexErrMsgTxt("Ccvec2mxArray: Pointer to real valued part is NULL");
00844   if (tempI == 0) mexErrMsgTxt("Ccvec2mxArray: Pointer to imaginary valued part is NULL");
00845   int size = mxGetNumberOfElements(out);
00846   if (size == 0) mexErrMsgTxt("Ccvec2mxArray: Size of data is zero");
00847   for (int i = 0; i < size; i++) { *tempR++ = in_real[i]; *tempI++ = in_imag[i]; }
00848 }
00849 
00850 void Csmat2mxArray(short **in, mxArray *out)
00851 {
00852   int r, c;
00853   double* temp = (double *) mxGetPr(out);
00854   if (temp == 0) mexErrMsgTxt("Csmat2mxArray: Pointer to data is NULL");
00855   int rows = mxGetM(out);
00856   if (rows == 0) mexErrMsgTxt("Csmat2mxArray: Data has zero rows");
00857   int cols = mxGetN(out);
00858   if (cols == 0) mexErrMsgTxt("Csmat2mxArray: Data has zero columns");
00859   for (c = 0; c < cols; c++) {
00860     for (r = 0; r < rows; r++) {
00861       *temp++ = (short) in[r][c];
00862     }
00863   }
00864 }
00865 
00866 void Cimat2mxArray(int **in, mxArray *out)
00867 {
00868   int r, c;
00869   double* temp = (double *) mxGetPr(out);
00870   if (temp == 0) mexErrMsgTxt("Cimat2mxArray: Pointer to data is NULL");
00871   int rows = mxGetM(out);
00872   if (rows == 0) mexErrMsgTxt("Cimat2mxArray: Data has zero rows");
00873   int cols = mxGetN(out);
00874   if (cols == 0) mexErrMsgTxt("Cimat2mxArray: Data has zero columns");
00875   for (c = 0; c < cols; c++) {
00876     for (r = 0; r < rows; r++) {
00877       *temp++ = (int) in[r][c];
00878     }
00879   }
00880 }
00881 
00882 void Cmat2mxArray(double **in, mxArray *out)
00883 {
00884   int r, c;
00885   double* temp = (double *) mxGetPr(out);
00886   if (temp == 0) mexErrMsgTxt("Cmat2mxArray: Pointer to data is NULL");
00887   int rows = mxGetM(out);
00888   if (rows == 0) mexErrMsgTxt("Cmat2mxArray: Data has zero rows");
00889   int cols = mxGetN(out);
00890   if (cols == 0) mexErrMsgTxt("Cmat2mxArray: Data has zero columns");
00891   for (c = 0; c < cols; c++) {
00892     for (r = 0; r < rows; r++) {
00893       *temp++ = in[r][c];
00894     }
00895   }
00896 }
00897 
00898 void Ccmat2mxArray(double **in_real, double **in_imag, mxArray *out)
00899 {
00900   int r, c;
00901   double* tempR = (double *) mxGetPr(out);
00902   double* tempI = (double *) mxGetPi(out);
00903   if (tempR == 0) mexErrMsgTxt("Ccmat2mxArray: Pointer to real valued part is NULL");
00904   if (tempI == 0) mexErrMsgTxt("Ccmat2mxArray: Pointer to imaginary valued part is NULL");
00905   int rows = mxGetM(out);
00906   if (rows == 0) mexErrMsgTxt("Ccmat2mxArray: Data has zero rows");
00907   int cols = mxGetN(out);
00908   if (cols == 0) mexErrMsgTxt("Ccmat2mxArray: Data has zero columns");
00909   for (c = 0; c < cols; c++) {
00910     for (r = 0; r < rows; r++) {
00911       *tempR++ = in_real[r][c];
00912       *tempI++ = in_imag[r][c];
00913     }
00914   }
00915 }
00916 
00917 } // namespace itpp
00918 
00919 #endif // #ifndef ITMEX_H
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SourceForge Logo

Generated on Sat Feb 26 2011 16:06:34 for IT++ by Doxygen 1.7.3