gpc_step.cpp

广义预测控制的COM接口程序 VBheVC可调用 实现联合编程

//
// MATLAB Compiler: 3.0
// Date: Sat Jun 16 16:54:19 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:/VC/matlab/gpc/src" "-v" "-B" "cppsglcom:gpcVC,gpcVC,1.0" "-B"
// "csglcom:gpcVC,gpcVC,1.0" "-B" "sgl" "-m" "-W" "main" "-L" "C" "-t" "-T"
// "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg" "libmwsglm.mlib" "-t" "-W"
// "comhg:gpcVC,gpcVC,1.0" "-T" "link:lib" "-h" "libmmfile.mlib" "-i" "-L"
// "cpp" "-g" "-G" "-A" "debugline:on" "-O" "none" "-O"
// "fold_scalar_mxarrays:off" "-O" "fold_non_scalar_mxarrays:off" "-O"
// "optimize_integer_for_loops:off" "-O" "array_indexing:off" "-O"
// "optimize_conditionals:off" "-O" "speculate:off" "-i"
// "D:/matlab/work/GPC/GPC/gpc_step.m" 
//
#include "gpc_step.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
#include "libmwsglm.hpp"
#include "xlabel.hpp"

static double _array0_[3] = { 1.0, -0.8063, -0.1703 };

static double _array1_[3] = { 0.0012, 0.0013, 0.001 };
static mwArray _mxarray2_ = mclInitializeDouble(6.0);

void InitializeModule_gpc_step() {
}

void TerminateModule_gpc_step() {
}

static mwArray Mgpc_step(mwArray * ZZZ,
                         mwArray * UUU,
                         int nargout_,
                         mwArray TT,
                         mwArray P,
                         mwArray M,
                         mwArray q,
                         mwArray r,
                         mwArray c,
                         mwArray a);

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

//
// The function "gpc_step" contains the normal interface for the "gpc_step"
// M-function from file "d:\matlab\work\gpc\gpc\gpc_step.m" (lines 1-159). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
mwArray gpc_step(mwArray * ZZZ,
                 mwArray * UUU,
                 mwArray TT,
                 mwArray P,
                 mwArray M,
                 mwArray q,
                 mwArray r,
                 mwArray c,
                 mwArray a) {
    int nargout = 1;
    mwArray YYY = mwArray::UNDEFINED;
    mwArray ZZZ__ = mwArray::UNDEFINED;
    mwArray UUU__ = mwArray::UNDEFINED;
    if (ZZZ != NULL) {
        ++nargout;
    }
    if (UUU != NULL) {
        ++nargout;
    }
    YYY = Mgpc_step(&ZZZ__, &UUU__, nargout, TT, P, M, q, r, c, a);
    if (ZZZ != NULL) {
        *ZZZ = ZZZ__;
    }
    if (UUU != NULL) {
        *UUU = UUU__;
    }
    return YYY;
}

//
// The function "mlxGpc_step" contains the feval interface for the "gpc_step"
// M-function from file "d:\matlab\work\gpc\gpc\gpc_step.m" (lines 1-159). The
// feval function calls the implementation version of gpc_step through this
// function. This function processes any input arguments and passes them to the
// implementation version of the function, appearing above.
//
void mlxGpc_step(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[7];
        mwArray mplhs[3];
        int i;
        mclCppUndefineArrays(3, mplhs);
        if (nlhs > 3) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: gpc_step Line: 1 Column: "
                  "1 The function \"gpc_step\" was called with mor"
                  "e than the declared number of outputs (3).")));
        }
        if (nrhs > 7) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: gpc_step Line: 1 Column: "
                  "1 The function \"gpc_step\" was called with mor"
                  "e than the declared number of inputs (7).")));
        }
        for (i = 0; i < 7 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 7; ++i) {
            mprhs[i].MakeDIN();
        }
        mplhs[0]
          = Mgpc_step(
              &mplhs[1],
              &mplhs[2],
              nlhs,
              mprhs[0],
              mprhs[1],
              mprhs[2],
              mprhs[3],
              mprhs[4],
              mprhs[5],
              mprhs[6]);
        plhs[0] = mplhs[0].FreezeData();
        for (i = 1; i < 3 && i < nlhs; ++i) {
            plhs[i] = mplhs[i].FreezeData();
        }
    }
    MW_END_MLX();
}

