libmatlb.h

博弈论自适应功率控制中的实现

extern void mcl_eval_string_fcn( int nlhs, mxArray **plhs, const char *str, 
                          mxFunctionPtr (*lookup)(char* name, void *lookup_x), void *lookup_x );


extern void
mclEvalString(  int nlhs, mxArray **plhs, const char *str );


extern void mclAddPaths( size_t num_paths, const char **paths );


extern bool mclFindFirstFileName(
    const char	*name,
    bool	supply_matlab_exts,
    char	*fullname
    );


extern void mclInitMatlabRoot( int *argc, const char **argv );


extern double mclDivideDouble(double x, double y);


extern double mclLeftDivideDouble(double x, double y);


extern mxArray *mclDivideDoublePair(double x1, double x2, double y1, double y2);


extern mxArray *mclLeftDivideDoublePair(double x1, double x2, double y1, double y2);


extern int mclLengthInt(mxArray *a);


#define mclInitializeAns() mclGetUninitializedArray()
#define mclInitializeNull() mclGetUninitializedArray()
#define mclIsUninitialized(pa) (mxGetClassID(pa) == mxUNKNOWN_CLASS)
#define mclIsInitialized(pa) (pa != NULL && !mclIsUninitialized(pa))

extern mxArray *mlfReturnValue(mxArray *a);

 
extern bool mclUninitWarning( const char *vname );


typedef enum mclValidateErrorCode {
  mclINPUT_UNDEFINED=0,
  mclFCN_OR_VARIABLE_UNDEFINED
} mclValidateErrorCode;


#ifndef WARNING_FREE_CODE

#define mclIsUninitializedWarn( in, vname ) ( mclIsUninitialized(in) ? mclUninitWarning(vname) : false )

/*
 * If "in" is Undefined, throw an error.
 * If "in" is Uninitialized, return [].  Otherwise return "in".
 */

#define mclVva_uninitialized( in, vname)                                \
   !mclIsUninitializedWarn(in,vname) ? in : mclCreateEmptyArray()

#define mclVs_uninitialized( in, vname) (mclIsUninitializedWarn(in,vname), in)


#define mclVve( in, vname )                                            \
( mclIsUninitializedWarn( in, vname ) ? mclCreateEmptyArray() : in )

#else

#define mclVva_uninitialized( in, vname) in
#define mclVs_uninitialized( in, vname) in
#define mclVve( in, vname ) in

#endif

#define mclVva( in, errcode, vname )                                                    \
( in != NULL ? mclVva_uninitialized(in, vname) : mclValidateError( errcode, vname ) )

#define mclVs_(in, errcode, vname )                                                     \
( (in) != NULL ?  mclVs_uninitialized(in, vname) : mclValidateError(errcode, vname ) )

#define mclVa(in, vname) mclVva(in, mclINPUT_UNDEFINED, vname)

#define mclVv(in, vname) mclVva(in, mclFCN_OR_VARIABLE_UNDEFINED, vname)

#define mclVsv(in, vname) mclVs_(in, mclFCN_OR_VARIABLE_UNDEFINED, vname)

#define mclVsa(in, vname) mclVs_(in, mclINPUT_UNDEFINED, vname)

#define mclVo( output ) { if ( *output == NULL ) *output = mclGetUninitializedArray(); }


 
extern mxArray *mclValidateError( mclValidateErrorCode code, const char *vname );


extern mxArray *mclVe( mxArray *in );


#ifdef WARNING_FREE_CODE
#define mclVe(in) in
#endif


extern void mclCopyInputArg( mxArray * volatile *dest, mxArray *src );

 
extern void mclCopyArray( mxArray **pa );


extern void mclCopyOutputArg(mxArray * volatile *dest, mxArray *src);


extern void mclValidateOutputWarning( const char *vname, const char *fname );


#ifndef WARNING_FREE_CODE
#define mclValidateOutput( output, pos, nargout, vname, fname ) \
{                                                               \
  if ((output) == NULL) {                                       \
     mlfAssign( &(output),  mclGetUninitializedArray() );       \
  }                                                             \
  else                                                          \
  if ( pos <= nargout && mclIsUninitialized(output) ) {         \
    mclValidateOutputWarning( vname, fname );                   \
  }                                                             \
} (void)0
#else
#define mclValidateOutput( output, pos, nargout, vname, fname ) \
{                                                               \
  if ((output) == NULL)                                         \
     mlfAssign( &(output),  mclGetUninitializedArray() );       \
} (void)0
#endif


extern mxArray ** mclInitGlobal( mxArray **g );

    
#define mclPrepareGlobal(g) ((*g != NULL) ? g : mclInitGlobal(g))


