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

Generated on Sat Jul 9 2011 15:21:32 for IT++ by Doxygen 1.7.4