lmsimu.c

nnToolKit 神经网络工具包是基于 MATLAB 神经网络工具箱自行开发的一组神经网络算法函数库

/*
 * MATLAB Compiler: 3.0
 * Date: Sun May 13 16:47:40 2007
 * Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
 * "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
 * "array_indexing:on" "-O" "optimize_conditionals:on" "-M" "-silentsetup" "-d"
 * "d:/MATLAB6p5/work/nnToolKit/src" "-B" "csglcom:nnToolKit,nnToolKit,2.0"
 * "-B" "sgl" "-m" "-W" "main" "-L" "C" "-t" "-T" "link:exe" "-h"
 * "libmmfile.mlib" "-W" "mainhg" "libmwsglm.mlib" "-t" "-W"
 * "comhg:nnToolKit,nnToolKit,2.0" "-T" "link:lib" "-h" "libmmfile.mlib" "-i"
 * "-i" "D:/MATLAB6p5/work/nnToolKit/lmnet/LmSimu.m"
 * "D:/MATLAB6p5/work/nnToolKit/lmnet/LmTrain.m"
 * "D:/MATLAB6p5/work/nnToolKit/sofm/SofmSimu.m"
 * "D:/MATLAB6p5/work/nnToolKit/sofm/SofmTrain.m" 
 */
#include "lmsimu.h"
#include "libmatlbm.h"
#include "libmmfile.h"
#include "logsig.h"
#include "nntwarn.h"
#include "purelin.h"
#include "simuff.h"
#include "tansig.h"

static mxChar _array1_[3] = { 'O', 'F', 'F' };
static mxArray * _mxarray0_;
static mxArray * _mxarray2_;

static mxChar _array4_[6] = { 't', 'a', 'n', 's', 'i', 'g' };
static mxArray * _mxarray3_;

static mxChar _array6_[7] = { 'p', 'u', 'r', 'e', 'l', 'i', 'n' };
static mxArray * _mxarray5_;

static mxChar _array8_[5] = { 'w', '%', 's', '%', 's' };
static mxArray * _mxarray7_;

static mxChar _array10_[5] = { '1', '.', 'd', 'a', 't' };
static mxArray * _mxarray9_;

static mxChar _array12_[1] = { 'r' };
static mxArray * _mxarray11_;

static mxChar _array14_[5] = { 'b', '%', 's', '%', 's' };
static mxArray * _mxarray13_;

static mxChar _array16_[5] = { '2', '.', 'd', 'a', 't' };
static mxArray * _mxarray15_;

static mxChar _array18_[2] = { '%', 'f' };
static mxArray * _mxarray17_;
static mxArray * _mxarray19_;
static mxArray * _mxarray20_;

static mxChar _array22_[10] = { 'r', 'e', 's', 'u', 'l',
                                't', '%', 's', '%', 's' };
static mxArray * _mxarray21_;

static mxChar _array24_[4] = { '.', 'd', 'a', 't' };
static mxArray * _mxarray23_;

static mxChar _array26_[1] = { 'w' };
static mxArray * _mxarray25_;

static mxChar _array28_[9] = { '%', '-', '1', '5', '.', '6', 'f', 0x005c, 'n' };
static mxArray * _mxarray27_;

void InitializeModule_lmsimu(void) {
    _mxarray0_ = mclInitializeString(3, _array1_);
    _mxarray2_ = mclInitializeDouble(-1.0);
    _mxarray3_ = mclInitializeString(6, _array4_);
    _mxarray5_ = mclInitializeString(7, _array6_);
    _mxarray7_ = mclInitializeString(5, _array8_);
    _mxarray9_ = mclInitializeString(5, _array10_);
    _mxarray11_ = mclInitializeString(1, _array12_);
    _mxarray13_ = mclInitializeString(5, _array14_);
    _mxarray15_ = mclInitializeString(5, _array16_);
    _mxarray17_ = mclInitializeString(2, _array18_);
    _mxarray19_ = mclInitializeDouble(1.0);
    _mxarray20_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
    _mxarray21_ = mclInitializeString(10, _array22_);
    _mxarray23_ = mclInitializeString(4, _array24_);
    _mxarray25_ = mclInitializeString(1, _array26_);
    _mxarray27_ = mclInitializeString(9, _array28_);
}

void TerminateModule_lmsimu(void) {
    mxDestroyArray(_mxarray27_);
    mxDestroyArray(_mxarray25_);
    mxDestroyArray(_mxarray23_);
    mxDestroyArray(_mxarray21_);
    mxDestroyArray(_mxarray20_);
    mxDestroyArray(_mxarray19_);
    mxDestroyArray(_mxarray17_);
    mxDestroyArray(_mxarray15_);
    mxDestroyArray(_mxarray13_);
    mxDestroyArray(_mxarray11_);
    mxDestroyArray(_mxarray9_);
    mxDestroyArray(_mxarray7_);
    mxDestroyArray(_mxarray5_);
    mxDestroyArray(_mxarray3_);
    mxDestroyArray(_mxarray2_);
    mxDestroyArray(_mxarray0_);
}

static mxArray * Mlmsimu(int nargout_,
                         mxArray * ModelNo,
                         mxArray * NetPara,
                         mxArray * SimulatePara,
                         mxArray * InputFun,
                         mxArray * OutputFun,
                         mxArray * DataDir);

_mexLocalFunctionTable _local_function_table_lmsimu
  = { 0, (mexFunctionTableEntry *)NULL };