extern mxArray *mclVg( mxArray **pg, const char *name );


/* Common definitions */
#define mclAppendMlineCommon()                                  \
      mclAppendMlineToError( (const char *) __M_file_name,      \
                             (const char *) __M_function_name,  \
                             (size_t) __M_line_number );

#define mclMlineEnterFunctionCommon(file_name, function_name )  \
{ const char * volatile __M_file_name = file_name;              \
  const char * volatile __M_function_name = function_name;      \
  volatile size_t __M_line_number = 0; 

#ifdef __cplusplus
#ifdef EXCEPTIONS_WORK

#define mclMlineEnterFunction( file_name, function_name )       \
  mclMlineEnterFunctionCommon( file_name, function_name)        \
   try{

#define mclMlineExitFunction()                  \
  } catch (mwException &) {                     \
      mclAppendMlineCommon()                    \
      error( lasterror() );                     \
  } } return

#else /* if !EXCEPTIONS_WORK */

#define mclMlineEnterFunction mclMlineEnterFunctionCommon

#define mclMlineExitFunction() } return

#endif /* EXCEPTIONS_WORK */

#define mclMlineFunctionReturn()  
#define mclMlineExitFunctionReturn() mclMlineExitFunction() mwArray()

#else /* if !__cplusplus */

#define mclMlineEnterFunction( file_name, function_name )       \
  mclMlineEnterFunctionCommon( file_name, function_name )       \
  mlfTry {

#define mclMlineExitFunctionCommon()             \
      mclAppendMlineCommon()                    \
      mlfError( mlfLasterror(NULL) );           \
  } mlfEndCatch } return

