libmatlb.h

BP神经网络的C++程序,里面有源程序和生成的可执行文件,希望对正在学习的朋友有用!

extern mxArray *mclUnpackVararginToCell(int nrhs, mxArray **prhs);


extern void mclVarargin(mxArray ** varargin, mxArray * last, int uselast, va_list ap);


extern int mlfCountVarargin(va_list ap, mxArray *first);


/* For math library use only.  Do not call this function.*/
extern void mlfUnpackVarargin(va_list ap, mxArray **prhs, mxArray *first);

extern mxArray *mlfCellhcat(mxArray *pa, ...);

extern void mlxCellhcat(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs);

extern mxArray *mlfNargin(int varargin_flag, ...);


typedef struct mlfVarargoutList_tag mlfVarargoutList;

extern int mlfNargout(mlfVarargoutList *varargout);

extern mlfVarargoutList *mlfIndexVarargout(mxArray **ppa, ...); 
extern mlfVarargoutList *mlfVarargout(mxArray **ppa, ...); 

extern mxArray *mlfGetVarargoutCell(mlfVarargoutList *v);

extern mxArray **mlfGetVarargoutCellPtr(mlfVarargoutList *v);

extern mlfVarargoutList *mclAnsVarargout(void); 

extern mlfVarargoutList *mclNVarargout(int nargout, int varargout_used, ...); 

extern mlfVarargoutList *mclValueVarargout(void); 

extern mxArray *mlfAssignOutputs(mlfVarargoutList *v);

extern void mclCreateVarargoutCell(mlfVarargoutList *vout, int nvarargs, mxArray **ppa);

extern mxArray * mlfVarargFeval(mlfVarargoutList *varargout,
                                void (*mxfn)(int nlhs, mxArray **plhs, int nrhs, mxArray **prhs), ...);


extern void mclAssignVarargoutCell(int nlhs, mxArray *plhs[], mxArray *cell);


extern mxArray *mclCreateVararginCell(int nrhs, mxArray *prhs[]);


typedef void (*mlfFcnPtr)(int, mxArray**, int, mxArray**);



typedef struct mlfDispatchTable_tag 
{
  mlfFcnPtr *vtab;
  const char** funcnames;
  int nfuncs;
} mlfDispatchTable;



/* For math library use only.  Do not call this function */
extern void mlfDispatch(int nlhs, mxArray** plhs, int nrhs, mxArray** prhs,
                 int code, mlfDispatchTable *dt);


#define MLF_DEFAULT_INDEX_SIZE 4

typedef unsigned char mlfIndexType;
struct mlfIndexDef_tag
{
    int num_index_ops;
    mlfIndexType *type;
    int *idx;
    mxArray **subscripts;
    int  *fieldptrs;
    char *fieldnames;
    mlfIndexType type_local[MLF_DEFAULT_INDEX_SIZE];
    int idx_local[MLF_DEFAULT_INDEX_SIZE+1];
    mxArray *subscripts_local[MLF_DEFAULT_INDEX_SIZE];
    int fieldptrs_local[MLF_DEFAULT_INDEX_SIZE+1];
    char fieldnames_local[MLF_DEFAULT_INDEX_SIZE];
    mxArray **dest;
    int size;
    int max_size;
};
#define mlfCELL 0
#define mlfARRAY 1
#define mlfSTRUCT 2
typedef struct mlfIndexDef_tag mlfIndexDef;


/* For use only by the C++ math library. Do not call this function. */
extern void mclInitIndex(mlfIndexDef *index_def);

extern void mclDestroyIndexDef(mlfIndexDef *index_def, int free_flag); 
extern void mclCopyIndexDef(mlfIndexDef *dest, const mlfIndexDef *src);


/* For use only by the C++ math library. Do not call this function. */
extern void mclAddIndex(mlfIndexDef *index_def, mlfIndexType type, int nsubscripts, mxArray **psubscripts);


extern void mclAddFieldToLastIndex(mlfIndexDef *index_def, const char* fname_in);


/* For use only by the C++ math library. Do not call this function. */
extern mxArray *mclComplexRef(mxArray *pa, mlfIndexDef *index_def);

 
/* This function is intended for use only by the C++ math library */
extern void mclComplexAssign(mlfIndexDef *index_def, mxArray *src, bool packCell);

