JSOC_Documentation: proj/mag/harp/libs/matlab/mex/src/mex2c/mex.h Source File

00001 /*
00002  * mex.h
00003  * 
00004  * These are C replacements for mex data structures.  This allows
00005  * functions written for compilation and execution
00006  * under the mex environment to be used standalone from C, 
00007  * without the rest of the matlab environment.
00008  *
00009  * This file must be a direct replacement for the file
00010  * .../matlab/extern/include/mex.h
00011  *
00012  * version 3, Michael Turmon, 1999
00013  * version 4, Michael Turmon, 2002
00014  * version 4.1, Michael Turmon, 2003 (for matlab r13/v6.5)
00015  * version 5.0, Michael Turmon, 2008, add Python/numpy, light updates for v7
00016  * version 5.1, turmon, 2009, remove some matlab-specific mimicry
00017  * use mwSize, etc., for large arrays, Michael Turmon, 2010 (matlab R2009b)
00018  */
00019 
00020 #ifndef _mex_h_
00021 #define _mex_h_
00022 
00023 #define USING_MEX2C /* so applications can determine environment */
00024 
00025 /*
00026  * Python.h must be included before anything else.
00027  * mexfiles must include this mex.h *first*
00028  */
00029 #ifdef USING_MEX2PY
00030 #define PY_ARRAY_UNIQUE_SYMBOL mex2py_ARRAY_API
00031 #include "Python.h"
00032 #include "arrayobject.h"
00033 #endif
00034 
00035 #ifdef __cplusplus
00036 extern "C" {
00037 #ifdef NOT_DEFINED
00038 } /* fool emacs */
00039 #endif
00040 #endif
00041 
00042 /* mathworks mex.h includes these; for consistency, so do we */
00043 #include <limits.h>   
00044 #include <stddef.h>   /* size_t, ptrdiff_t */
00045 #include <stdlib.h>   /* alloc, free */
00046 #include <stdio.h>    /* for printf() below */
00047 #include <assert.h>   /* for assert() below */
00048 #include <float.h>    /* for DBL_EPSILON and other IEEE f.p. below */
00049 #include <math.h>     /* ditto */
00050 
00051 /* need functions/global variables to be static 
00052  * when compiling against mex2py (and anything else offering 
00053  * multi-mexfunction integration) because of namespace conflicts 
00054  * among multiple mex2* modules.  mex2c_cli does not have that issue, 
00055  * so here we just define StaticP to empty.
00056  * mnemonic: static or not-static = StaticP as in Lisp predicates
00057  */
00058 #ifdef USING_MEX2PY
00059 /* hook at end, used by mex2py to include methods table there */
00060 #define MEX2C_TAIL_HOOK 
00061 /* need certain things to be static when compiling against mex2py 
00062  * because of namespace conflicts among multiple mex2py modules */
00063 #define StaticP static
00064 #else /* !USING_MEX2PY */
00065 /* allow an external definition for StaticP to override */
00066 #ifndef StaticP
00067 #define StaticP
00068 #endif /* ifndef */
00069 #endif
00070 
00071 /*
00072  * constants
00073  */
00074 
00075 #define mxMAXNAM 64  /* same as matlab v6 thru v7 */
00076 
00077 /*
00078  * types, shadowing matlab
00079  */
00080 
00081 /* boolean abstraction */
00082 #if defined(NO_BUILT_IN_SUPPORT_FOR_BOOL)
00083 typedef unsigned char bool;
00084 #ifndef false
00085 #define false (0)
00086 #endif
00087 #ifndef true 
00088 #define true (1)
00089 #endif
00090 #else  /* defined(NO_BUILT_IN_SUPPORT_FOR_BOOL) */
00091 #include <stdbool.h> /* typical case */
00092 #endif /* defined(NO_BUILT_IN_SUPPORT_FOR_BOOL) */
00093 
00094 typedef bool mxLogical;
00095 
00096 /* indexing abstractions */
00097 #define MX_COMPAT_32  /* undef for large (>2G) arrays, cf -largeArrayDims */
00098 #ifdef MX_COMPAT_32
00099 typedef int mwSize;
00100 typedef int mwIndex;
00101 typedef int mwSignedIndex;
00102 #else
00103 typedef size_t    mwSize;
00104 typedef size_t    mwIndex;
00105 typedef ptrdiff_t mwSignedIndex; /* when you need a signed type */
00106 #endif
00107 
00108 /* character abstraction */
00109 #ifdef USING_MEX2PY
00110 /* numpy stores its string type as char's */
00111 typedef char mxChar;
00112 #else /* !USING_MEX2PY */
00113 typedef unsigned short mxChar; /* follow matlab: use a short int */
00114 #endif
00115 
00116 typedef enum {
00117   mxUNKNOWN_CLASS = 0,
00118   mxCELL_CLASS = 1,
00119   mxSTRUCT_CLASS,
00120   mxLOGICAL_CLASS,  /* new at r13 */
00121   mxCHAR_CLASS,
00122   mxSPARSE_CLASS,   /* obsolete by r13 */
00123   mxDOUBLE_CLASS,
00124   mxSINGLE_CLASS,
00125   mxINT8_CLASS,
00126   mxUINT8_CLASS,
00127   mxINT16_CLASS,
00128   mxUINT16_CLASS,
00129   mxINT32_CLASS,
00130   mxUINT32_CLASS,
00131   mxINT64_CLASS,
00132   mxUINT64_CLASS,
00133   mxFUNCTION_CLASS,
00134   mxOPAQUE_CLASS,
00135   mxOBJECT_CLASS
00136 } mxClassID;
00137 
00138 typedef enum {
00139     mxREAL,
00140     mxCOMPLEX
00141 } mxComplexity;
00142 
00143 /*
00144  * fundamental array data structure 
00145  */
00146 #ifdef USING_MEX2PY
00147 
00148 #define mxArray PyArrayObject /* for mex2py, it's easy */
00149 
00150 #else /* !USING_MEX2PY */
00151 
00152 /* this defintion is recursive */
00153 struct _mxA {
00154   /* bookkeeping */
00155   mxClassID     tag;   /* class of contents: controls data union below */
00156   bool    sparse;      /* attribute: applies various content classes above */
00157   /* note: no fields are set up for the other sparse machinery */
00158   mwSize  ndim;        /* number of dimensions */
00159   mwSize *dims;        /* size of each dimension */
00160   mwSize  M;           /* dims[0] as a shortcut */
00161   mwSize  N;           /* prod_{1..d-1} dims[i] as a shortcut */
00162   mwSize  Nelem;       /* prod(dims) as a shortcut */
00163   /* extra info for mex2c */
00164   double  datamin;     /* data range -- for FITS output */
00165   double  datamax;
00166   /* data pointers, variant depending on tag above */
00167   /* note: no variants for function handles and opaques because
00168    * there are no mx* functions using them yet */
00169   union { 
00170     struct {               /* numeric array */
00171       void *pr;            /* real data */
00172       void *pi;            /* imag data */
00173     } numA;
00174     struct {               /* char array */
00175       mxChar *pc;          /* char data */
00176     } charA;
00177     struct {               /* logical array */
00178       mxLogical *pl;       /* logical data */
00179     } logA;
00180     struct {               /* struct array */
00181       struct _mxA **ps;    /* structure data */
00182       char **fname;        /* field names */
00183       int nfield;          /* number of fields (always int) */
00184     } structA;
00185     struct {               /* cell array */
00186       struct _mxA **pc;    /* cell data */
00187     } cellA;
00188   } data;
00189 };
00190 
00191 /* the actual type name as used */
00192 typedef struct _mxA mxArray;
00193 
00194 #endif /* USING_MEX2PY */
00195 
00196 
00197 #ifdef USING_MEX2PY
00198 /* Declaration for the C-API entry point
00199  * This is a convenience for use in the per-mexfunction glue file.
00200  */
00201 /* this is an abbreviation for clarity here, not to be used elsewhere */
00202 typedef void (mexfn_t_abbrev)(int, mxArray **, int , const mxArray **);
00203 
00204 PyObject *mx_entry(mexfn_t_abbrev *, PyObject *, PyObject *,
00205            int, int, int, int, 
00206                    const char **, const char **, const char **);
00207 #endif
00208 
00209 /*
00210  * Old version compatibility has been removed.
00211  * These V4/V5 functions are here #defined away from their
00212  * target functions.  This results in a compile error.  
00213  */
00214 #define mxIsFull()         mxIsFull_is_obsolete
00215 #define mxCreateFull()     mxCreateFull_is_obsolete
00216 #define mxIsString()       mxIsString_is_obsolete
00217 #define mxFreeMatrix()     mxFreeMatrix_is_obsolete
00218 #define mxSetLogical()     mxSetLogical_is_obsolete
00219 #define mxClearLogical()   mxClearLogical_is_obsolete
00220 #define mxSetName()        mxSetName_is_obsolete
00221 #define mxGetName()        mxGetName_is_obsolete
00222 
00223 /*
00224  * mexPrintf and mxAssert's, as #defines 
00225  */
00226 #define mexPrintf printf
00227 #define mxAssert(expr,msg)  assert(expr)
00228 #define mxAssertS(expr,msg) assert(expr)
00229 
00230 /*
00231  * function prototypes
00232  *
00233  * functions that were introduced in later versions
00234  * are defined for earlier versions anyway, to encourage migration
00235  */
00236 
00237 void    mexErrMsgTxt( const char *error_msg); 
00238 void    mexWarnMsgTxt(const char *error_msg); 
00239 int     mexEvalString(const char *string); 
00240 int     mexCallMATLAB(int nlhs, mxArray *plhs[], int nrhs, 
00241               mxArray *prhs[], const char *name); 
00242 void    mexLock(void);
00243 void    mexUnlock(void);
00244 bool    mexIsLocked(void);
00245 int     mexAtExit(void (*exit_fcn)(void)); /* NI */
00246 
00247 StaticP 
00248 void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]); 
00249 const char *mexFunctionName(void); 
00250 int mexPutArray(mxArray *pa, const char *ws);
00251 int mexPutVariable(const char *workspace, const char *name, const mxArray *parray);
00252 /* NB: most mex* functions have been omitted for brevity */
00253 
00254 /* memory */
00255 void *mxMalloc(size_t n);
00256 void *mxCalloc(size_t n, size_t size);
00257 void  mxFree(void *ptr);
00258 void *mxRealloc(void *ptr, size_t size);
00259 /* get/set attribute */
00260 mxClassID mxGetClassID(const mxArray *pa);
00261 void    *mxGetData(const mxArray *pa);
00262 void     mxSetData(mxArray *pa, void *newdata);
00263 void    *mxGetImagData(const mxArray *pa);
00264 void     mxSetImagData(mxArray *pa, void *newdata);
00265 double  *mxGetPi(const mxArray *pm);
00266 double  *mxGetPr(const mxArray *pm);
00267 void     mxSetPi(mxArray *pm, double *pi);
00268 void     mxSetPr(mxArray *pm, double *pr);
00269 /* get contents */
00270 double   mxGetScalar(const mxArray *pm); 
00271 int      mxGetString(const mxArray *pa, char *buf, mwSize buflen); 
00272 mxChar  *mxGetChars(const mxArray *pa);      /* get data, for chars */
00273 mxLogical *mxGetLogicals(const mxArray *pa); /* get data, for logicals */
00274 /* get/set sizes */
00275 size_t   mxGetM(const mxArray *pm); /* matlab does use size_t here */
00276 size_t   mxGetN(const mxArray *pm);
00277 void     mxSetM(mxArray *pm, mwSize m);
00278 void     mxSetN(mxArray *pm, mwSize n);
00279 mwSize   mxGetNumberOfDimensions(const mxArray *pa);
00280 const mwSize *mxGetDimensions(const mxArray *pa);
00281 int      mxSetDimensions(mxArray *pa, const mwSize *size, mwSize ndims);
00282 size_t   mxGetNumberOfElements(const mxArray *pa); /* is size_t */
00283 size_t   mxGetElementSize(const mxArray *pa);
00284 mwIndex  mxCalcSingleSubscript(const mxArray *pa, mwSize nsubs, const mwIndex *subs);
00285 /* get/set sparse */
00286 mwIndex *mxGetIr(const mxArray *pa);           /* NI */
00287 void     mxSetIr(mxArray *pa, mwIndex *newir); /* NI */
00288 mwIndex *mxGetJc(const mxArray *pa);           /* NI */
00289 void     mxSetJc(mxArray *pa, mwIndex *newjc); /* NI */
00290 mwSize   mxGetNzmax(const mxArray *pa);        /* NI */
00291 void     mxSetNzmax(mxArray *pa, mwSize nzmax);/* NI */
00292 /* get/set structs and cells.  field numbers are int's. */
00293 mxArray *mxGetCell(const mxArray *pa, mwIndex i);           /* NI */
00294 void     mxSetCell(mxArray *pa, mwIndex i, mxArray *value); /* NI */
00295 int      mxGetNumberOfFields(const mxArray *pa);            /* NI */
00296 int      mxGetFieldNumber(const mxArray *pa, const char *name);        /* NI */
00297 mxArray *mxGetFieldByNumber(const mxArray *pa, mwIndex i, int f);      /* NI */
00298 void     mxSetFieldByNumber(mxArray *pa,mwIndex i,int f, mxArray *val);/* NI */
00299 mxArray *mxGetField(const mxArray *pa, mwIndex i, const char *f);      /* NI */
00300 void     mxSetField(mxArray *pa,mwIndex i,const char *f,mxArray *val); /* NI */
00301 const char *mxGetFieldNameByNumber(const mxArray *pa, int f);          /* NI */
00302 const char *mxGetClassName(const mxArray *pa);                         /* NI */
00303 int      mxSetClassName(mxArray *pa, const char *classname);           /* NI */
00304 int      mxAddField(mxArray *pa, const char *fieldname);               /* NI */
00305 void     mxRemoveField(mxArray *pa, int fnum);                         /* NI */
00306 /* get/set objects */
00307 mxArray *mxGetProperty(const mxArray *pa, mwIndex i, const char *name);/* NI */
00308 void     mxSetProperty(mxArray *pa, mwIndex i, const char *name, const mxArray *val); /* NI */
00309 
00310 bool     mxIsFromGlobalWS(const mxArray *pa);
00311 bool     mxIsEmpty(  const mxArray *pa); 
00312 bool     mxIsComplex(const mxArray *pa); 
00313 bool     mxIsDouble( const mxArray *pa); 
00314 bool     mxIsSparse( const mxArray *pa); 
00315 bool     mxIsNumeric(const mxArray *pa); 
00316 bool     mxIsChar(   const mxArray *pa); 
00317 bool     mxIsCell(   const mxArray *pa);
00318 bool     mxIsStruct( const mxArray *pa);
00319 bool     mxIsOpaque( const mxArray *pa);
00320 bool     mxIsFunctionHandle(const mxArray *pa);
00321 bool     mxIsObject( const mxArray *pa);
00322 bool     mxIsClass(const mxArray *pa, const char *name); /* NI */
00323 bool     mxIsSingle( const mxArray *pa);
00324 bool     mxIsLogical(const mxArray *pa);
00325 bool     mxIsLogicalScalar(const mxArray *pa);
00326 bool     mxIsLogicalScalarTrue(const mxArray *pa);
00327 bool     mxIsInt8(   const mxArray *pa);
00328 bool     mxIsUint8(  const mxArray *pa);
00329 bool     mxIsInt16(  const mxArray *pa);
00330 bool     mxIsUint16( const mxArray *pa);
00331 bool     mxIsInt32(  const mxArray *pa);
00332 bool     mxIsUint32( const mxArray *pa);
00333 bool     mxIsInt64(  const mxArray *pa);
00334 bool     mxIsUint64( const mxArray *pa);
00335 
00336 /* creation, copying, destruction of mxArray's */
00337 mxArray *mxCreateNumericArray(mwSize n, const mwSize *dims, mxClassID id, mxComplexity f);
00338 mxArray *mxCreateNumericMatrix(mwSize m, mwSize n, mxClassID classid, mxComplexity f);
00339 mxArray *mxCreateDoubleMatrix (mwSize m, mwSize n, mxComplexity f);
00340 mxArray *mxCreateDoubleScalar(double value);
00341 #define mxCreateScalarDouble(d) mxCreateDoubleScalar(d)
00342 mxArray *mxCreateSparse(mwSize m, mwSize n, mwSize nzmax, mxComplexity f); /* NI */
00343 mxArray *mxCreateSparseLogicalMatrix(mwSize m, mwSize n, mwSize nzmax); /* NI */
00344 mxArray *mxCreateLogicalArray(mwSize ndim, const mwSize *dims);
00345 mxArray *mxCreateLogicalMatrix(mwSize m, mwSize n);
00346 mxArray *mxCreateLogicalScalar(mxLogical value);
00347 char    *mxArrayToString(const mxArray *pa);
00348 mxArray *mxCreateString(const char *str); 
00349 mxArray *mxCreateCharArray(mwSize ndim, const mwSize *dims);
00350 mxArray *mxCreateCharMatrixFromStrings(mwSize m, const char **str);
00351 mxArray *mxCreateCellMatrix(mwSize m, mwSize n); /* NI */
00352 mxArray *mxCreateCellArray(mwSize ndim, const mwSize *dims); /* NI */
00353 mxArray *mxCreateStructMatrix(mwSize m, mwSize n,int nf,const char **names); /* NI */
00354 mxArray *mxCreateStructArray(mwSize nd, const mwSize *dims, int nf, const char **names); /* NI */
00355 mxArray *mxDuplicateArray(const mxArray *in);
00356 void     mxDestroyArray(mxArray *pa); 
00357 
00358 /* IEEE floating point */
00359 #define mxGetEps() DBL_EPSILON /* in float.h */
00360 #define mxGetInf getinfd  /* in ieee_consts.c -> libmextools.a */
00361 #define mxGetNaN getnand  /* in ieee_consts.c -> libmextools.a */
00362 #define mxIsFinite finite
00363 #define mxIsInf(x) (!finite(x)) 
00364 #define mxIsNaN isnan     /* in math.h */
00365 int finite(double dsrc);  /* location of the declaration varies */
00366 
00367 #ifdef __cplusplus
00368 #ifdef NOT_DEFINED
00369 { /* fool emacs */
00370 #endif
00371 }   /* extern "C" */
00372 #endif
00373 
00374 #endif /* _mex_h_ */
00375