libmatlb.h

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

/*
 * @(#)libmatlb.h    generated by: makeheader    Thu Jan 21 01:45:03 1999
 *
 *		built from:	headers/copyright.h
 *				mlm/memory.c
 *				mlm/stubs.c
 *				mlm/handler.c
 *				mlm/mlm.c
 *				mlm/varargs.c
 *				mlm/mlmdispatch.c
 *				mlm/index.c
 *				mlm/mlmscalar.c
 *				mlm/builtins.c
 *				mlm/mlmsparse.c
 *				mlm/mxapi.c
 *				mlm/mex_interface.c
 */

#ifndef libmatlb_h
#define libmatlb_h


/*
 * Copyright (c) 1984-1998 by The MathWorks, Inc.
 * All Rights Reserved.
 */

#ifdef __cplusplus
    extern "C" {
#endif

extern void mlfSetLibraryAllocFcns(calloc_proc calloc_fcn, free_proc free_fcn,
                                   realloc_proc realloc_fcn, malloc_proc malloc_fcn);

extern void mclInitMemoryCache(void);


typedef void (*ErrorHandlerFcn)(const char*, bool);



#ifndef __cplusplus
static mxArray *__mclUnassignedArray = NULL;
static mxArray *__mclUninitializedArray = NULL;

#ifdef __GNUC__
static void __mcl_nowarn(void)
{
    (void)__mclUnassignedArray;
    (void)__mclUninitializedArray;
    (void)__mcl_nowarn;
}
#endif

#define mclUnassigned() (__mclUnassignedArray==NULL?\
                         (__mclUnassignedArray=mclGetUnassignedArray()):__mclUnassignedArray)
#define mclInitializeAns() (__mclUninitializedArray==NULL?\
                            (__mclUninitializedArray=mclGetUninitializedArray()):__mclUninitializedArray)
#else
#define mclUnassigned() mclGetUnassignedArray()
#define mclInitializeAns() mclGetUninitializedArray()
#endif

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


#ifdef __cplusplus
#define mclMline( line ) __M_line_number = line;
#ifdef EXCEPTIONS_WORK
#define mclMlineEnterFunction( 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; \
  try {
#define mclMlineExitFunction() \
  } catch (mwException &) { \
      mclAppendMlineToError( (const char *) __M_file_name, (const char *) __M_function_name, (size_t) __M_line_number ); \
      error( lasterror() ); \
  } }
#else
#define mclMlineEnterFunction( 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; 
#define mclMlineExitFunction() \
  }
#endif
#else
#define mclMlineEnterFunction( 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; \
  mlfTry {
#define mclMline( line ) __M_line_number = line;
#define mclMlineExitFunction() \
  } mlfCatch { \
      mclAppendMlineToError( (const char *) __M_file_name, (const char *) __M_function_name, (size_t) __M_line_number ); \
      mlfError( mlfLasterror(NULL) ); \
  } mlfEndCatch }
#endif


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

extern mxArray *mclGetUninitializedArray(); 

extern mxArray *mclGetUnassignedArray();


extern void mclErrorIfUnassigned(mxArray *pa); 


extern bool mclIsCommaList(mxArray *array);


extern bool mclIsNewContext(void);

extern void mclDestroyArray(mxArray *a); 
 
/* For use only by the compiler. Do not call this function */
extern bool mclIsTempArray(mxArray *a); 
 
/* For use only by the compiler. Do not call this function */
extern void mclFixInternalMatrix(mxArray *a);

extern mxArray *mclCreateGlobal(void); 
extern void mclMoveArraysToCurrentContext(int count, mxArray **ppa); 

/* This function is intended for use only by the MATLAB compiler. */
extern void mclAssignLastValue(mxArray **ans);

 
/* This function is intended for use only by the MATLAB compiler. */
extern mxArray *mclAssignAns(mxArray * volatile *dest, mxArray *src); 


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

