IT++ Logo Newcom Logo

itmex.h

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

Generated on Fri Jun 8 02:08:56 2007 for IT++ by Doxygen 1.5.2