//
// The function "Mgpc_step" is the implementation version of the "gpc_step"
// M-function from file "d:\matlab\work\gpc\gpc\gpc_step.m" (lines 1-159). 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[YYY,ZZZ,UUU]=gpc_step(TT,P,M,q,r,c,a)
//
static mwArray Mgpc_step(mwArray * ZZZ,
                         mwArray * UUU,
                         int nargout_,
                         mwArray TT,
                         mwArray P,
                         mwArray M,
                         mwArray q,
                         mwArray r,
                         mwArray c,
                         mwArray a) {
    mclMlineEnterFunction("d:\\matlab\\work\\gpc\\gpc\\gpc_step.m", "gpc_step")
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_gpc_step;
    mwArray YYY = mwArray::UNDEFINED;
    mwArray sample_time = mwArray::UNDEFINED;
    mwArray TT1 = mwArray::UNDEFINED;
    mwArray du = mwArray::UNDEFINED;
    mwArray YD = mwArray::UNDEFINED;
    mwArray Y = mwArray::UNDEFINED;
    mwArray DUU = mwArray::UNDEFINED;
    mwArray UU = mwArray::UNDEFINED;
    mwArray YY = mwArray::UNDEFINED;
    mwArray t = mwArray::UNDEFINED;
    mwArray temp = mwArray::UNDEFINED;
    mwArray H = mwArray::UNDEFINED;
    mwArray G = mwArray::UNDEFINED;
    mwArray Gj = mwArray::UNDEFINED;
    mwArray a3 = mwArray::UNDEFINED;
    mwArray a2 = mwArray::UNDEFINED;
    mwArray a1 = mwArray::UNDEFINED;
    mwArray m = mwArray::UNDEFINED;
    mwArray k = mwArray::UNDEFINED;
    mwArray j = mwArray::UNDEFINED;
    mwArray i = mwArray::UNDEFINED;
    mwArray E = mwArray::UNDEFINED;
    mwArray F = mwArray::UNDEFINED;
    mwArray y = mwArray::UNDEFINED;
    mwArray nb = mwArray::UNDEFINED;
    mwArray na = mwArray::UNDEFINED;
    mwArray nu = mwArray::UNDEFINED;
    mwArray ny = mwArray::UNDEFINED;
    mwArray RB = mwArray::UNDEFINED;
    mwArray RA = mwArray::UNDEFINED;
    mwArray B = mwArray::UNDEFINED;
    mwArray A = mwArray::UNDEFINED;
    mwArray R = mwArray::UNDEFINED;
    mwArray Q = mwArray::UNDEFINED;
    mwArray ans = mwArray::UNDEFINED;
    //
    // clc;
    //
    mclMline(2);
    clc();
    //
    // 
    // %%%%   [YYY,ZZZ,UUU]=gpc_step(1000,3,3,1,0.01,1,0.95)
    // 
    // 
    // %clear;
    // %P=3;                               %预测时域长度
    // %M=3;                               %控制时域长度
    // %TT=1000;                             %仿真步数
    // 
    // TT;
    //
    mclMline(12);
    mwVa(TT, "TT");
    //
    // P;
    //
    mclMline(13);
    mwVa(P, "P");
    //
    // M;
    //
    mclMline(14);
    mwVa(M, "M");
    //
    // c;
    //
    mclMline(15);
    mwVa(c, "c");
    //
    // a;
    //
    mclMline(16);
    mwVa(a, "a");
    //
    // q;
    //
    mclMline(17);
    mwVa(q, "q");
    //
    // r;
    //
    mclMline(18);
    mwVa(r, "r");
    //
    // 
    // 
    // Q=q*eye(P,P);                      %误差权矩阵
    //
    mclMline(21);
    Q = mwVa(q, "q") * eye(mwVa(P, "P"), mwVa(P, "P"));
    //
    // R=r*eye(M,M);                    %控制权矩阵
    //
    mclMline(22);
    R = mwVa(r, "r") * eye(mwVa(M, "M"), mwVa(M, "M"));
    //
    // %c=1;                               %设定值
    // %a=0.95;                             %参考轨迹柔化系数
    // %A=[0.0021 0.0021 0.0021];                        %A,B为系统的实际参数
    // %B=[1 -0.6671 -0.2993];
    // A=[1 -0.8063 -0.1703];
    //
    mclMline(27);
    A = mwArray(1, 3, _array0_, (double *)NULL);
    //
    // B=[0.0012 0.0013 0.001];
    //
    mclMline(28);
    B = mwArray(1, 3, _array1_, (double *)NULL);
    //
    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    // %RA=[1 0.6];                       %RA,RB为预测模型失配时的参数
    // %RB=[0.2 -0.3];
    // RA=A;
    //
    mclMline(32);
    RA = mwVv(A, "A");
    //
    // RB=B;
    //
    mclMline(33);
    RB = mwVv(B, "B");
    //
    // %RA=[1 -0.2342 0.002479];
    // %RB=[-0.6825 -0.3419];
    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    // ny=length(RA)-1;                   %取实际对象输出时滞
    //
    mclMline(37);
    ny = mclLengthInt(mwVv(RA, "RA")) - 1;
    //
    // nu=length(RB)-1;                   %取实际对象输入时滞    
    //
    mclMline(38);
    nu = mclLengthInt(mwVv(RB, "RB")) - 1;
    //
    // na=length(A)-1;
    //
    mclMline(39);
    na = mclLengthInt(mwVv(A, "A")) - 1;
    //
    // nb=length(B)-1;
    //
    mclMline(40);
    nb = mclLengthInt(mwVv(B, "B")) - 1;
    //
    // y=zeros(P,1);                      %初始预测值y
    //
    mclMline(41);
    y = zeros(mwVarargin(mwVa(P, "P"), 1));
    //
    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    // F=zeros(P,na+1);           
    //
    mclMline(43);
    F = zeros(mwVarargin(mwVa(P, "P"), mwVv(na, "na") + 1));
    //
    // E=zeros(P,P);
    //
    mclMline(44);
    E = zeros(mwVarargin(mwVa(P, "P"), mwVa(P, "P")));
    //
    // E(1,1)=1;
    //
    mclMline(45);
    E(1, 1) = 1;
    //
    // for i=1:na
    //
    mclMline(46);
    {
        mwForLoopIterator viter__;
        for (viter__.Start(1, mwVv(na, "na"), mwArray::DIN);
             viter__.Next(&i);
             ) {
            //
            // F(1,i)=-(A(i+1)-A(i));
            //
            mclMline(47);
            F(1, mwVv(i, "i"))
            = - (mwVv(A, "A")(mwVv(i, "i") + 1) - mwVv(A, "A")(mwVv(i, "i")));
        //
        // end
        //
        mclMline(48);
        }
    }
    //
    // F(1,na+1)=A(na+1);
    //
    mclMline(49);
    F(1, mwVv(na, "na") + 1) = mwVv(A, "A")(mwVv(na, "na") + 1);
    //
    // for j=2:P
    //
    mclMline(50);
    {
        mwForLoopIterator viter__;
        for (viter__.Start(2, mwVa(P, "P"), mwArray::DIN); viter__.Next(&j); ) {
            //
            // E(j,:)=E(j-1,:);
            //
            mclMline(51);
            E(mwVv(j, "j"), colon()) = mwVv(E, "E")(mwVv(j, "j") - 1, colon());
            //
            // for k=1:na+1
            //
            mclMline(52);
            {
                mwForLoopIterator viter__0;
                for (viter__0.Start(1, mwVv(na, "na") + 1, mwArray::DIN);
                     viter__0.Next(&k);
                     ) {
                    //
                    // if F(j-1,k)~=0
                    //
                    mclMline(53);
                    if (tobool(
                          mwVv(F, "F")(mwVv(j, "j") - 1, mwVv(k, "k")) != 0)) {
                        //
                        // E(j,j)=F(j-1,k);
                        //
                        mclMline(54);
                        E(mwVv(j, "j"), mwVv(j, "j"))
                        = mwVv(F, "F")(mwVv(j, "j") - 1, mwVv(k, "k"));
                        //
                        // break;                   %%注意不用的后果，容易出错
                        //
                        mclMline(55);
                        break;
                    //
                    // end
                    //
                    }
                //
                // end
                //
                mclMline(57);
                }
            }
            //
            // for i=1:na+1
            //
            mclMline(58);
            {
                mwForLoopIterator viter__1;
                for (viter__1.Start(1, mwVv(na, "na") + 1, mwArray::DIN);
                     viter__1.Next(&i);
                     ) {
                    //
                    // if F(j-1,i)==0
                    //
                    mclMline(59);
                    if (tobool(
                          mwVv(F, "F")(mwVv(j, "j") - 1, mwVv(i, "i")) == 0)) {
                        //
                        // F(j,i)=0;
                        //
                        mclMline(60);
                        F(mwVv(j, "j"), mwVv(i, "i")) = 0;
                    //
                    // end
                    //
                    mclMline(61);
                    }
                    //
                    // if F(j-1,i)~=0
                    //
                    mclMline(62);
                    if (tobool(
                          mwVv(F, "F")(mwVv(j, "j") - 1, mwVv(i, "i")) != 0)) {
                        //
                        // break;
                        //
                        mclMline(63);
                        break;
                    //
                    // end
                    //
                    }
                //
                // end
                //
                mclMline(65);
                }
            }
            //
            // if i==1                            %%表示F的第一列没有0的情况，使用没有改进的算法
            //
            mclMline(66);
            if (tobool(mwVv(i, "i") == 1)) {
                mwForLoopIterator viter__2;
                //
                // for m=1:na
                //
                mclMline(67);
                for (viter__2.Start(1, mwVv(na, "na"), mwArray::DIN);
                     viter__2.Next(&m);
                     ) {
                    //
                    // % F(j,m)=F(j-1,m+1)-(A(m+1)-A(m))*E(j,j);
                    // a1=F(j-1,m+1);
                    //
                    mclMline(69);
                    a1 = mwVv(F, "F")(mwVv(j, "j") - 1, mwVv(m, "m") + 1);
                    //
                    // a2=(A(m+1)-A(m));
                    //
                    mclMline(70);
                    a2
                      = mwVv(A, "A")(mwVv(m, "m") + 1)
                        - mwVv(A, "A")(mwVv(m, "m"));
                    //
                    // a3=E(j,j);
                    //
                    mclMline(71);
                    a3 = mwVv(E, "E")(mwVv(j, "j"), mwVv(j, "j"));
                    //