fun_dmcsim.cpp

DMC VC++ 的程序 给大学生毕业用 啦 其它不多说了 用了就知道！

//
// MATLAB Compiler: 3.0
// Date: Sat May 15 16:36:22 2004
// 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" "-t" "-L" "Cpp"
// "fun_dmcsim" 
//
#include "fun_dmcsim.hpp"
#include "libmatlbm.hpp"
static mwArray _mxarray0_ = mclInitializeDouble(50.0);
static mwArray _mxarray1_ = mclInitializeDouble(10.0);
static mwArray _mxarray2_ = mclInitializeDouble(1.0);
static mwArray _mxarray3_ = mclInitializeDouble(0.0);
static mwArray _mxarray4_ = mclInitializeDouble(.1);
static mwArray _mxarray5_ = mclInitializeDouble(6.0);

static double _array7_[4] = { -2.4048, .8333, 0.0, -2.2381 };
static mwArray _mxarray6_ = mclInitializeDoubleVector(2, 2, _array7_);

static double _array9_[2] = { 7.0, -1.117 };
static mwArray _mxarray8_ = mclInitializeDoubleVector(2, 1, _array9_);

static double _array11_[2] = { 0.0, 1.0 };
static mwArray _mxarray10_ = mclInitializeDoubleVector(1, 2, _array11_);

static double _array13_[4] = { .7863, .0661, 0.0, .7995 };
static mwArray _mxarray12_ = mclInitializeDoubleVector(2, 2, _array13_);

static double _array15_[2] = { .6222, -.0751 };
static mwArray _mxarray14_ = mclInitializeDoubleVector(2, 1, _array15_);

static double _array17_[50] = { -.0751, -.094, -.0768, -.0376, .0137, .0704,
                                .1281, .184, .2362, .284, .327, .365, .3983,
                                .4273, .4522, .4735, .4917, .5071, .5202,
                                .5311, .5403, .548, .5544, .5597, .5641, .5678,
                                .5708, .5733, .5753, .577, .5784, .5796, .5805,
                                .5813, .5819, .5824, .5829, .5832, .5835,
                                .5837, .5839, .584, .5842, .5843, .5843, .5844,
                                .5845, .5845, .5845, .5846 };
static mwArray _mxarray16_ = mclInitializeDoubleVector(50, 1, _array17_);
static mwArray _mxarray18_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
static mwArray _mxarray19_ = mclInitializeDouble(2.0);
static mwArray _mxarray20_ = mclInitializeDouble(3.0);

void InitializeModule_fun_dmcsim() {
}

void TerminateModule_fun_dmcsim() {
}

static mwArray Mfun_dmcsim(mwArray * u,
                           mwArray * r,
                           mwArray * y,
                           int nargout_,
                           mwArray g1);

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

//
// The function "fun_dmcsim" contains the normal interface for the "fun_dmcsim"
// M-function from file "h:\刘建军\fun_dmcsim.m" (lines 1-228). This function
// processes any input arguments and passes them to the implementation version
// of the function, appearing above.
//
mwArray fun_dmcsim(mwArray * u, mwArray * r, mwArray * y, mwArray g1) {
    int nargout = 1;
    mwArray s = mwArray::UNDEFINED;
    mwArray u__ = mwArray::UNDEFINED;
    mwArray r__ = mwArray::UNDEFINED;
    mwArray y__ = mwArray::UNDEFINED;
    if (u != NULL) {
        ++nargout;
    }
    if (r != NULL) {
        ++nargout;
    }
    if (y != NULL) {
        ++nargout;
    }
    s = Mfun_dmcsim(&u__, &r__, &y__, nargout, g1);
    if (u != NULL) {
        *u = u__;
    }
    if (r != NULL) {
        *r = r__;
    }
    if (y != NULL) {
        *y = y__;
    }
    return s;
}

//
// The function "mlxFun_dmcsim" contains the feval interface for the
// "fun_dmcsim" M-function from file "h:\刘建军\fun_dmcsim.m" (lines 1-228).
// The feval function calls the implementation version of fun_dmcsim through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxFun_dmcsim(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[1];
        mwArray mplhs[4];
        int i;
        mclCppUndefineArrays(4, mplhs);
        if (nlhs > 4) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: fun_dmcsim Line: 1 Column:"
                  " 1 The function \"fun_dmcsim\" was called with m"
                  "ore than the declared number of outputs (4).")));
        }
        if (nrhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: fun_dmcsim Line: 1 Column:"
                  " 1 The function \"fun_dmcsim\" was called with m"
                  "ore than the declared number of inputs (1).")));
        }
        for (i = 0; i < 1 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 1; ++i) {
            mprhs[i].MakeDIN();
        }
        mplhs[0] = Mfun_dmcsim(&mplhs[1], &mplhs[2], &mplhs[3], nlhs, mprhs[0]);
        plhs[0] = mplhs[0].FreezeData();
        for (i = 1; i < 4 && i < nlhs; ++i) {
            plhs[i] = mplhs[i].FreezeData();
        }
    }
    MW_END_MLX();
}

