#if defined(ARRAY_ACCESS_INLINING)
#define mxGetPr(pa)             ((double *)mxGetData(pa))
#endif /* defined(ARRAY_ACCESS_INLINING) */


/*
 * Set real data pointer for numeric array
 */
extern void mxSetPr(
    mxArray *pa,		/* pointer to array */
    double  *pr			/* real data array pointer */
    );


/*
 * Get imaginary data pointer for numeric array
 */
extern double *mxGetPi(
    const mxArray *pa		/* pointer to array */
    );


#if defined(ARRAY_ACCESS_INLINING)
#define mxGetPi(pa)             ((double *)mxGetImagData(pa))
#endif /* defined(ARRAY_ACCESS_INLINING) */


/*
 * Set imaginary data pointer for numeric array
 */
extern void mxSetPi(
    mxArray *pa,		/* pointer to array */
    double  *pi			/* imaginary data array pointer */
    );


/*
 * Get string array data
 */
extern mxChar *mxGetChars(
    const mxArray *pa		/* pointer to array */
    );


#if defined(ARRAY_ACCESS_INLINING)
#define mxGetChars(pa)          ((mxChar *)mxGetData(pa))
#endif /* defined(ARRAY_ACCESS_INLINING) */


/*
 * Get 8 bits of user data stored in the mxArray header.  NOTE: This state
 * of these bits are not guaranteed to be preserved after API function
 * calls.
 */
extern int mxGetUserBits(
    const mxArray	*pa		/* pointer to array */
    );


/*
 * Set 8 bits of user data stored in the mxArray header. NOTE: This state
 * of these bits are not guaranteed to be preserved after API function
 * calls.
 */ 
extern void mxSetUserBits(
	mxArray	*pa,		/* pointer to array */
	int	value
    );


#ifdef __WATCOMC__
#ifndef __cplusplus
#pragma aux mxGetScalar value [8087];
#endif
#endif


/*
 * Get the real component of the specified array's first data element.
 */
extern double mxGetScalar(const mxArray *pa);


/*
 * Is the isFromGlobalWorkspace bit set?
 */
extern bool mxIsFromGlobalWS(const mxArray *pa);


/*
 * Set the isFromGlobalWorkspace bit.
 */
extern void mxSetFromGlobalWS(mxArray *pa, bool global);


/*
 * Get number of dimensions in array
 */
extern int mxGetNumberOfDimensions(
    const mxArray *pa		/* pointer to array */
    );


#if defined(ARRAY_ACCESS_INLINING)
#define mxGetNumberOfDimensions(pa)  ((pa)->number_of_dims)
#endif /* defined(ARRAY_ACCESS_INLINING) */


/*
 * Get pointer to dimension array
 */
extern const int *mxGetDimensions(
    const mxArray *pa		/* pointer to array */
    );


/* 
 * Get row dimension
 */
extern int mxGetM(
    const mxArray *pa		/* pointer to array */
    );


/* 
 * Set row dimension
 */
extern void mxSetM(
    mxArray *pa,		/* pointer to array */
    int     m			/* row dimension */
    );


/* 
 * Get column dimension
 */
extern int mxGetN(
    const mxArray *pa		/* pointer to array */
    );


/*
 * Is array empty
 */
extern bool mxIsEmpty(
    const mxArray *pa		/* pointer to array */
    );


/*
 * Get row data pointer for sparse numeric array
 */
extern int *mxGetIr(
    const mxArray *pa		/* pointer to array */
    );


/*
 * Set row data pointer for numeric array
 */
extern void mxSetIr(
    mxArray *pa,		/* pointer to array */
    int     *newir		/* row data array pointer */
    );


/*
 * Get column data pointer for sparse numeric array
 */
extern int *mxGetJc(
    const mxArray *pa		/* pointer to array */
    );


/*
 * Set column data pointer for numeric array
 */
extern void mxSetJc(
    mxArray *pa,		/* pointer to array */
    int     *newjc		/* column data array pointer */
    );


/*
 * Get maximum nonzero elements for sparse numeric array
 */
extern int mxGetNzmax(
    const mxArray *pa		/* pointer to array */
    );


/*
 * Set maximum nonzero elements for numeric array
 */
extern void mxSetNzmax(
    mxArray *pa,		/* pointer to array */
    int     nzmax		/* maximum nonzero elements */
    );


/* 
 * Get number of elements in array
 */
extern int mxGetNumberOfElements(	
    const mxArray *pa		/* pointer to array */
    );


/*
 * Get array data element size
 */
extern int mxGetElementSize(const mxArray *pa);


/* 
 * Return the offset (in number of elements) from the beginning of 
 * the array to a given subscript.  
 */
extern int mxCalcSingleSubscript(const mxArray *pa, int nsubs, const int *subs);


/*
 * Get number of structure fields in array
 */
extern int mxGetNumberOfFields(
    const mxArray *pa		/* pointer to array */
    );


/*
 * Get a pointer to the specified cell element. 
 */ 
extern mxArray *mxGetCell(const mxArray *pa, int i);


/*
 * Set an element in a cell array to the specified value.
 */
extern void mxSetCell(mxArray *pa, int i, mxArray *value);


/*
 * Return pointer to the nth field name
 */
extern const char *mxGetFieldNameByNumber(const mxArray *pa, int n);