/*
 * The function "mlfLmsimu" contains the normal interface for the "lmsimu"
 * M-function from file "d:\matlab6p5\work\nntoolkit\lmnet\lmsimu.m" (lines
 * 1-76). This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
mxArray * mlfLmsimu(mxArray * ModelNo,
                    mxArray * NetPara,
                    mxArray * SimulatePara,
                    mxArray * InputFun,
                    mxArray * OutputFun,
                    mxArray * DataDir) {
    int nargout = 1;
    mxArray * retdouble = NULL;
    mlfEnterNewContext(
      0, 6, ModelNo, NetPara, SimulatePara, InputFun, OutputFun, DataDir);
    retdouble
      = Mlmsimu(
          nargout,
          ModelNo,
          NetPara,
          SimulatePara,
          InputFun,
          OutputFun,
          DataDir);
    mlfRestorePreviousContext(
      0, 6, ModelNo, NetPara, SimulatePara, InputFun, OutputFun, DataDir);
    return mlfReturnValue(retdouble);
}

/*
 * The function "mlxLmsimu" contains the feval interface for the "lmsimu"
 * M-function from file "d:\matlab6p5\work\nntoolkit\lmnet\lmsimu.m" (lines
 * 1-76). The feval function calls the implementation version of lmsimu through
 * this function. This function processes any input arguments and passes them
 * to the implementation version of the function, appearing above.
 */
void mlxLmsimu(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    mxArray * mprhs[6];
    mxArray * mplhs[1];
    int i;
    if (nlhs > 1) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: lmsimu Line: 4 Column: "
            "1 The function \"lmsimu\" was called with mor"
            "e than the declared number of outputs (1)."),
          NULL);
    }
    if (nrhs > 6) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: lmsimu Line: 4 Column: "
            "1 The function \"lmsimu\" was called with mor"
            "e than the declared number of inputs (6)."),
          NULL);
    }
    for (i = 0; i < 1; ++i) {
        mplhs[i] = NULL;
    }
    for (i = 0; i < 6 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 6; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(
      0, 6, mprhs[0], mprhs[1], mprhs[2], mprhs[3], mprhs[4], mprhs[5]);
    mplhs[0]
      = Mlmsimu(
          nlhs, mprhs[0], mprhs[1], mprhs[2], mprhs[3], mprhs[4], mprhs[5]);
    mlfRestorePreviousContext(
      0, 6, mprhs[0], mprhs[1], mprhs[2], mprhs[3], mprhs[4], mprhs[5]);
    plhs[0] = mplhs[0];
}

/*
 * The function "Mlmsimu" is the implementation version of the "lmsimu"
 * M-function from file "d:\matlab6p5\work\nntoolkit\lmnet\lmsimu.m" (lines
 * 1-76). It contains the actual compiled code for that M-function. It is a
 * static function and must only be called from one of the interface functions,
 * appearing below.
 */
/*
 * %此为一仿真程序
 * %首先读入权域值参数
 * 
 * function retdouble = LmSimu(ModelNo,NetPara,SimulatePara,InputFun,OutputFun,DataDir)
 */
static mxArray * Mlmsimu(int nargout_,
                         mxArray * ModelNo,
                         mxArray * NetPara,
                         mxArray * SimulatePara,
                         mxArray * InputFun,
                         mxArray * OutputFun,
                         mxArray * DataDir) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_lmsimu);
    mxArray * retdouble = NULL;
    mxArray * fwresult = NULL;
    mxArray * a = NULL;
    mxArray * p1 = NULL;
    mxArray * i = NULL;
    mxArray * b2 = NULL;
    mxArray * w2 = NULL;
    mxArray * b1 = NULL;
    mxArray * count = NULL;
    mxArray * w1 = NULL;
    mxArray * MidDim = NULL;
    mxArray * OutputDim = NULL;
    mxArray * InputDim = NULL;
    mxArray * frb2 = NULL;
    mxArray * frw2 = NULL;
    mxArray * frb1 = NULL;
    mxArray * frw1 = NULL;
    mxArray * olddir = NULL;
    mxArray * ans = NULL;
    mclCopyArray(&ModelNo);
    mclCopyArray(&NetPara);
    mclCopyArray(&SimulatePara);
    mclCopyArray(&InputFun);
    mclCopyArray(&OutputFun);
    mclCopyArray(&DataDir);
    /*
     * NNTWARN OFF
     */
    mlfNntwarn(_mxarray0_);
    /*
     * 
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * %ModelNo='1';
     * %NetPara(1)=7;
     * %NetPara(2)=1;
     * %NetPara(3)=28;
     * 
     * %SimulatePara(1)=0.495723;
     * %SimulatePara(2)=0.286143;
     * %SimulatePara(3)=0.849300;
     * %SimulatePara(4)=0.839320;
     * %SimulatePara(5)=0.932467;
     * %SimulatePara(6)=0.428714;
     * %SimulatePara(7)=0.100800;
     * 
     * %DataDir='.';
     * %InputFun = 'tansig';
     * %OutputFun = 'purelin';
     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     * retdouble = -1;
     */
    mlfAssign(&retdouble, _mxarray2_);
    /*
     * olddir=pwd;
     */
    mlfAssign(&olddir, mlfPwd());
    /*
     * % 数据所在目录
     * cd(DataDir);
     */
    mclAssignAns(&ans, mlfNCd(0, mclVa(DataDir, "DataDir")));
    /*