//
// The function "Mfun_dmcsim" is the implementation version of the "fun_dmcsim"
// M-function from file "h:\刘建军\fun_dmcsim.m" (lines 1-228). 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 [s,u,r,y]=fun_dmcsim(g1)
//
static mwArray Mfun_dmcsim(mwArray * u,
                           mwArray * r,
                           mwArray * y,
                           int nargout_,
                           mwArray g1) {
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_fun_dmcsim;
    mwArray s = mwArray::UNDEFINED;
    mwArray ymod = mwArray::UNDEFINED;
    mwArray du = mwArray::UNDEFINED;
    mwArray delu = mwArray::UNDEFINED;
    mwArray e_free = mwArray::UNDEFINED;
    mwArray y_free = mwArray::UNDEFINED;
    mwArray rvec = mwArray::UNDEFINED;
    mwArray dvec = mwArray::UNDEFINED;
    mwArray uold = mwArray::UNDEFINED;
    mwArray rrr = mwArray::UNDEFINED;
    mwArray delup = mwArray::UNDEFINED;
    mwArray k = mwArray::UNDEFINED;
    mwArray dist = mwArray::UNDEFINED;
    mwArray x = mwArray::UNDEFINED;
    mwArray sn = mwArray::UNDEFINED;
    mwArray dup = mwArray::UNDEFINED;
    mwArray yinit = mwArray::UNDEFINED;
    mwArray uinit = mwArray::UNDEFINED;
    mwArray xinit = mwArray::UNDEFINED;
    mwArray Kmat = mwArray::UNDEFINED;
    mwArray Sp = mwArray::UNDEFINED;
    mwArray i = mwArray::UNDEFINED;
    mwArray Sf = mwArray::UNDEFINED;
    mwArray j = mwArray::UNDEFINED;
    mwArray w = mwArray::UNDEFINED;
    mwArray dd = mwArray::UNDEFINED;
    mwArray cd = mwArray::UNDEFINED;
    mwArray gama = mwArray::UNDEFINED;
    mwArray phi = mwArray::UNDEFINED;
    mwArray dp = mwArray::UNDEFINED;
    mwArray cp = mwArray::UNDEFINED;
    mwArray bp = mwArray::UNDEFINED;
    mwArray ap = mwArray::UNDEFINED;
    mwArray d = mwArray::UNDEFINED;
    mwArray c = mwArray::UNDEFINED;
    mwArray b = mwArray::UNDEFINED;
    mwArray a = mwArray::UNDEFINED;
    mwArray ksp = mwArray::UNDEFINED;
    mwArray kfinal = mwArray::UNDEFINED;
    mwArray t = mwArray::UNDEFINED;
    mwArray noise = mwArray::UNDEFINED;
    mwArray tfinal = mwArray::UNDEFINED;
    mwArray delt = mwArray::UNDEFINED;
    mwArray timesp = mwArray::UNDEFINED;
    mwArray ysp = mwArray::UNDEFINED;
    mwArray weight = mwArray::UNDEFINED;
    mwArray m = mwArray::UNDEFINED;
    mwArray p = mwArray::UNDEFINED;
    mwArray n = mwArray::UNDEFINED;
    //
    // % dmcsim
    // 
    // % May 25, 2005 for APC Lecture
    // % Zhao Zhong 
    // % unconstrained SISO DMC Simulation, calls: smatgen.m and dmccalc.m
    // 
    // % MPC tuning and simulation parameters
    // n = 50;             % model length
    //
    n = _mxarray0_;
    //
    // p = 10;             % prediction horizon
    //
    p = _mxarray1_;
    //
    // m = 1;              % control horizon
    //
    m = _mxarray2_;
    //
    // weight = 0.0;       % weight factor
    //
    weight = _mxarray3_;
    //
    // ysp = 1;            % setpoint change (from 0)
    //
    ysp = _mxarray2_;
    //
    // timesp = 1;         % time of setpoint change
    //
    timesp = _mxarray2_;
    //
    // delt = 0.1;         % sample time
    //
    delt = _mxarray4_;
    //
    // tfinal = 6;         % final simulation time
    //
    tfinal = _mxarray5_;
    //
    // noise = 0;          % noise added to resonse cofficients
    //
    noise = _mxarray3_;
    //
    // 
    // t =0: delt:tfinal; % time vector   t的取值从0至tfinal,间隔为delt.如t=0:2:10,                     % 则t取值为0，2，4，6，8，10
    //
    t = colon(_mxarray3_, mwVv(delt, "delt"), mwVv(tfinal, "tfinal"));
    //
    // kfinal = length(t); % number of time intervals，上例中，length(t)=6
    //
    kfinal = mclLengthInt(mwVv(t, "t"));
    //
    // 
    // ksp = fix(timesp/delt);      %取整
    //
    ksp = fix(mwVv(timesp, "timesp") / mwVv(delt, "delt"));
    //
    // r = [zeros(ksp,1);ones(kfinal-ksp,1)*ysp]; % setpoint vector，构造列向量，前                                           % ksp个值为0，后面的制为ysp，向量                                             % 长度为kfinal
    //
    *r
      = vertcat(
          mwVarargin(
            zeros(mwVarargin(mwVv(ksp, "ksp"), _mxarray2_)),
            ones(
              mwVarargin(
                mwVv(kfinal, "kfinal") - mwVv(ksp, "ksp"), _mxarray2_))
            * mwVv(ysp, "ysp")));
    //
    // %
    // % -------- insert continuous model here -----------
    // % model (continuous state space form)
    // % 
    // a = [-2.4048 0; 0.8333 -2.2381]; % a matrix
    //
    a = _mxarray6_;
    //
    // b = [7; -1.117];                 % b matrix
    //
    b = _mxarray8_;
    //
    // c = [0 1];                       % c matrix
    //
    c = _mxarray10_;
    //
    // d = 0;                           % d
    //
    d = _mxarray3_;
    //
    // 
    // 
    // % sysc_mod = ss(a,b,c,d); % create LTI OBJECT  状态空间模型
    // a=[ -2.4048         0; 0.8333   -2.2381 ] ;
    //
    a = _mxarray6_;
    //
    // b=[7.0000; -1.1170];
    //
    b = _mxarray8_;
    //
    // c= [0     1 ];
    //
    c = _mxarray10_;
    //
    // d=0;
    //
    d = _mxarray3_;
    //
    // 
    // 
    // 
    // %
    // % --------- insert plant here ----------------
    // % perfect model assumption (plant = model)
    // ap = a;
    //
    ap = mwVv(a, "a");
    //
    // bp = b;
    //
    bp = mwVv(b, "b");
    //
    // cp = c;
    //
    cp = mwVv(c, "c");
    //
    // dp = d;
    //
    dp = mwVv(d, "d");
    //
    // 
    // 
    // % sysc_plant = ss(ap,bp,cp,dp);    %状态空间模型，初始值为LTI OBJECT，估计是迭 %代用的，你看看算法
    // %
    // 
    // 
    // % discretize the plant with a sample time, delt
    // % 
    // % sysd_plant = c2d(sysc_plant,delt);  %把连续的状态空间模型离散化，采样时间delt
    // % [phi,gama,cd,dd] = ssdata(sysd_plant);  %把离散化得到的模型转化为状态空间的矩%阵，phi,gama,cd,dd分别对应状态空间模         
    // 
    // phi=[ 0.7863     0; 0.0661    0.7995 ];
    //
    phi = _mxarray12_;
    //
    // gama=[0.6222 ; -0.0751 ];
    //
    gama = _mxarray14_;
    //
    // cd=[0 1];  dd=[0];
    //
    cd = _mxarray10_;
    dd = _mxarray3_;
    //
    // 
    // %型中的A,B,C,D
    // %
    // % evaluate discrete model step response coefficients
    // %
    // 
    // % [s] = step(sysc_mod,[delt:delt:n*delt]);   %sysc_mod的阶跃响应，仿真从delt时
    // %间开始，间隔delt，在n*delt处结束
    // %返回响应给s，s为n维列向量(n个响应)
    // s=[ -0.0751
    //
    s = _mxarray16_;
    //
    // -0.0940
    // -0.0768
    // -0.0376
    // 0.0137
    // 0.0704
    // 0.1281