/*
 * Get the index to the named field.
 */ 
extern int mxGetFieldNumber(const mxArray *pa, const char *name);


/*
 * Return a pointer to the contents of the named field for 
 * the ith element (zero based).
 */ 
extern mxArray *mxGetFieldByNumber(const mxArray *pa, int i, int fieldnum);


/*
 * Set pa[i][fieldnum] = value 
 */
extern void mxSetFieldByNumber(mxArray *pa, int i, int fieldnum, mxArray *value);


/*
 * Return a pointer to the contents of the named field for the ith 
 * element (zero based).  Returns NULL on no such field or if the
 * field itself is NULL
 */
extern mxArray *mxGetField(const mxArray *pa, int i, const char *fieldname);


/*
 * Set pa[i]->fieldname = value  
 */
extern void mxSetField(mxArray *pa, int i, const char *fieldname, mxArray *value);

 
/* 
 * Return the name of an array's class.  
 */
extern const char *mxGetClassName(const mxArray *pa);


/*
 * Determine whether an array is a member of the specified class. 
 */
extern bool mxIsClass(const mxArray *pa, const char *name);


/*
 * Set scalar double flag
 */
extern void mxSetScalarDoubleFlag(
    mxArray	*pa		/* pointer to array */
    );


#if defined(ARRAY_ACCESS_INLINING)
#define mxSetScalarDoubleFlag(pa) ((pa)->flags.scalar_flag = true)
#endif /* defined(ARRAY_ACCESS_INLINING) */


/*
 * Clear scalar double flag
 */
extern void mxClearScalarDoubleFlag(
    mxArray	*pa		/* pointer to array */
    );


#if defined(ARRAY_ACCESS_INLINING)
#define mxClearScalarDoubleFlag(pa) ((pa)->flags.scalar_flag = false)
#endif /* defined(ARRAY_ACCESS_INLINING) */


/*
 * Is scalar double flag set
 */
extern bool mxIsScalarDoubleFlagSet(
    const mxArray	*pa		/* pointer to array */
    );


#if defined(ARRAY_ACCESS_INLINING)
#define mxIsScalarDoubleFlagSet(pa) ((pa)->flags.scalar_flag == 1)
#endif /* defined(ARRAY_ACCESS_INLINING) */


/*
 * Set scalar flag if appropiate (double scalar)
 */
extern void mxSetScalarDoubleFlagIfAppropiate(
    mxArray *pa		/* pointer to array */
    );


/*
 * Mark data as unshareable
 */
extern void mxSetDataPrivateFlag(
    mxArray	*pa,		/* pointer to array */
    bool        val
    );


#if defined(ARRAY_ACCESS_INLINING)
#define mxSetDataPrivateFlag(pa, val) ((pa)->flags.private_data_flag = (int)(val))
#endif /* defined(ARRAY_ACCESS_INLINING) */


/*
 * Is data unshareable?
 */
extern bool mxIsDataPrivate(
    const mxArray	*pa		/* pointer to array */
    );


#if defined(ARRAY_ACCESS_INLINING)
#define mxIsDataPrivate(pa)     (((pa)->flags.private_data_flag==1) ? true : false)
#endif /* defined(ARRAY_ACCESS_INLINING) */


#include <stdlib.h>
#define MX_DYNAMIC_STRUCT_REF_ERROR  "Argument to dynamic structure reference must evaluate to a valid field name"


/*
 * Create a numeric matrix and initialize all its data elements to 0.
 */ 
extern mxArray *mxCreateNumericMatrix(
	int		m, 
	int		n,
	mxClassID	classid,
	int		cmplx_flag
	);

 
/* 
 * Set column dimension
 */
extern void mxSetN(mxArray *pa, int n);


/*
 * Set dimension array and number of dimensions.  Returns 0 on success and 1
 * if there was not enough memory available to reallocate the dimensions array.
 */
extern int mxSetDimensions(mxArray *pa, const int *size, int ndims);


/*
 * mxArray destructor
 */
extern void mxDestroyArray(mxArray *pa);


/*
 * Create a numeric array and initialize all its data elements to 0.
 */ 
extern mxArray *mxCreateNumericArray(int ndim, const int *dims, mxClassID classid, mxComplexity flag);


/*
 * Create a two-dimensional array to hold double-precision 
 * floating-point data; initialize each data element to 0.
 */
extern mxArray *mxCreateDoubleMatrix(int m, int n, mxComplexity flag);


/*
 * Get a properly typed pointer to the elements of a logical array.
 */
extern mxLogical *mxGetLogicals(const mxArray *pa);


/*
 * Create a logical array and initialize its data elements to false.
 */ 
extern mxArray *mxCreateLogicalArray(int ndim, const int *dims);


/*
 * Create a two-dimensional array to hold logical data and
 * initializes each data element to false.
 */
extern mxArray *mxCreateLogicalMatrix(unsigned int m, unsigned int n);


/*
 * Create a logical scalar mxArray having the specified value.
 */
extern mxArray *mxCreateLogicalScalar(bool value);


/*
 * Returns true if the logical scalar value is true.
 */
extern bool mxIsLogicalScalarTrue(const mxArray *pa);


/*
 * Create a double-precision scalar mxArray initialized to the
 * value specified