extern void mclPrintIndex(const char* index_string, ...);

extern mxArray * mlfIndexRef(mxArray *pa, const char* index_string, ...);

extern mxArray * mlfIndexAssign(mxArray * volatile *pa, const char* index, ...);

extern mxArray * mlfIndexDelete(mxArray * volatile *pa, const char* index, ...);

extern mxArray* mlfArrayRef(mxArray *array, ...);

extern void mlfArrayAssign(mxArray *dest, mxArray *src, ...);

extern void mlfArrayDelete(mxArray *dest, ...);

extern mxArray * mlfCreateColonIndex();

extern bool mlfIsColonIndex(mxArray *a);


extern int mclGetNumberOfIndexedElements(mlfIndexDef *index_def); 


/* For use only by the C++ math library */
extern int mclMultiAssign(mlfIndexDef *index_def, mxArray **prhs, int max_rhs_size);


/* For use only by the Matlab compiler. This is unsupported functionality. */
typedef struct mclForIter_tag {
    int curridx;  /* Current index into loop array */
    int maxidx;   /* maximum index into loop array */
    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)*/
    double start; /* start value (ignored if not colon) */ 
    double delta; /* step value (ignored if not colon) */ 
} mclForLoopIterator;
#define mclForDone 0

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

 
/* For use only by the Matlab compiler.  Do not call this function. */
extern void mclForStart(mclForLoopIterator *piter, 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 *piter, mclVolatileArrayPtr ppa); 