extern mxArray *mlfReturnValue(mxArray *a); 


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


extern mxArray *mclPrintAns(mxArray * volatile *dest, mxArray *src); 

extern mxArray *mlfAssign(mxArray * volatile *dest, mxArray *src); 

extern void mlfClear(mxArray * volatile *var, ...);

extern mxArray *mclInitialize(mxArray *pa);

extern void mclValidateInputs(const char* fname, int nargs, ...);

extern void mclValidateOutputs(const char* fname, int noutputs, int nargout, ...);

extern void mclCopyArray(mxArray **pa);

extern void mlfEnterNewContext(int nout, int nin, ...);

extern void mlfRestorePreviousContext(int nout, int nin, ...);

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

extern ErrorHandlerFcn mlfSetErrorHandler(ErrorHandlerFcn EH);

extern int mlfPrintf(const char* fmt, ...);

extern void mlfSetPrintHandler(void (* PH)(const char *));

extern void mlfInitFcn(void);

extern void mlfCleanupFcn(void);

extern void mlfCleanupOutputArray(mxArray* pa);


#include <setjmp.h>



typedef void (*mclExceptionFcn)(void*);

typedef struct mclErrorContext_tag
{
  int depth;
  int allocContext;
  int arrayContext;
  int libraryContext;
} mclErrorContext;

typedef struct mclTryCatchContext_tag
{
  mclErrorContext err_ctx;
  int err_mode;
  jmp_buf *buffer;
  ErrorHandlerFcn err_handler;
  mclExceptionFcn except_fcn;
} mclTryCatchContext;
  

extern void mclNewErrorContext(mclErrorContext *errorCtx);

extern void mclRestoreErrorContext(mclErrorContext *errorCtx); 


typedef struct mclErrorContext_tag mclCppContext;
#define mclExitCppContext mclRestoreErrorContext

extern void mclEnterCppContext(mclCppContext *cppCtx);

extern void mclCppError(mclCppContext *cppCtx);

extern void mclMexError(void);

extern jmp_buf *mclGetSetjmpData();

extern void mclEnterTryCatchContext(mclTryCatchContext *ctx, jmp_buf *newbuf, mclExceptionFcn exception_fcn);

extern void mclExitTryCatchContext(mclTryCatchContext *ctx, int err_flag);


#ifdef MLF_ENABLE_TRYCATCH 

static void _mclExceptionFcn(void* msg)
{
    mclExceptionFcn dummy;
    dummy = _mclExceptionFcn; msg = 0;/* Prevents compiler warning */
    longjmp(*mclGetSetjmpData(), -1);
}

/*
 * Consider the following C source:
 *
 *   typedef long jb[5];
 *   ...
 *   jb b;
 *   jb *x = &b
 *
 * This causes the alpha compiler (and maybe others) to issue two warnings:
 *
 *   ... & before array "b" is ignored ...
 *
 *   ... the referenced type of the pointer value "&b" is "long",
 *       which is not compatible with "array [5] of long"
 *
 * Thus rather than &_mcl_tcbuf, which is what you might think is right,
 * the pointer needed in the second argument to mclEnterTryCatchContext is
 * obtained with a cast.
 */
