libmatlb.h

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

extern void mlxSprintf(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSqrt(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSscanf(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrrep(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrcmp(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrcmpi(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrncmp(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStrncmpi(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStruct(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxStruct2cell(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSubsasgn(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSubsindex(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSubsref(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSum(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSuperiorto(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSvd(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxSystem_dependent(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTan(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTanh(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTimes(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTranspose(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTrmginput(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTril(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxTriu(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxType(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUint8(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUint16(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUint32(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUminus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUnaryminus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUplus(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUpper(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxUnix(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxVersion(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxVertcat(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxVms(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWarning(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWhich(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWho(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWhos(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxWhat(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxXlate(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void mlxZeros(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[]);

extern void *mclMalloc(size_t s);

extern void *mclCalloc(size_t c, size_t s);

extern void *mclRealloc(void *p, size_t s);



#ifdef mxMalloc
#undef mxMalloc
#endif
#define mxMalloc mclMalloc

#ifdef mxCalloc
#undef mxCalloc
#endif
#define mxCalloc mclCalloc

#ifdef mxRealloc
#undef mxRealloc
#endif
#define mxRealloc mclRealloc


extern int mclUnshareArray(mxArray *pa, int level);


#ifdef mxUnshareArray
#undef mxUnshareArray
#endif
#define mxUnshareArray mclUnshareArray

extern mxArray *mclCreateCellArray(int ndim, const int *dims);


#ifdef mxCreateCellArray
#undef mxCreateCellArray
#endif
#define mxCreateCellArray mclCreateCellAray

extern mxArray *mclCreateCharMatrixFromStrings(int m, const char **str);


#ifdef mxCreateCharMatrixFromStrings
#undef mxCreateCharMatrixFromStrings
#endif
#define mxCreateCharMatrixFromStrings mclCreateCharMatrixFromStrings

extern mxArray *mclCreateDoubleMatrix(int m, int n, mxComplexity ComplexFlag);


#ifdef mxCreateDoubleMatrix
#undef mxCreateDoubleMatrix
#endif
#define mxCreateDoubleMatrix mclCreateDoubleMatrix

extern mxArray *mclCreateNumericArray(int ndim, const int *dims, 
                                      mxClassID clsid, mxComplexity ComplexFlag);


#ifdef mxCreateNumericArray
#undef mxCreateNumericArray
#endif
#define mxCreateNumericArray mclCreateNumericArray

extern mxArray *mclCreateSparse(int m, int n, int nzmax, 
                                mxComplexity ComplexFlag);


#ifdef mxCreateSparse
#undef mxCreateSparse
#endif
#define mxCreateSparse mclCreateSparse

extern mxArray *mclCreateString(const char *str);


#ifdef mxCreateString
#undef mxCreateString
#endif
#define mxCreateString mclCreateString

extern mxArray *mclCreateStructArray(int ndim, const int *dims, int nfields,
                                    const char **field_names);


#ifdef mxCreateStructArray
#undef mxCreateStructArray
#endif
#define mxCreateStructArray mclCreateStructArray

extern mxArray *mclCreateStructMatrix(int m, int n, int nfields, 
                                      const char **field_names);


#ifdef mxCreateStructMatrix
#undef mxCreateStructMatrix
#endif
#define mxCreateStructMatrix mclCreateStructMatrix

extern mxArray *mclDuplicateArray(const mxArray *in);


#ifdef mxDuplicateArray
#undef mxDuplicateArray
#endif
#define mxDuplicateArray mclDuplicateArray

extern mxArray *mclGetCell(const mxArray *array_ptr, int index);


#ifdef mxGetCell
#undef mxGetCell
#endif
#define mxGetCell mclGetCell

extern void *mclGetData(const mxArray *array_ptr);


#ifdef mxGetData
#undef mxGetData
#endif
#define mxGetData mclGetData

extern mxArray *mclGetField(const mxArray *array_ptr, int index, 
                            const char *field_name);


#ifdef mxGetField
#undef mxGetField
#endif
#define mxGetField mclGetField

extern mxArray *mclGetFieldByNumber(const mxArray *array_ptr, int index, 
                                   int field_number);


#ifdef mxGetFieldByNumber
#undef mxGetFieldByNumber
#endif
#define mxGetFieldByNumber mclGetFieldByNumber

extern void *mclGetImagData(const mxArray *array_ptr);


#ifdef mxGetImagData
#undef mxGetImagData
#endif
#define mxGetImagData mclGetImagData

extern int *mclGetIr(const mxArray *array_ptr);


#ifdef mxGetIr
#undef mxGetIr
#endif
#define mxGetIr mclGetIr

extern int *mclGetJc(const mxArray *array_ptr);


#ifdef mxGetJc
#undef mxGetJc
#endif
#define mxGetJc mclGetJc

extern double *mclGetPr(const mxArray *array_ptr);


#ifdef mxGetPr
#undef mxGetPr
#endif
#define mxGetPr mclGetPr

extern double *mclGetPi(const mxArray *array_ptr);


#ifdef mxGetPi
#undef mxGetPi
#endif
#define mxGetPi mclGetPi

extern void mclSetCell(mxArray *array_ptr, int index, mxArray *value);


#ifdef mxSetCell
#undef mxSetCell
#endif
#define mxSetCell mclSetCell

extern void mclSetData(mxArray *array_ptr, void *data_ptr);


#ifdef mxSetData
#undef mxSetData
#endif
#define mxSetData mclSetData

extern int mclSetDimensions(mxArray *array_ptr, const int *dims, int ndims);


#ifdef mxSetDimensions
#undef mxSetDimensions
#endif
#define mxSetDimensions mclSetDimensions

extern void mclSetField(mxArray *array_ptr, int index, 
                        const char *field_name, mxArray *value);


#ifdef mxSetField
#undef mxSetField
#endif
#define mxSetField mclSetField

extern void mclSetFieldByNumber(mxArray *array_ptr, int index, 
                               int field_number, mxArray *value);


#ifdef mxSetFieldByNumber
#undef mxSetFieldByNumber
#endif
#define mxSetFieldByNumber mclSetFieldByNumber

extern void mclSetImagData(mxArray *array_ptr, void *pi);


#ifdef mxSetImagData
#undef mxSetImagData
#endif
#define mxSetImagData mclSetImagData

extern void mclSetIr(mxArray *array_ptr, int *ir);


#ifdef mxSetIr
#undef mxSetIr
#endif
#define mxSetIr mclSetIr

extern void mclSetJc(mxArray *array_ptr, int *jc);


#ifdef mxSetJc
#undef mxSetJc
#endif
#define mxSetJc mclSetJc

extern void mclSetPi(mxArray *array_ptr, double *pi);


#ifdef mxSetPi
#undef mxSetPi
#endif
#define mxSetPi mclSetPi

extern void mclSetPr(mxArray *array_ptr, double *pr);


#ifdef mxSetPr
#undef mxSetPr
#endif
#define mxSetPr mclSetPr

extern mxArray *mclCreateSharedCopy(const mxArray *pa); 


#ifdef mxCreateSharedCopy
#undef mxCreateSharedCopy
#endif
#define mxCreateSharedCopy mclCreateSharedCopy


typedef struct mclGlobalTableEntry_Tag
{
    const char *name;             /* The name of the global */
    mxArray    **variable;        /* A pointer to the variable */ 
} mclGlobalTableEntry;



/*
 * This function imports the globals from the Matlab workspace into
 * the Compiler 2.0 generated global variables
 */
   
extern void mclImportGlobal( size_t size, mclGlobalTableEntry *gtab );


extern void mclExportGlobal( size_t size, mclGlobalTableEntry *gtab );


extern void mclFevalExecMATLAB(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       /* function name */
                        );


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


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

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

#endif /* libmatlb_h */