extern mxArray * mlf_colonobj(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlf_license_checkout(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfAbs(mxArray *in1);

extern mxArray * mlfAcos(mxArray *in1);

extern mxArray * mlfAcosh(mxArray *in1);

extern void mlfAdd_block(mxArray *in1, ...);

extern void mlfAdd_line(mxArray *in1, ...);

extern mxArray * mlfAll(mxArray *in1, mxArray *in2);

extern mxArray * mlfAnd(mxArray *in1, mxArray *in2);

extern mxArray * mlfAny(mxArray *in1, mxArray *in2);

extern mxArray * mlfApplescript(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfAsin(mxArray *in1);

extern mxArray * mlfAsinh(mxArray *in1);

extern mxArray * mlfAssignin(mxArray *in1, mxArray *in2, mxArray *in3, ...);

extern mxArray * mlfAtan(mxArray *in1);

extern mxArray * mlfAtanh(mxArray *in1);

extern mxArray * mlfAtan2(mxArray *in1, mxArray *in2);

extern mxArray * mlfBalance(mxArray **out1, mxArray *in1);

extern mxArray * mlfBitand(mxArray *in1, mxArray *in2);

extern mxArray * mlfBitcmp(mxArray *in1, mxArray *in2);

extern mxArray * mlfBitget(mxArray *in1, mxArray *in2);

extern mxArray * mlfBitset(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfBitshift(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfBitor(mxArray *in1, mxArray *in2);

extern mxArray * mlfBitxor(mxArray *in1, mxArray *in2);

extern mxArray * mlfCallstats(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfCat(mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfCd(mxArray *in1);

extern mxArray * mlfCeil(mxArray *in1);

extern mxArray * mlfCell(mxArray *in1, ...);

extern mxArray * mlfCell2struct(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfChar(mxArray *in1, ...);

extern mxArray * mlfChdir(mxArray *in1);

extern mxArray * mlfChol(mxArray **out1, mxArray *in1);

extern mxArray * mlfCholinc(mxArray **out1, mxArray *in1, mxArray *in2);

extern mxArray * mlfCholupdate(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfClassName(mxArray *in1);

extern void mlfClc( void );

extern mxArray * mlfClock( void );

extern void mlfClose_system(mxArray *in1, ...);

extern mxArray * mlfColon(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfComputer(mxArray **out1);

extern mxArray * mlfConj(mxArray *in1);

extern mxArray * mlfConv2(mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern mxArray * mlfCos(mxArray *in1);

extern mxArray * mlfCtranspose(mxArray *in1);

extern mxArray * mlfCosh(mxArray *in1);

extern mxArray * mlfCumprod(mxArray *in1, mxArray *in2);

extern mxArray * mlfCumsum(mxArray *in1, mxArray *in2);

extern mxArray * mlfCputime( void );

extern void mlfDbclear(mxArray *in1, ...);

extern void mlfDbdown( void );

extern void mlfDbquit( void );

extern mxArray * mlfDbstack(mxArray **out1);

extern mxArray * mlfDbstatus(mxArray *in1, ...);

extern void mlfDbstep(mxArray *in1);

extern void mlfDbstop(mxArray *in1, ...);

extern void mlfDbtype(mxArray *in1);

extern void mlfDbup( void );

extern void mlfDelete_block(mxArray *in1);

extern void mlfDelete_line(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfDet(mxArray *in1);

extern mxArray * mlfDiag(mxArray *in1, mxArray *in2);

extern void mlfDiary(mxArray *in1);

extern mxArray * mlfDiff(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfDir(mxArray *in1);

extern void mlfDisp(mxArray *in1);

extern mxArray * mlfDongarra(mxArray *in1);

extern mxArray * mlfDouble(mxArray *in1);

extern mxArray * mlfDos(mxArray **out1, mxArray *in1, mxArray *in2);

extern void mlfEcho(mxArray *in1, ...);

extern mxArray * mlfEdt(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfEnd(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfEig(mxArray **out1, mxArray *in1, mxArray *in2);

extern mxArray * mlfEps( void );

extern mxArray * mlfEq(mxArray *in1, mxArray *in2);

extern void mlfError(mxArray *in1);

extern mxArray * mlfErrorstat( void );

extern void mlfErrortrap(mxArray *in1);

extern mxArray * mlfEvalin(mlfVarargoutList *varargout, mxArray *in1, mxArray *in2, mxArray *in3, ...);

extern mxArray * mlfNEvalin(int nargout, mlfVarargoutList *varargout, mxArray *in1, mxArray *in2, mxArray *in3, ...);

extern void mlfExit( void );

extern mxArray * mlfExp(mxArray *in1);

extern mxArray * mlfExpm(mxArray *in1);

extern mxArray * mlfEye(mxArray *in1, mxArray *in2);

extern mxArray * mlfFclose(mxArray *in1);

extern void mlfFeature(mxArray *in1, ...);

extern mxArray * mlfFieldnames(mxArray *in1);

extern mxArray * mlfFields(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfFeof(mxArray *in1);

extern mxArray * mlfFerror(mxArray **out1, mxArray *in1, mxArray *in2);

extern mxArray * mlfFft(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfFftn(mxArray *in1, mxArray *in2);

extern mxArray * mlfFgets(mxArray **out1, mxArray *in1, mxArray *in2);

extern mxArray * mlfFilter(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4, mxArray *in5);

extern mxArray * mlfFind(mxArray **out1, mxArray **out2, mxArray *in1);

extern mxArray * mlfFindstr(mxArray *in1, mxArray *in2);

extern mxArray * mlfFinite(mxArray *in1);

extern mxArray * mlfFix(mxArray *in1);

extern mxArray * mlfFloor(mxArray *in1);

extern mxArray * mlfFlops(mxArray *in1);

extern void mlfFormat(mxArray *in1, mxArray *in2);

extern mxArray * mlfFopen(mxArray **out1, mxArray **out2, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfFprintf(mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfFread(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern mxArray * mlfFschange(mlfVarargoutList *varargout, mxArray *in1, ...);

extern mxArray * mlfFscanf(mxArray **out1, mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfFseek(mxArray *in1, mxArray *in2, mxArray *in3);

extern mxArray * mlfFtell(mxArray *in1);

extern mxArray * mlfFull(mxArray *in1);

extern mxArray * mlfFwrite(mxArray *in1, mxArray *in2, mxArray *in3, mxArray *in4);

extern mxArray * mlfGe(mxArray *in1, mxArray *in2);

extern mxArray * mlfGet_param(mxArray *in1, mxArray *in2);

extern mxArray * mlfGetenv(mxArray *in1);

extern mxArray * mlfGetfield(mxArray *in1, mxArray *in2, ...);

extern mxArray * mlfGt(mxArray *in1, mxArray *in2);

extern mxArray * mlfHcreate(mlfVarargoutList *varargout, mxArray *in1, ...);