mexaux.hpp

Go to the documentation of this file.
00001 #ifndef _MEXAUX_HPP_
00002 #define _MEXAUX_HPP_
00003 
00004 #include "mex.h"
00005 #include "matrix.h"
00006 
00007 #include "fmm3d.hpp"
00008 
00009 using std::cerr;
00010 using std::endl;
00011 
00012 //int
00013 inline void mex2cpp(const mxArray*& md, int& cd);
00014 inline void cpp2mex(const int& cd, mxArray*& md);
00015 //bool
00016 inline void mex2cpp(const mxArray*& md, bool& cd);
00017 inline void cpp2mex(const bool& cd, mxArray*& md);
00018 //double
00019 inline void mex2cpp(const mxArray*& md, double& cd);
00020 inline void cpp2mex(const double& cd, mxArray*& md);
00021 //dblnummat
00022 inline void mex2cpp(const mxArray*& md, DblNumMat& cd);
00023 inline void cpp2mex(const DblNumMat& cd, mxArray*& md);
00024 //dblnumvec
00025 inline void mex2cpp(const mxArray*& md, DblNumVec& cd);
00026 inline void cpp2mex(const DblNumVec& cd, mxArray*& md);
00027 //point3
00028 inline void mex2cpp(const mxArray*& md, Point3& cd);
00029 inline void cpp2mex(const Point3& cd, mxArray*& md);
00030 //Kernel3d
00031 inline void mex2cpp(const mxArray*& md, Kernel3d& cd);
00032 inline void cpp2mex(const Kernel3d& cd, mxArray*& md);
00033 //vector<double>
00034 inline void mex2cpp(const mxArray*& md, vector<double>& cd);
00035 inline void cpp2mex(const vector<double>& cd, mxArray*& md);
00036 //vector<T>
00037 template <class T> inline void mex2cpp(const mxArray*& md, vector<T>& cd);
00038 template <class T> inline void cpp2mex(const vector<T>& cd, mxArray*& md);
00039 //NumTns<T>
00040 template <class T> inline void mex2cpp(const mxArray*& md, NumTns<T>& cd);
00041 template <class T> inline void cpp2mex(const NumTns<T>& cd, mxArray*& md);
00042 //OffTns<T>
00043 template <class T> inline void mex2cpp(const mxArray*& md, OffTns<T>& cd);
00044 template <class T> inline void cpp2mex(const OffTns<T>& cd, mxArray*& md);
00045 //map<S,T>
00046 template <class S, class T> inline void mex2cpp(const mxArray*& md, map<S,T>& cd);
00047 template <class S, class T> inline void cpp2mex(const map<S,T>& cd, mxArray*& md);
00048 //matmgnt
00049 inline void mex2cpp(const mxArray*& md, MatMgnt3d& cd);
00050 inline void cpp2mex(const MatMgnt3d& cd, mxArray*& md);
00051 
00052 
00053 //----------------------int
00054 inline void mex2cpp(const mxArray*& md, int& cd)
00055 {
00056   cd = int(mxGetScalar(md));
00057   return;
00058 }
00059 inline void cpp2mex(const int& cd, mxArray*& md)
00060 {
00061   md = mxCreateDoubleScalar(cd);
00062   return;
00063 }
00064 //----------------------int
00065 inline void mex2cpp(const mxArray*& md, bool& cd)
00066 {
00067   cd = bool(mxGetScalar(md));
00068   return;
00069 }
00070 inline void cpp2mex(const bool& cd, mxArray*& md)
00071 {
00072   md = mxCreateDoubleScalar(cd);
00073   return;
00074 }
00075 //----------------------double
00076 inline void mex2cpp(const mxArray*& md, double& cd)
00077 {
00078   cd = mxGetScalar(md);
00079   return;
00080 }
00081 inline void cpp2mex(const double& cd, mxArray*& md)
00082 {
00083   md = mxCreateDoubleScalar(cd);
00084   return;
00085 }
00086 //----------------------DblNumMat
00087 inline void mex2cpp(const mxArray*& md, DblNumMat& cd)
00088 {
00089   int m = mxGetM(md);
00090   int n = mxGetN(md);
00091   double* xr = mxGetPr(md);
00092   cd.resize(m,n);
00093   int cnt = 0;
00094   for(int j=0; j<n; j++)
00095          for(int i=0; i<m; i++) {
00096                 cd(i,j) = xr[cnt];
00097                 cnt++;
00098          }
00099   return;
00100 }
00101 inline void cpp2mex(const DblNumMat& cd, mxArray*& md)
00102 {
00103   int m = cd.m();
00104   int n = cd.n();
00105   md = mxCreateDoubleMatrix(m, n, mxREAL);
00106   double* xr = mxGetPr(md);
00107   int cnt = 0;
00108   for(int j=0; j<n; j++)
00109          for(int i=0; i<m; i++) {
00110                 xr[cnt] = cd(i,j);
00111                 cnt++;
00112          }
00113   return;
00114 }
00115 //----------------------dblnumvec
00116 inline void mex2cpp(const mxArray*& md, DblNumVec& cd)
00117 {
00118   int m = mxGetM(md);
00119   int n = mxGetN(md); iA(n==1);
00120   double* xr = mxGetPr(md);
00121   cd.resize(m);
00122   for(int i=0; i<m; i++)
00123          cd(i) = xr[i];
00124   return;
00125 }
00126 inline void cpp2mex(const DblNumVec& cd, mxArray*& md)
00127 {
00128   int m = cd.m();
00129   md = mxCreateDoubleMatrix(m, 1, mxREAL);
00130   double* xr = mxGetPr(md);
00131   for(int i=0; i<m; i++)
00132          xr[i] = cd(i);
00133   return;
00134 }
00135 //----------------------Point3
00136 inline void mex2cpp(const mxArray*& md, Point3& cd)
00137 {
00138   int m = mxGetM(md);
00139   int n = mxGetN(md);  iA(m==3 && n==1);
00140   double* xr = mxGetPr(md);
00141   cd = Point3(xr[0], xr[1], xr[2]);
00142   return;
00143 }
00144 inline void cpp2mex(const Point3& cd, mxArray*& md)
00145 {
00146   md = mxCreateDoubleMatrix(3, 1, mxREAL);
00147   double* xr = mxGetPr(md);
00148   xr[0] = cd(0);  xr[1] = cd(1);  xr[2] = cd(2);
00149   return;
00150 }
00151 //----------------------Kernel3d
00152 inline void mex2cpp(const mxArray*& md, Kernel3d& cd)
00153 {
00154   int m = mxGetM(md); iA(m==2);
00155   int n = mxGetN(md); iA(n==1);  //cerr<<m<<" "<<n<<endl;
00156   { const mxArray* tt = mxGetCell(md, 0);  mex2cpp(tt, cd.kt()); }
00157   { const mxArray* tt = mxGetCell(md, 1);  mex2cpp(tt, cd.coefs()); }
00158   return;
00159 }
00160 inline void cpp2mex(const Kernel3d& cd, mxArray*& md)
00161 {
00162   int m = 2;
00163   int n = 1;
00164   md = mxCreateCellMatrix(m,n);
00165   mxArray* ss;
00166   cpp2mex(cd.kt(), ss);  mxSetCell(md, 0, ss);
00167   cpp2mex(cd.coefs(), ss);  mxSetCell(md, 1, ss);
00168   return;
00169 }
00170 //----------------------vector<double>
00171 inline void mex2cpp(const mxArray*& md, vector<double>& cd)
00172 {
00173   int m = mxGetM(md);
00174   int n = mxGetN(md); iA(n==1);  //cerr<<m<<"   "<<n<<endl;
00175   double* xr = mxGetPr(md);
00176   cd.resize(m*n);
00177   for(int i=0; i<m*n; i++)
00178          cd[i] = xr[i];
00179   return;
00180 }
00181 inline void cpp2mex(const vector<double>& cd, mxArray*& md)
00182 {
00183   int m = cd.size();
00184   int n = 1;
00185   md = mxCreateDoubleMatrix(m, n, mxREAL);
00186   double* xr = mxGetPr(md);
00187   for(int i=0; i<m*n; i++)
00188          xr[i] = cd[i];
00189   return;
00190 }
00191 //----------------------vector<...>
00192 template <class T> inline void mex2cpp(const mxArray*& md, vector<T>& cd)
00193 {
00194   int m = mxGetM(md);
00195   int n = mxGetN(md);  assert(n==1);
00196   cd.resize(m*n);
00197   for(int ci=0; ci<m*n; ci++) {
00198          const mxArray*tt = mxGetCell(md, ci);
00199          mex2cpp(tt, cd[ci]);
00200   }
00201   return;
00202 }
00203 template <class T> inline void cpp2mex(const vector<T>& cd, mxArray*& md)
00204 {
00205   int n = cd.size();
00206   md = mxCreateCellMatrix(n, 1);
00207   for(int ci=0; ci<n; ci++) {
00208          mxArray* ss;    cpp2mex(cd[ci], ss);
00209          mxSetCell(md, ci, ss);
00210   }
00211   return;
00212 }
00213 //----------------------numtns<...>
00214 template <class T> inline void mex2cpp(const mxArray*& md, NumTns<T>& cd)
00215 {
00216   const int* dims = mxGetDimensions(md);
00217   int m = dims[0];  int n = dims[1];  int p = dims[2];
00218   cd.resize(m,n,p);
00219   int cnt = 0;
00220   for(int k=0; k<p; k++)
00221          for(int j=0; j<n; j++)
00222                 for(int i=0; i<m; i++) {
00223                   const mxArray* tt = mxGetCell(md, cnt);                 mex2cpp(tt, cd(i,j,k));
00224                   cnt++;
00225                 }
00226   return;
00227 }
00228 template <class T> inline void cpp2mex(const NumTns<T>& cd, mxArray*& md)
00229 {
00230   int m = cd.m();
00231   int n = cd.n();
00232   int p = cd.p();
00233   int dims[3];  dims[0] = m;  dims[1] = n;  dims[2] = p;
00234   md = mxCreateCellArray(3,dims);
00235   int cnt = 0;
00236   for(int k=0; k<p; k++)
00237          for(int j=0; j<n; j++)
00238                 for(int i=0; i<m; i++) {
00239                   mxArray* ss;          cpp2mex(cd(i,j,k), ss);         mxSetCell(md, cnt, ss);
00240                   cnt++;
00241                 }
00242   return;
00243 }
00244 //----------------------offtns<...>
00245 template <class T> inline void mex2cpp(const mxArray*& md, OffTns<T>& cd)
00246 {
00247   const int* dims = mxGetDimensions(md);
00248   int m = dims[0];  int n = dims[1];  int p = dims[2];
00249   int s = -m/2;  int t = -n/2;  int u = -p/2;
00250   cd.resize(m,n,p,s,t,u);
00251   int cnt = 0;
00252   for(int k=u; k<u+p; k++)
00253          for(int j=t; j<t+n; j++)
00254                 for(int i=s; i<s+m; i++) {
00255                   const mxArray* tt = mxGetCell(md, cnt);                 mex2cpp(tt, cd(i,j,k));
00256                   cnt++;
00257                 }
00258   return;
00259 }
00260 template <class T> inline void cpp2mex(const OffTns<T>& cd, mxArray*& md)
00261 {
00262   int m = cd.m();  int n = cd.n();  int p = cd.p();
00263   int s = -m/2;  int t = -n/2;  int u = -p/2;
00264   int dims[3];  dims[0] = m;  dims[1] = n;  dims[2] = p;
00265   md = mxCreateCellArray(3,dims);
00266   int cnt = 0;
00267   for(int k=u; k<u+p; k++)
00268          for(int j=t; j<t+n; j++)
00269                 for(int i=s; i<s+m; i++) {
00270                   mxArray* ss;          cpp2mex(cd(i,j,k), ss);         mxSetCell(md, cnt, ss);
00271                   cnt++;
00272                 }
00273   return;
00274 }
00275 //----------------------map<S,T>
00276 template <class S, class T> inline void mex2cpp(const mxArray*& md, map<S,T>& cd)
00277 {
00278   int m = mxGetM(md);
00279   int n = mxGetN(md);  assert(n==1);
00280   for(int ci=0; ci<m*n; ci++) {
00281          const mxArray* now = mxGetCell(md, ci);
00282          const mxArray* tmp;
00283          S ss;   tmp = mxGetCell(now,0); mex2cpp(tmp, ss);
00284          T tt;   tmp = mxGetCell(now,1); mex2cpp(tmp, tt);
00285          cd[ss] = tt;
00286   }
00287   return;
00288 }
00289 template <class S, class T> inline void cpp2mex(const map<S,T>& cd, mxArray*& md)
00290 {
00291   int n = cd.size();
00292   md = mxCreateCellMatrix(n,1);
00293   int cnt = 0;
00294   for(map<S,T>::const_iterator mi=cd.begin(); mi!=cd.end(); mi++) {
00295          mxArray* now = mxCreateCellMatrix(2,1);
00296          mxArray* ss;    cpp2mex((*mi).first, ss);       mxSetCell(now, 0, ss);
00297          mxArray* tt;    cpp2mex((*mi).second, tt);      mxSetCell(now, 1, tt);
00298          mxSetCell(md, cnt, now);
00299          cnt++;
00300   }
00301   assert(cnt==n);
00302   return;
00303 }
00304 //----------------------matmgnt3d
00305 inline void mex2cpp(const mxArray*& md, MatMgnt3d& cd)
00306 {
00307   const mxArray* tt;
00308   tt = mxGetCell(md,0);  mex2cpp(tt, cd._knl);
00309   tt = mxGetCell(md,1);  mex2cpp(tt, cd._np);
00310   tt = mxGetCell(md,2);  mex2cpp(tt, cd._hom);
00311   tt = mxGetCell(md,3);  mex2cpp(tt, cd._degvec);
00312   tt = mxGetCell(md,4);  mex2cpp(tt, cd._uc2ue);
00313   tt = mxGetCell(md,5);  mex2cpp(tt, cd._ue2uc);
00314   tt = mxGetCell(md,6);  mex2cpp(tt, cd._dc2de);
00315   tt = mxGetCell(md,7);  mex2cpp(tt, cd._de2dc);
00316   tt = mxGetCell(md,8);  mex2cpp(tt, cd._ue2dc);
00317   tt = mxGetCell(md,9);  mex2cpp(tt, cd._splpos[0]);
00318   tt = mxGetCell(md,10); mex2cpp(tt, cd._splpos[1]);
00319   tt = mxGetCell(md,11); mex2cpp(tt, cd._splpos[2]);
00320   tt = mxGetCell(md,12); mex2cpp(tt, cd._splpos[3]);
00321   tt = mxGetCell(md,13); mex2cpp(tt, cd._regpos);
00322   return;
00323 }
00324 inline void cpp2mex(const MatMgnt3d& cd, mxArray*& md)
00325 {
00326   md = mxCreateCellMatrix(1,14);
00327   
00328   mxArray* ss;
00329   cpp2mex(cd._knl, ss);  mxSetCell(md, 0, ss);
00330   cpp2mex(cd._np, ss);  mxSetCell(md, 1, ss);
00331   cpp2mex(cd._hom, ss);  mxSetCell(md, 2, ss);
00332   cpp2mex(cd._degvec, ss);  mxSetCell(md, 3, ss);
00333   cpp2mex(cd._uc2ue, ss);  mxSetCell(md, 4, ss);
00334   cpp2mex(cd._ue2uc, ss);  mxSetCell(md, 5, ss);
00335   cpp2mex(cd._dc2de, ss);  mxSetCell(md, 6, ss);
00336   cpp2mex(cd._de2dc, ss);  mxSetCell(md, 7, ss);
00337   cpp2mex(cd._ue2dc, ss);  mxSetCell(md, 8, ss);
00338   cpp2mex(cd._splpos[0], ss);  mxSetCell(md, 9, ss);
00339   cpp2mex(cd._splpos[1], ss);  mxSetCell(md, 10, ss);
00340   cpp2mex(cd._splpos[2], ss);  mxSetCell(md, 11, ss);
00341   cpp2mex(cd._splpos[2], ss);  mxSetCell(md, 12, ss);
00342   cpp2mex(cd._regpos, ss);  mxSetCell(md, 13, ss);
00343   
00344   return;
00345 }
00346 
00347 
00348 #endif

Generated on Sun Dec 4 19:24:39 2005 for fmm3d by  doxygen 1.4.5