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

Generated on Sat Apr 19 10:43:55 2008 for IT++ by Doxygen 1.5.5