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 bvec2mxArray(const bvec &in, mxArray *out)
00503   {
00504     double* temp = (double *) mxGetPr(out);
00505     if (temp==0) mexErrMsgTxt("bvec2mxArray: Pointer to data is NULL");
00506     if (in.size()==0) mexErrMsgTxt("bvec2mxArray: Size of data is zero");
00507     for(int i=0; i<in.size(); i++) {
00508       if(in(i))
00509         *temp++= 1.0;
00510       else
00511         *temp++= 0.0;
00512     }
00513   }
00514 
00515   void ivec2mxArray(const ivec &in, mxArray *out)
00516   {
00517     double* temp = (double *) mxGetPr(out);
00518     if (temp==0) mexErrMsgTxt("ivec2mxArray: Pointer to data is NULL");
00519     if (in.size()==0) mexErrMsgTxt("ivec2mxArray: Size of data is zero");
00520 
00521     for(int i=0; i<in.size(); i++) {
00522       *temp++= (double) in(i);
00523     }
00524   }
00525 
00526   void vec2mxArray(const vec &in, mxArray *out)
00527   {
00528     double* temp = (double *) mxGetPr(out);
00529     if (temp==0) mexErrMsgTxt("vec2mxArray: Pointer to data is NULL");
00530     if (in.size()==0) mexErrMsgTxt("vec2mxArray: Size of data is zero");
00531 
00532     for(int i=0; i<in.size(); i++) {
00533       *temp++= (double) in(i);
00534     }
00535   }
00536 
00537   void cvec2mxArray(const cvec &in, mxArray *out)
00538   {
00539     double* tempR = (double *) mxGetPr(out);
00540     double* tempI = (double *) mxGetPi(out);
00541     if (tempR==0) mexErrMsgTxt("cvec2mxArray: Pointer to real valued part is NULL");
00542     if (tempI==0) mexErrMsgTxt("cvec2mxArray: Pointer to imaginary valued part is NULL");
00543     if (in.size()==0) mexErrMsgTxt("cvec2mxArray: Size of data is zero");
00544 
00545     for(int i=0; i<in.size(); i++) {
00546       *tempR++= (double) in(i).real();
00547       *tempI++= (double) in(i).imag();
00548     }
00549   }
00550 
00551   void bmat2mxArray(const bmat &in, mxArray *out)
00552   {
00553     int rows, cols, r, c;
00554 
00555     double* temp = (double *) mxGetPr(out);
00556     if (temp==0) mexErrMsgTxt("bmat2mxArray: Pointer to data is NULL");
00557 
00558     rows = in.rows();
00559     cols = in.cols();
00560     if (rows==0) mexErrMsgTxt("bmat2mxArray: Data has zero rows");
00561     if (cols==0) mexErrMsgTxt("bmat2mxArray: Data has zero columns");
00562 
00563     for(c=0; c<cols; c++) {
00564       for(r=0; r<rows; r++) {
00565         if(in(r,c))
00566           *temp++= 1.0;
00567         else
00568           *temp++= 0.0;    
00569       }
00570     }
00571 
00572   }
00573 
00574   void smat2mxArray(const smat &in, mxArray *out)
00575   {
00576     int rows, cols, r, c;
00577 
00578     double* temp = (double *) mxGetPr(out);
00579     if (temp==0) mexErrMsgTxt("smat2mxArray: Pointer to data is NULL");
00580 
00581     rows = in.rows();
00582     cols = in.cols();
00583     if (rows==0) mexErrMsgTxt("smat2mxArray: Data has zero rows");
00584     if (cols==0) mexErrMsgTxt("smat2mxArray: Data has zero columns");
00585 
00586     for(c=0; c<cols; c++) {
00587       for(r=0; r<rows; r++) {
00588         *temp++= (double) in(r,c);
00589       }
00590     }
00591 
00592   }
00593 
00594   void imat2mxArray(const imat &in, mxArray *out)
00595   {
00596     int rows, cols, r, c;
00597 
00598     double* temp = (double *) mxGetPr(out);
00599     if (temp==0) mexErrMsgTxt("imat2mxArray: Pointer to data is NULL");
00600 
00601     rows = in.rows();
00602     cols = in.cols();
00603     if (rows==0) mexErrMsgTxt("imat2mxArray: Data has zero rows");
00604     if (cols==0) mexErrMsgTxt("imat2mxArray: Data has zero columns");
00605 
00606     for(c=0; c<cols; c++) {
00607       for(r=0; r<rows; r++) {
00608         *temp++= (double) in(r,c);
00609       }
00610     }
00611 
00612   }
00613 
00614   void mat2mxArray(const mat &in, mxArray *out)
00615   {
00616     int rows, cols, r, c;
00617 
00618     double* temp = (double *) mxGetPr(out);
00619     if (temp==0) mexErrMsgTxt("mat2mxArray: Pointer to data is NULL");
00620 
00621     rows = in.rows();
00622     cols = in.cols();
00623     if (rows==0) mexErrMsgTxt("mat2mxArray: Data has zero rows");
00624     if (cols==0) mexErrMsgTxt("mat2mxArray: Data has zero columns");
00625 
00626     for(c=0; c<cols; c++) {
00627       for(r=0; r<rows; r++) {
00628         *temp++= in(r,c);
00629       }
00630     }
00631 
00632   }
00633 
00634   void cmat2mxArray(const cmat &in, mxArray *out)
00635   {
00636     int rows, cols, r, c;
00637 
00638     double* tempR = (double *) mxGetPr(out);
00639     double* tempI = (double *) mxGetPi(out);
00640     if (tempR==0) mexErrMsgTxt("cvec2mxArray: Pointer to real valued part is NULL");
00641     if (tempI==0) mexErrMsgTxt("cvec2mxArray: Pointer to imaginary valued part is NULL");
00642 
00643     rows = in.rows();
00644     cols = in.cols();
00645     if (rows==0) mexErrMsgTxt("cvec2mxArray: Data has zero rows");
00646     if (cols==0) mexErrMsgTxt("cvec2mxArray: Data has zero columns");
00647 
00648     for(c=0; c<cols; c++) {
00649       for(r=0; r<rows; r++) {
00650         *tempR++= (double) in(r,c).real();
00651         *tempI++= (double) in(r,c).imag();
00652       }
00653     }
00654 
00655   }
00656 
00657   void mxArray2Csvec(const mxArray *in, short *out)
00658   {
00659     double* temp = (double*) mxGetPr(in);
00660     if (temp==0) mexErrMsgTxt("mxArray2Csvec: Pointer to data is NULL");
00661     int size = mxGetNumberOfElements(in);
00662     if (size==0) mexErrMsgTxt("mxArray2Csvec: Size of data is zero");
00663     for (int i=0; i<size; i++) { out[i] = (short) (*temp++); }
00664   }
00665 
00666   void mxArray2Civec(const mxArray *in, int *out)
00667   {
00668     double* temp = (double*) mxGetPr(in);
00669     if (temp==0) mexErrMsgTxt("mxArray2Civec: Pointer to data is NULL");
00670     int size = mxGetNumberOfElements(in);
00671     if (size==0) mexErrMsgTxt("mxArray2Civec: Size of data is zero");
00672     for (int i=0; i<size; i++) { out[i] = (int) (*temp++); }
00673   }
00674 
00675   void mxArray2Cvec(const mxArray *in, double *out)
00676   {
00677     double* temp = (double*) mxGetPr(in);
00678     if (temp==0) mexErrMsgTxt("mxArray2Cvec: Pointer to data is NULL");
00679     int size = mxGetNumberOfElements(in);
00680     if (size==0) mexErrMsgTxt("mxArray2Cvec: Size of data is zero");
00681     for (int i=0; i<size; i++) { out[i] = (*temp++); }
00682   }
00683 
00684   void mxArray2Ccvec(const mxArray *in, double *out_real, double *out_imag)
00685   {
00686     double* tempR = (double*) mxGetPr(in);
00687     double* tempI = (double*) mxGetPi(in);
00688     if (tempR==0) mexErrMsgTxt("mxArray2Ccvec: Pointer to real valued part is NULL");
00689     if (tempI==0) mexErrMsgTxt("mxArray2Ccvec: Pointer to imaginary valued part is NULL");
00690     int size = mxGetNumberOfElements(in);
00691     if (size==0) mexErrMsgTxt("mxArray2Ccvec: Size of data is zero");
00692     for (int i=0; i<size; i++) { out_real[i] = (*tempR++); out_imag[i] = (*tempI++); }
00693   }
00694 
00695   void mxArray2Csmat(const mxArray *in, short **out)
00696   {
00697     int r, c;
00698     double* temp = (double*) mxGetPr(in);
00699     if (temp==0) mexErrMsgTxt("mxArray2Csmat: Pointer to data is NULL");
00700     int rows = mxGetM(in);
00701     if (rows==0) mexErrMsgTxt("mxArray2Csmat: Data has zero rows");
00702     int cols = mxGetN(in);
00703     if (cols==0) mexErrMsgTxt("mxArray2Csmat: Data has zero columns");
00704     for (c=0; c<cols; c++) {
00705       for (r=0; r<rows; r++) {
00706         out[r][c] = (short) (*temp++);    
00707       }
00708     }
00709   }
00710 
00711   void mxArray2Cimat(const mxArray *in, int **out)
00712   {
00713     int r, c;
00714     double* temp = (double*) mxGetPr(in);
00715     if (temp==0) mexErrMsgTxt("mxArray2Cimat: Pointer to data is NULL");
00716     int rows = mxGetM(in);
00717     if (rows==0) mexErrMsgTxt("mxArray2Cimat: Data has zero rows");
00718     int cols = mxGetN(in);
00719     if (cols==0) mexErrMsgTxt("mxArray2Cimat: Data has zero columns");
00720     for (c=0; c<cols; c++) {
00721       for (r=0; r<rows; r++) {
00722         out[r][c] = (int) (*temp++);    
00723       }
00724     }
00725   }
00726 
00727   void mxArray2Cmat(const mxArray *in, double **out)
00728   {
00729     int r, c;
00730     double* temp = (double*) mxGetPr(in);
00731     if (temp==0) mexErrMsgTxt("mxArray2Cmat: Pointer to data is NULL");
00732     int rows = mxGetM(in);
00733     if (rows==0) mexErrMsgTxt("mxArray2Cmat: Data has zero rows");
00734     int cols = mxGetN(in);
00735     if (cols==0) mexErrMsgTxt("mxArray2Cmat: Data has zero columns");
00736     for (c=0; c<cols; c++) {
00737       for (r=0; r<rows; r++) {
00738         out[r][c] = (*temp++);    
00739       }
00740     }
00741   }
00742 
00743   void mxArray2Ccmat(const mxArray *in, double **out_real, double **out_imag)
00744   {
00745     int r, c;
00746     double* tempR = (double*) mxGetPr(in);
00747     double* tempI = (double*) mxGetPi(in);
00748     if (tempR==0) mexErrMsgTxt("mxArray2Cmat: Pointer to real valued part is NULL");
00749     if (tempI==0) mexErrMsgTxt("mxArray2Cmat: Pointer to imaginary valued part is NULL");
00750     int rows = mxGetM(in);
00751     if (rows==0) mexErrMsgTxt("mxArray2Cmat: Data has zero rows");
00752     int cols = mxGetN(in);
00753     if (cols==0) mexErrMsgTxt("mxArray2Cmat: Data has zero columns");
00754     for (c=0; c<cols; c++) {
00755       for (r=0; r<rows; r++) {
00756         out_real[r][c] = (*tempR++);    
00757         out_imag[r][c] = (*tempI++);    
00758       }
00759     }
00760   }
00761 
00762   void Csvec2mxArray(short *in, mxArray *out)
00763   {
00764     double* temp = (double *) mxGetPr(out);
00765     if (temp==0) mexErrMsgTxt("Csvec2mxArray: Pointer to data is NULL");
00766     int size = mxGetNumberOfElements(out);
00767     if (size==0) mexErrMsgTxt("Csvec2mxArray: Size of data is zero");
00768     for(int i=0; i<size; i++) { *temp++= (double) in[i]; }
00769   }
00770 
00771   void Civec2mxArray(int *in, mxArray *out)
00772   {
00773     double* temp = (double *) mxGetPr(out);
00774     if (temp==0) mexErrMsgTxt("Civec2mxArray: Pointer to data is NULL");
00775     int size = mxGetNumberOfElements(out);
00776     if (size==0) mexErrMsgTxt("Civec2mxArray: Size of data is zero");
00777     for(int i=0; i<size; i++) { *temp++= (double) in[i]; }
00778   }
00779 
00780   void Cvec2mxArray(double *in, mxArray *out)
00781   {
00782     double* temp = (double *) mxGetPr(out);
00783     if (temp==0) mexErrMsgTxt("Cvec2mxArray: Pointer to data is NULL");
00784     int size = mxGetNumberOfElements(out);
00785     if (size==0) mexErrMsgTxt("Cvec2mxArray: Size of data is zero");
00786     for(int i=0; i<size; i++) { *temp++= in[i]; }
00787   }
00788 
00789   void Ccvec2mxArray(double *in_real, double *in_imag, mxArray *out)
00790   {
00791     double* tempR = (double *) mxGetPr(out);
00792     double* tempI = (double *) mxGetPi(out);
00793     if (tempR==0) mexErrMsgTxt("Ccvec2mxArray: Pointer to real valued part is NULL");
00794     if (tempI==0) mexErrMsgTxt("Ccvec2mxArray: Pointer to imaginary valued part is NULL");
00795     int size = mxGetNumberOfElements(out);
00796     if (size==0) mexErrMsgTxt("Ccvec2mxArray: Size of data is zero");
00797     for(int i=0; i<size; i++) { *tempR++= in_real[i]; *tempI++= in_imag[i]; }
00798   }
00799 
00800   void Csmat2mxArray(short **in, mxArray *out)
00801   {
00802     int r, c;
00803     double* temp = (double *) mxGetPr(out);
00804     if (temp==0) mexErrMsgTxt("Csmat2mxArray: Pointer to data is NULL");
00805     int rows = mxGetM(out);
00806     if (rows==0) mexErrMsgTxt("Csmat2mxArray: Data has zero rows");
00807     int cols = mxGetN(out);
00808     if (cols==0) mexErrMsgTxt("Csmat2mxArray: Data has zero columns");
00809     for(c=0; c<cols; c++) {
00810       for(r=0; r<rows; r++) {
00811         *temp++= (short) in[r][c];
00812       }
00813     }
00814   }
00815 
00816   void Cimat2mxArray(int **in, mxArray *out)
00817   {
00818     int r, c;
00819     double* temp = (double *) mxGetPr(out);
00820     if (temp==0) mexErrMsgTxt("Cimat2mxArray: Pointer to data is NULL");
00821     int rows = mxGetM(out);
00822     if (rows==0) mexErrMsgTxt("Cimat2mxArray: Data has zero rows");
00823     int cols = mxGetN(out);
00824     if (cols==0) mexErrMsgTxt("Cimat2mxArray: Data has zero columns");
00825     for(c=0; c<cols; c++) {
00826       for(r=0; r<rows; r++) {
00827         *temp++= (int) in[r][c];
00828       }
00829     }
00830   }
00831 
00832   void Cmat2mxArray(double **in, mxArray *out)
00833   {
00834     int r, c;
00835     double* temp = (double *) mxGetPr(out);
00836     if (temp==0) mexErrMsgTxt("Cmat2mxArray: Pointer to data is NULL");
00837     int rows = mxGetM(out);
00838     if (rows==0) mexErrMsgTxt("Cmat2mxArray: Data has zero rows");
00839     int cols = mxGetN(out);
00840     if (cols==0) mexErrMsgTxt("Cmat2mxArray: Data has zero columns");
00841     for(c=0; c<cols; c++) {
00842       for(r=0; r<rows; r++) {
00843         *temp++= in[r][c];
00844       }
00845     }
00846   }
00847 
00848   void Ccmat2mxArray(double **in_real, double **in_imag, mxArray *out)
00849   {
00850     int r, c;
00851     double* tempR = (double *) mxGetPr(out);
00852     double* tempI = (double *) mxGetPi(out);
00853     if (tempR==0) mexErrMsgTxt("Ccmat2mxArray: Pointer to real valued part is NULL");
00854     if (tempI==0) mexErrMsgTxt("Ccmat2mxArray: Pointer to imaginary valued part is NULL");
00855     int rows = mxGetM(out);
00856     if (rows==0) mexErrMsgTxt("Ccmat2mxArray: Data has zero rows");
00857     int cols = mxGetN(out);
00858     if (cols==0) mexErrMsgTxt("Ccmat2mxArray: Data has zero columns");
00859     for(c=0; c<cols; c++) {
00860       for(r=0; r<rows; r++) {
00861         *tempR++= in_real[r][c];
00862         *tempI++= in_imag[r][c];
00863       }
00864     }
00865   }
00866 
00867 } // namespace itpp
00868 
00869 #endif // #ifndef ITMEX_H
SourceForge Logo

Generated on Wed Mar 21 12:21:48 2007 for IT++ by Doxygen 1.4.7