#define mclMlineExitFunction()                  \
  } mlfCatch {                                  \
  mclMlineExitFunctionCommon()

#define mclMlineFunctionReturn()  mclExitTryBlock_();
#define mclMlineExitFunctionReturn()                            \
   } mclCatchWithoutExit { mclMlineExitFunctionCommon() NULL

#endif /* !__cplusplus */

#define mclMline( line ) __M_line_number = line;



extern void mclAppendMlineToError(const char *file_name, const char *function_name, size_t line_number );


extern int mclCallMexFile(
    int		nlhs,			/* number of expected outputs */
    mxArray	*plhs[],		/* pointer array to outputs */
    int		nrhs,			/* number of inputs */
    mxArray	*prhs[],		/* pointer array to inputs */
    const char	*fcn_name		/* name of function to execute */
    );


extern mxArray * mclExecMexFile(mlfVarargoutList *varargout,
                               const char *name, ...);


extern mxArray *mclInitializeDouble( double d );


extern mxArray *mclInitializeComplex( double re, double im );


extern mxArray *mclInitializeComplexVector( int m, int n, double *pr, double *pi );


extern mxArray *mclInitializeDoubleVector( int m, int n, double *pr );


extern mxArray *mclInitializeString( int len, mxChar *string_pr );


extern mxArray *mclInitializeCharVector( int m, int n, mxChar *string_pr );


extern mxArray *mclInitializeCell( mxArray *cell );

 
extern mxArray *mclInitializeCellVector( int m, int n, mxArray **cell_pr );


extern mxArray *mclInitializeOther( unsigned char *buf, size_t size );


extern void mclInitializePersistent(mxArray* volatile * pv);


extern mxArray *mclInitializeLogical( bool b );


extern mxArray *mclInitializeLogicalVector( int m, int n, double *pr );


typedef enum {mclFOR_COLON, mclFOR_NUMERIC, mclFOR_GENERIC} mclForLoopCategory;

typedef struct _mclForLoopIterator mclForLoopIterator;

typedef void (*fn_for_next)( mclForLoopIterator *iter, mxArray * index );

/* For use only by the Matlab compiler. */
struct _mclForLoopIterator {
  int curridx;  /* Current index into loop array */
  int maxidx;   /* number of times to repeat the loop */
  mclForLoopCategory category;
  fn_for_next start;
  fn_for_next next;
  union {
    struct {
      int m;
      unsigned char scalar;
      unsigned char logical;
      void *pr;
      void *pi;
      int nel;
      mxArray *loop_array;  /* array over which we are iterating, (null if colon index) */
    } num;
    struct {
      double start; /* start value (ignored if not colon) */ 
      double delta; /* step value (ignored if not colon) */ 
    } colon;
    struct {
      mxArray *loop_array;  /* array over which we are iterating, (null if colon index) */
      mxArray *row; /* row index (null if colon index) */ 
      mxArray *col; /* column index (null if colon index)*/
    } arr;
  } iter;
};

#define mclForDone 0

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern void mclDestroyForLoopIterator_(mclForLoopIterator *iter);


#define mclDestroyForLoopIterator(x) mclDestroyForLoopIterator_(&x)

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern void mclForStart(mclForLoopIterator *iter, mxArray *pa, mxArray *pa2, mxArray *pa3);


typedef mxArray * volatile *mclVolatileArrayPtr;

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern int mclForNext(mclForLoopIterator *iter, mclVolatileArrayPtr ppa);


/* For use only by the Matlab compiler.  Do not call this function. */
/*
 * The purpose of this function is to ensure that a value of INT_MIN for
 * the upper bound of a loop always causes a null loop.  This is true as
 * long as the start of the loop is not exactly INT_MIN.
 */
extern int mclForIntStart(int s);


/* For use only by the Matlab compiler.  Do not call this function. */
/*
 * The next two functions are based on mxColonop_size for integer values of
 * what are there called a and d.
 */
extern int mclForIntEnd(mxArray *e); /* The increment is implicitly 1 */


/* For use only by the Matlab compiler.  Do not call this function. */
/*
 * When comparing to mxColonop_size, s corresponds to a, and i to d.
 * This returns the exact endpoint, so termination can be done by equality,
 * independently of the sign of i.
 */
extern int mclForIntIntEnd(int s, int i, mxArray *e);


extern mxArray *mclPlus( mxArray *a, mxArray *b );


extern mxArray *mclMinus( mxArray *a, mxArray *b );


extern mxArray *mclTimes( mxArray *a, mxArray *b );


extern mxArray *mclMtimes( mxArray *a, mxArray *b );


extern mxArray *mclRdivide( mxArray *a, mxArray *b );


extern mxArray *mclMrdivide( mxArray *a, mxArray *b );


extern mxArray *mclMpower( mxArray *a, mxArray *b );


extern mxArray *mclEq( mxArray *a, mxArray *b );


extern mxArray *mclNe( mxArray *a, mxArray *b );


extern mxArray *mclLt( mxArray *a, mxArray *b );


extern mxArray *mclGt( mxArray *a, mxArray *b );


extern mxArray *mclLe( mxArray *a, mxArray *b );


extern mxArray *mclGe( mxArray *a, mxArray *b );


extern mxArray *mclAnd( mxArray *a, mxArray *b );


extern mxArray *mclOr( mxArray *a, mxArray *b );


extern mxArray *mclUplus( mxArray *a );


extern mxArray *mclUminus( mxArray *a );


extern mxArray *mclNot( mxArray *a );


extern bool mclEqBool( mxArray *a, mxArray *b );


extern bool mclNeBool( mxArray *a, mxArray *b );


extern bool mclLtBool( mxArray *a, mxArray *b );


extern bool mclGtBool( mxArray *a, mxArray *b );


extern bool mclLeBool( mxArray *a, mxArray *b );


extern bool mclGeBool( mxArray *a, mxArray *b );


extern bool mclNotBool( mxArray *a );


extern void mclAddPaths( size_t num_paths, const char **paths );


extern bool mclFindFirstFileName(
    const char	*name,
    bool	supply_matlab_exts,
    char	*fullname
    );


extern void mclInitMatlabRoot( int *argc, const char **argv );


extern void mclLibInitGlobals(int length, mexGlobalTable globals);


extern void mclLibTermGlobals(int length, mexGlobalTable globals);


extern void mclLibInitInitTerms(int length, mexInitTermTableEntry inits);


extern void mclLibTermInitTerms(int length, mexInitTermTableEntry terms);


extern void mclLibInitCommon( mex_information info );


extern void mclLibInit(int * ref, mex_information info);


extern void mclLibTermCommon( mex_information info );


extern void mclLibTerm(int * ref, mex_information info);


extern int mclMain( int argc, const char **argv, mxFunctionPtr mlxfn, bool nout, mex_information info );


extern mex_information mclMex( mex_information mex_info );


extern void mclMextest( int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs, mxFunctionPtr mlxF, mex_information info, const char *mfcn );


/*
 * These macros are for backward compatibility.
 */
#define mclGlobalTableEntry mexGlobalTableEntry
#define mclExportGlobal mexExportGlobal
#define mlfFunctionTableEntry mexFunctionTableEntry


extern mxArray * mclFevalCallMATLAB(mlfVarargoutList *varargout,
                               const char *name, ...);


extern int mclSupportedDataTypes(int nrhs, const mxArray **prhs);


/*
 * $Revision: 1.1 $
 */

#include "libmatlbm.h"
#include "libsgl.h"

#ifdef __cplusplus
    }	/* extern "C" */
#endif

#endif /* libmatlb_h */