#define mlfTry \
{ \
    jmp_buf _mcl_tcbuf; \
    mclTryCatchContext _mcl_ctx; \
    mclEnterTryCatchContext(&_mcl_ctx, (jmp_buf *)_mcl_tcbuf, _mclExceptionFcn); \
    if (!setjmp(_mcl_tcbuf)) {

#define mlfCatch \
        mclExitTryCatchContext(&_mcl_ctx, 0); \
    } else {{ \
        mclExitTryCatchContext(&_mcl_ctx, 1);

#define mlfEndCatch }}}

#endif


extern mxArray * mlfLasterr(mxArray * OI1);


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


#define mlfLasterror mlfLasterr

extern bool mclIsOutOfMemoryError(void); 

extern mxArray * mlfScalar(double v);

extern mxArray * mlfComplexScalar(double v, double i);

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

extern double *mlfGetPr(mxArray *pa);

extern void mlfSetPr(mxArray *pa, double *pr);

extern double *mlfGetPi(mxArray *pa);

extern void mlfSetPi(mxArray *pa, double *pi);

extern bool mclSwitchCompare(mxArray *switchvar, mxArray *casevar);

extern mxArray * mclCreateEmptyArray(void );


#define mclArrayToInt(x) ((int)(*mxGetPr(x)))
#define mlfBuiltin mlfVarargFeval

extern mxArray * mclCreateCellFromStrings(int count, const char** strings);

extern mxArray * mclCreateEmptyCell();

extern mxArray * mlfI(void);


#define mlfJ() mlfI()

extern bool mlfTobool(mxArray *RI1);

extern void mlfAddFlops(double f);

extern void mlfSetLibraryCalloc(void *func);

extern void mlfSetLibraryMalloc(void *func);

extern void mlfSetLibraryFree(void *func);

extern void mlfPrintMatrix(mxArray *RI1);

extern void mclPrintArray(mxArray *RI1, const char *name);

extern void mlfSave(mxArray *file, const char* mode, ... );

extern void mlfSave_v12(const char* file, const char* mode, ...);

extern void mlfLoad(mxArray *file, ... );

extern void mlfLoad_v12(const char* file, ...);

extern mxArray *mclCreateStructFromMatFile(mxArray *matfile, int numfields, char **names);

extern mxArray *mlfLoadStruct(mxArray *matfile, const char* name, ...);


#ifndef MLF_ENABLE_ND_ARRAYS
#define mlfSave mlfSave_v12
#define mlfLoad mlfLoad_v12
#endif


#include <stdarg.h>

#define MLFMAXVAR 100

#define mlfVararginDecls \
    int nrhs = 0, size = MLFMAXVAR; \
    mxArray *prhslocal[MLFMAXVAR], **prhs = prhslocal; \
    mxArray *patemp;

#define mlfVararginBody(varargin, last, uselast, ap) \
    if (uselast) { \
        patemp = last; \
    } else { \
        patemp = va_arg(ap, mxArray *); \
    } \
    while(patemp != NULL) { \
        prhs[nrhs++] = patemp; \
        if (nrhs == size) { \
            size = mclExpandVararginList(&prhs, size); \
        } \
        patemp = va_arg(ap, mxArray *); \
    } \
    mlfAssign(varargin, mclUnpackVararginToCell(nrhs, prhs)); \
    if (prhs != prhslocal) mxFree(prhs);

/* mlfVarargin assigns, via the varargin argument, a cell array which is temporary and
 * is in the caller's array list context.  Any temporary inputs to the varargs function
 * will be owned by the cell array.  The cell array will have a reference count of 1,
 * and must be explicitly destroyed.  */

/* Can't pass a va_list to a library compiled with a non-default compiler.  */
#if (defined(__WATCOMC__) || defined(__BORLANDC__) || (defined(__GNUC__) && !defined(__linux__)))
#define mlfVarargin( varargin, last, uselast) \
{ \
    mlfVararginDecls \
    va_list ap; \
    va_start(ap, last); \
    mlfVararginBody(varargin, (mxArray*)last, uselast, ap) \
    va_end(ap); \
}
#else
#define mlfVarargin( varargin, last, uselast) \
{ \
    va_list ap; \
    va_start(ap, last); \
    mclVarargin(varargin, (mxArray*)(void*)last, uselast, ap); \
    va_end(ap); \
}
#endif

 
/* For math library use only.  Do not call this function.*/
extern int mclExpandVararginList(mxArray ***prhs, int size); 

extern int mclUnpackCommaList(mxArray **prhs, mxArray *m, bool to_cell, bool is_cpp_array);

 
/* For math library use only.  Do not call this function.*/