unit Discrete;

interface

uses WinTypes,WinProcs,gltype,glproc,MathObj,Math, Classes, SysUtils, MVTU_TLB;

function TDis0(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
function TDis1(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
function TDis2(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
function TDis3(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
function TDis4(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
function TDis5(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
function TDis6(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
function TDis7(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
function TDis8(at,adt:RealType;var time,dtime:RealType;var AU,AY:TPtrExt;var AX,ADX:array of RealType;
               var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;Action:Integer):Integer;export;
{#######################################################################################################}

                               IMPLEMENTATION

{#######################################################################################################}
type
 PDis0Rec = ^TDis0Rec;
 TDis0Rec = record
  It  : PInteger;
  Y0  : TExtArray;
 end;

 PDis1Rec = ^TDis1Rec;
 TDis1Rec = record
  tau : PRealType
 end;

 PDis2Rec = ^TDis2Rec;
 TDis2Rec = record
  tau : PRealType;
  Y0  : TExtArray;
 end;

 PDis3Rec = ^TDis3Rec;
 TDis3Rec = record
  b,a : TExtArray;
  tau : PRealType;
  Y0  : TExtArray;
 end;

 PDis5Rec = ^TDis5Rec;
 TDis5Rec = record
  Kp,Ki,Kd : PRealType;
  tau : PRealType;
  Y0  : TExtArray;
 end;

 PDis6Rec = ^TDis6Rec;
 TDis6Rec = record
  xc,uc,yc    : ^Integer;
  A_,B_,C_,D_ : TExtArray2;
  Y0          : TExtArray;
  tau         : PRealType;
 end;

{---------------------------------------------------------------------------
Запаздывание на один временной шаг
---------------------------------------------------------------------------}
function TDis0Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Задержка на шаг интегрирования';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: with PDis0Rec(Prop.arr)^ do begin
                   MVTU.SetBlockProp(BlockId,'it',PChar(IntToStr(it^)),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(ConvertVector(PropStr[1])),Res);
                 end;
  end;
end;

function TDis0;
var j : Integer;
begin
 Result:=0;
 with PDis0Rec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TDis0Convert);
//  f_GetDeriCount  : Result:=0;
  f_GetStateCount : Result:=Y0.Count;
  f_GetInit       : case it^ of
                     0,2:Result:=0;
                     else Result:=1
                    end;
  f_GetCount      : begin
                     CY.arr^[0]:=Y0.Count;
                     CU.arr^[0]:=Y0.Count
                    end;
  f_InitState,
  f_InitMem       : Move(Y0.arr^,AY.Ptr(0).arr^,Y0.Count*SOfR);
  f_InitTime      : begin
                     time:=at;
                     dtime:=0
                    end;
  f_UpdateJacoby  : for j:=0 to Y0.Count-1 do AY.Ptr(0).arr^[j]:=AU.Ptr(0).arr^[j];
  f_UpdateOuts    : case it^ of
                     2,3: for j:=0 to Y0.Count-1 do begin
                           AX[j]:=AU.Ptr(0).arr^[j];
                           AY.Ptr(0).arr^[j]:=AX[j]
                          end;
                    end;
  f_RestoreOuts,
  f_GoodStep      : for j:=0 to Y0.Count-1 do AY.Ptr(0).arr^[j]:=AX[j];
  f_GetState      : begin
                     for j:=0 to Y0.Count-1 do AX[j]:=AU.Ptr(0).arr^[j];
                     dtime:=at-time;
                     time:=at
                    end;
  f_JacobyState   : for j:=0 to Y0.Count-1 do ADX[j]:=AU.Ptr(0).arr^[j];
  f_GetDelayTime  : AX[0]:=dtime;
//  f_SteadyState   : Move(AY.Ptr(0).arr^,Y0.arr^,Y0.Count*SOfR);
 end
end;
{---------------------------------------------------------------------------
 Экстраполятор нулевого порядка
---------------------------------------------------------------------------}
function TDis1Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Экстраполятор';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin
                   MVTU.SetBlockProp(BlockId,'tau',PChar(PropStr[0]),Res);
                 end;
  end;
end;

function TDis1;
var j : Integer;
begin
 Result:=0;
 with PDis1Rec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TDis1Convert);
  f_GetStateCount : Result:=max(CU.arr^[0],1);
  f_GetCount      : CY.arr^[0]:=CU.arr^[0];
  f_InitTime      : begin
                     time:=at;
                     dtime:=tau^
                    end;
  f_GetDelayTime  : AX[0]:=dtime;
  f_InitState,
  f_InitMem       : Move(AU.Ptr(0).arr^,AY.Ptr(0).arr^,AU.Ptr(0).Count*SOfR);
  f_RestoreOuts   : for j:=0 to AY.Ptr(0).Count-1 do AY.Ptr(0).arr^[j]:=AX[j];
  f_GoodStep      : if time-at <= adt/2 then
                     Move(AU.Ptr(0).arr^,AY.Ptr(0).arr^,AU.Ptr(0).Count*SOfR);
  f_GetState      : if time-at <= adt/2 then begin
                     for j:=0 to AY.Ptr(0).Count-1 do AX[j]:=AY.Ptr(0).arr^[j];
                     time:=time+dtime
                    end;
 end
end;
{---------------------------------------------------------------------------
 Дискретное запаздывание
---------------------------------------------------------------------------}
function TDis2Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Запаздывание на период квантования';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin
                   MVTU.SetBlockProp(BlockId,'tau',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(ConvertVector(PropStr[1])),Res);
                 end;
  end;
end;

function TDis2;
var j : Integer;
begin
 Result:=0;
 with PDis2Rec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TDis2Convert);
  f_GetStateCount : Result:=Y0.Count;
  f_GetInit       : Result:=1;
  f_GetCount      : begin
                     CY.arr^[0]:=Y0.Count;
                     CU.arr^[0]:=Y0.Count
                    end;
  f_InitTime      : begin
                     dtime:=tau^;
                     time:=at
                    end;
  f_InitMem,
  f_InitState     : Move(Y0.arr^,AY.Ptr(0).arr^,Y0.Count*SOfR);
  f_RestoreOuts,
  f_UpdateJacoby  : for j:=0 to Y0.Count-1 do AY.Ptr(0).arr^[j]:=AX[j];
  f_GoodStep      : if (time-at <= adt/2) then
                     for j:=0 to Y0.Count-1 do AY.Ptr(0).arr^[j]:=AX[j];
  f_GetState      : if time-at <= adt/2 then begin
                     for j:=0 to Y0.Count-1 do AX[j]:=AU.Ptr(0).arr^[j];
                     time:=time+dtime
                    end;
  f_JacobyState   : for j:=0 to Y0.Count-1 do ADX[j]:=AU.Ptr(0).arr^[j];
  f_GetDelayTime  : AX[0]:=dtime;
 end
end;
{---------------------------------------------------------------------------
 Дискретная передаточная функция общего вида
---------------------------------------------------------------------------}
function TDis3Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Дискретная передаточная ф-я общего вида';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin
                   MVTU.SetBlockProp(BlockId,'b',PChar(ConvertVector(PropStr[0])),Res);
                   MVTU.SetBlockProp(BlockId,'a',PChar(ConvertVector(PropStr[1])),Res);
                   MVTU.SetBlockProp(BlockId,'tau',PChar(PropStr[2]),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(ConvertVector(PropStr[3])),Res);
                 end;
  end;
end;

function TDis3;
var j,n,m : Integer;
    x,y   : RealType;
label 1;
begin
 Result:=0;
 with PDis3Rec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TDis3Convert);
  f_EditErr       : begin
                     if a.arr^[a.count-1] = 0 then Result:=er_parzero;
                     if a.count < 2 then Result:=er_OrderMin;
                     if a.count < b.count then Result:=er_order;
                    end;
  f_GetDeriCount  : Result:=0;
  f_GetStateCount : Result:=a.count-1;
  f_GetInit       : if b.count < a.count then Result:=1 else Result:=0;
  f_GetCount      : begin CY.arr^[0]:=1;CU.arr^[0]:=1 end;
  f_InitTime      : begin
                     dtime:=tau^;
                     time:=at
                    end;
  f_InitState     : begin
                     n:=a.count-1;
                     for j:=0 to n-2 do AX[j]:=0;
                     AX[n-1]:=Y0.arr^[0];
                     goto 1;
                    end;
  f_RestoreOuts,
  f_UpdateJacoby  : begin
1:                   n:=a.count-1;
                     m:=b.count-1;
                     x:=b.arr^[m]/a.arr^[n];
                     if n = m then AY.Ptr(0).arr^[0]:=AX[n-1]+x*AU.Ptr(0).arr^[0]
                      else AY.Ptr(0).arr^[0]:=AX[n-1];
                    end;
  f_GoodStep      : if time-at <= adt/2 then goto 1;
  f_GetState      : if time-at <= adt/2 then begin
                     n:=a.count-1;
                     m:=b.count-1;
                     x:=a.arr^[n];
                     y:=AY.Ptr(0).arr^[0];
                     for j:=n-1 downto 1 do AX[j]:=AX[j-1]-a.arr^[j]/x*y;
                     AX[0]:=-a.arr^[0]/x*y;
                     for j:=0 to min(n-1,m) do AX[j]:=AX[j]+b.arr^[j]/x*AU.Ptr(0).arr^[0];
                     time:=time+dtime
                    end;
  f_JacobyState   : begin
                     n:=a.count-1;
                     m:=b.count-1;
                     x:=a.arr^[n];
//                     y:=AY.Ptr(0).arr^[0];
                     if n = m then y:=AX[n-1]+b.arr^[m]/x*AU.Ptr(0).arr^[0]
                      else y:=AX[n-1];
                     for j:=n-1 downto 1 do ADX[j]:=AX[j-1]-a.arr^[j]/x*y;
                     ADX[0]:=-a.arr^[0]/x*y;
                     for j:=0 to min(n-1,m) do ADX[j]:=ADX[j]+b.arr^[j]/x*AU.Ptr(0).arr^[0];
                    end;
  f_GetDelayTime  : AX[0]:=dtime;
 end
end;
{---------------------------------------------------------------------------
 Дискретная передаточная функция W(1/z)=N(1/z)/D(1/z)
---------------------------------------------------------------------------}
function TDis4Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Дискретная передаточная ф-я обратного аргумента';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin
                   MVTU.SetBlockProp(BlockId,'b',PChar(ConvertVector(PropStr[0])),Res);
                   MVTU.SetBlockProp(BlockId,'a',PChar(ConvertVector(PropStr[1])),Res);
                   MVTU.SetBlockProp(BlockId,'tau',PChar(PropStr[2]),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(ConvertVector(PropStr[3])),Res);
                 end;
  end;
end;

function TDis4;
var j,l,m,n : Integer;
    x,y     : RealType;
label 1;
begin
 Result:=0;
 with PDis3Rec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TDis4Convert);
  f_EditErr       : begin
                     if a.arr^[0] = 0 then Result:=er_parzero;
                     if (a.count < 2)and(b.count < 2) then Result:=er_OrderMin;
                    end;
//  f_GetDeriCount  : Result:=0;
  f_GetStateCount : Result:=max(a.count-1,b.count-1);
  f_GetInit       : if ABS(b.arr^[0])/2+1 = 1 then Result:=1 else Result:=0;
  f_GetCount      : begin CY.arr^[0]:=1;CU.arr^[0]:=1 end;
  f_InitTime      : begin
                     dtime:=tau^;
                     time:=at
                    end;
  f_InitState     : begin
                     n:=max(a.count-1,b.count-1);
                     for j:=1 to n-1 do AX[j]:=0;
                     AX[0]:=Y0.arr^[0];
                     goto 1;
                    end;
  f_RestoreOuts,
  f_UpdateJacoby  : begin
1:                   x:=b.arr^[0]/a.arr^[0];
                     AY.Ptr(0).arr^[0]:=AX[0]+x*AU.Ptr(0).arr^[0]
                    end;
  f_GoodStep      : if time-at <= adt/2 then goto 1;
  f_GetState      : if time-at <= adt/2 then begin
                     l:=a.count-1;
                     m:=b.count-1;
                     n:=max(l,m);
                     x:=a.arr^[0];
                     for j:=0 to n-2 do AX[j]:=AX[j+1];
                     AX[n-1]:=0;

                     for j:=0 to l-1 do
                      AX[j]:=AX[j]-a.arr^[j+1]/x*AY.Ptr(0).arr^[0];
                     for j:=0 to m-1 do
                      AX[j]:=AX[j]+b.arr^[j+1]/x*AU.Ptr(0).arr^[0];
                     time:=time+dtime
                    end;
  f_JacobyState   : begin
                     l:=a.count-1;
                     m:=b.count-1;
                     n:=max(l,m);
                     x:=a.arr^[0];
                     y:=AX[0]+b.arr^[0]/x*AU.Ptr(0).arr^[0];

                     for j:=0 to n-2 do ADX[j]:=AX[j+1];
                     ADX[n-1]:=0;

                     for j:=0 to l-1 do
                      ADX[j]:=ADX[j]-a.arr^[j+1]/x*y;
                     for j:=0 to m-1 do
                      ADX[j]:=ADX[j]+b.arr^[j+1]/x*AU.Ptr(0).arr^[0]
                    end;
  f_GetDelayTime  : AX[0]:=dtime;
 end
end;
{---------------------------------------------------------------------------
 Дискретный ПИД-регулятор
---------------------------------------------------------------------------}
function TDis5Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Дискретный ПИД-регулятор';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin
                   MVTU.SetBlockProp(BlockId,'kp',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'ki',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'kd',PChar(PropStr[2]),Res);
                   MVTU.SetBlockProp(BlockId,'tau',PChar(PropStr[3]),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(ConvertVector(PropStr[4])),Res);
                 end;
  end;
end;

function TDis5;
begin
 Result:=0;
 with PDis5Rec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TDis5Convert);
  f_GetDeriCount  : Result:=0;
  f_GetStateCount : Result:=2;
  f_GetInit       : Result:=0;
  f_GetCount      : begin CY.arr^[0]:=1;CU.arr^[0]:=1 end;
  f_InitTime      : begin
                     dtime:=tau^;
                     time:=at+dtime
                    end;
  f_InitMem       : AY.Ptr(0).arr^[0]:=Y0.arr^[0];
  f_InitState     : begin
                     AX[0]:=0.0;
                     AY.Ptr(0).arr^[0]:=Y0.arr^[0];
                     AX[1]:=AU.Ptr(0).arr^[0]
                    end;
  f_RestoreOuts,
  f_UpdateJacoby  : AY.Ptr(0).arr^[0]:=Ki^*(AX[0]+tau^*AU.Ptr(0).arr^[0])+
                    Kp^*AU.Ptr(0).arr^[0]+
                    Kd^*(AU.Ptr(0).arr^[0]-AX[1])/tau^;
  f_GoodStep      : if time-at <= adt/2 then
                     AY.Ptr(0).arr^[0]:=Ki^*(AX[0]+tau^*AU.Ptr(0).arr^[0])+
                     Kp^*AU.Ptr(0).arr^[0]+
                     Kd^*(AU.Ptr(0).arr^[0]-AX[1])/tau^;
  f_GetState     : if time-at <= adt/2 then begin
                     AX[0]:=AX[0]+tau^*AU.Ptr(0).arr^[0];
                     AX[1]:=AU.Ptr(0).arr^[0];
                     time:=time+dtime
                    end;
  f_JacobyState  : begin
                    ADX[0]:=AX[0]+tau^*AU.Ptr(0).arr^[0];
                    ADX[1]:=AU.Ptr(0).arr^[0]
                   end;
  f_GetDelayTime  : AX[0]:=dtime;
 end
end;
{---------------------------------------------------------------------------
Дискретные уравнения состояния

Блок реализует описание многомерной линейной
дискретной системы в матричной форме:
	x[k+1] = Ax[k] + Bu[k];
	y[k] = Cx[k] + Du[k],
где A, B, C, D - матрицы: собственная, входа,
выхода и обхода, соответственно; x-вектор
переменных состояния; u - вектор входа;
y - вектор выхода. Размерность матрицы А - n*n,
матрицы B - n*m, матрицы C - p*n, матрицы D -
p*m (n >= p).
Входом и выходом блока являются векторные
(“многожильные”) сигналы, размерностью m и p,
соответственно. Для работы блока необходимо в
диалоговом окне задать матрицы А, B, C, D;
вектор начальных условий xi(0) при  t = 0;
период квантования tau.

---------------------------------------------------------------------------}
function TDis6Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Дискретные переменные состояния';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin
                   MVTU.SetBlockProp(BlockId,'xc',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'uc',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'yc',PChar(PropStr[2]),Res);
                   MVTU.SetBlockProp(BlockId,'A',PChar(ConvertMatrix(PropStr[3])),Res);
                   MVTU.SetBlockProp(BlockId,'B',PChar(ConvertMatrix(PropStr[4])),Res);
                   MVTU.SetBlockProp(BlockId,'C',PChar(ConvertMatrix(PropStr[5])),Res);
                   MVTU.SetBlockProp(BlockId,'D',PChar(ConvertMatrix(PropStr[6])),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(ConvertVector(PropStr[7])),Res);
                   MVTU.SetBlockProp(BlockId,'tau',PChar(PropStr[8]),Res);
                 end;
  end;
end;

function TDis6;
var  i,j : Integer;
     sum  : RealType;
label 1;
begin
 Result:=0;
 with PDis6Rec(Prop.arr)^ do
 case Action of
 f_GetConvertFuncAdr: Result:=integer(@TDis6Convert);
 f_GetStateCount: Result:=xc^;
 f_GetDeriCount : Result:=0;
 f_GetInit      : begin
                   Result:=1;
                   for i:=0 to D_.countx-1 do
                   for j:=0 to D_.county-1 do
                   if ABS(D_.Val(i,j))/2+1  <> 1 then
                   begin Result:=0; break end
                  end;
 f_GetCount   :   begin
                   CU.arr^[0]:=uc^;
                   CY.arr^[0]:=yc^
                  end;
 f_EditErr:       begin
                   if xc^ <> A_.CountX then Result:=er_count;
                   if xc^ <> A_.CountY then Result:=er_count;
                   if uc^ <> B_.CountX then Result:=er_count;
                   if xc^ <> B_.CountY then Result:=er_count;
                   if yc^ <> C_.CountY then Result:=er_count;
                   if xc^ <> C_.CountX then Result:=er_count;
                   if uc^ <> D_.CountX then Result:=er_count;
                   if yc^ <> D_.CountY then Result:=er_count;
                  end;
 f_InitTime   :   begin
                   dtime:=tau^;
                   time:=at
                  end;
 f_InitState  :   begin
                   for i:=0 to xc^-1 do AX[i]:=Y0.arr^[i];
                   for i:=0 to yc^-1 do begin
                    AY.Ptr(0).arr^[i]:=0;
                    for j:=0 to xc^-1 do
                    AY.Ptr(0).arr^[i]:=AY.Ptr(0).arr^[i] + C_.val(j,i)*AX[j];
                   end;

                   for i:=0 to yc^-1 do
                   for j:=0 to uc^-1 do
                   AY.Ptr(0).arr^[i]:=AY.Ptr(0).arr^[i]+ D_.val(j,i)*AU.Ptr(0).arr^[j];
                  end;
 f_RestoreOuts,
 f_UpdateJacoby:  begin
                   for i:=0 to yc^-1 do begin
                    AY.Ptr(0).arr^[i]:=0;
                    for j:=0 to xc^-1 do
                    AY.Ptr(0).arr^[i]:=AY.Ptr(0).arr^[i] + C_.val(j,i)*AX[j]
                   end;

                   for i:=0 to yc^-1 do for j:=0 to uc^-1 do
                    AY.Ptr(0).arr^[i]:=AY.Ptr(0).arr^[i]+ D_.val(j,i)*AU.Ptr(0).arr^[j]
                  end;
 f_GoodStep  :    if time-at <= adt/2 then begin
                   for i:=0 to yc^-1 do begin
                    AY.Ptr(0).arr^[i]:=0;
                    for j:=0 to xc^-1 do
                     AY.Ptr(0).arr^[i]:=AY.Ptr(0).arr^[i] + C_.val(j,i)*AX[j]
                   end;

                   for i:=0 to yc^-1 do for j:=0 to uc^-1 do
                    AY.Ptr(0).arr^[i]:=AY.Ptr(0).arr^[i]+ D_.val(j,i)*AU.Ptr(0).arr^[j]
                  end;
 f_GetState   :   if time-at <= adt/2 then begin
1:                 for i:=0 to xc^-1 do begin
                    sum:=0;
                    for j:=0 to xc^-1 do sum:=sum+A_.val(j,i)*AX[j];
                    for j:=0 to uc^-1 do sum:=sum+B_.val(j,i)*AU.Ptr(0).arr^[j];
                    ADX[i]:=sum;
                   end;
                   if Action = f_GetState then begin
                    for i:=0 to xc^-1 do AX[i]:=ADX[i];
                    time:=time+dtime
                   end;
                  end;
 f_JacobyState :  goto 1;
// f_SteadyState :  for i:=0 to xc^-1 do Y0.arr^[i]:=AX[i];
 f_GetDelayTime:  AX[0]:=dtime;
 end{END CASE}
end;{END TDis6}

{---------------------------------------------------------------------------
 ПРОИЗВОДНАЯ ВХОДНОГО СИГНАЛА - Y(t) = dU(t)/dt, Y(0) = Y0
---------------------------------------------------------------------------}
function TDis7Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Дискретная производная';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin
                   MVTU.SetBlockProp(BlockId,'tau',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(ConvertVector(PropStr[1])),Res);
                 end;
  end;
end;

function TDis7;
var j : Integer;
label 1;
begin
 Result:=0;
 with PDis2Rec(Prop.arr)^ do
 case Action of
 f_GetConvertFuncAdr: Result:=integer(@TDis7Convert);
 f_GetDeriCount  : Result:=0;
 f_GetStateCount : Result:=Y0.Count;
 f_GetInit       : Result:=0;
 f_GetCount   :  begin
                  CY.arr^[0]:=Y0.Count;
                  CU.arr^[0]:=Y0.Count
                 end;
 f_InitTime   :  begin
		  time:=at;
                  dtime:=tau^
		 end;
 f_InitMem,
 f_InitState  :  Move(Y0.arr^,AY.Ptr(0).arr^,Y0.Count*SOfR);
 f_GetState   :  if (time-at) <= adt/2 then begin
                  for j:=0 to Y0.Count-1 do AX[j]:=AU.Ptr(0).arr^[j];
                  time:=time+dtime
                 end;
 f_JacobyState:  for j:=0 to Y0.Count-1 do ADX[j]:=AU.Ptr(0).arr^[j];
 f_RestoreOuts,
 f_UpdateJacoby: goto 1;
 f_GoodStep   :	 if (time-at) <= adt/2 then
1:                for j:=0 to Y0.Count-1 do
		   AY.Ptr(0).arr^[j]:=(AU.Ptr(0).arr^[j]-AX[j])/dtime;
// f_SteadyState:  Move(AY.Ptr(0).arr^,Y0.arr^,Y0.Count*SOfR);
 f_GetDelayTime: AX[0]:=dtime;
 end{END CASE}
end;{END Dis7}
{---------------------------------------------------------------------------

---------------------------------------------------------------------------}
function TDis8Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Разность нулевого порядка';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: with PDis0Rec(Prop.arr)^ do begin
                   MVTU.SetBlockProp(BlockId,'it',PChar(IntToStr(it^)),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(ConvertVector(PropStr[1])),Res);
                 end;
  end;
end;

function TDis8;
var j : Integer;
begin
 Result:=0;
 with PDis0Rec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TDis8Convert);
  f_GetDeriCount  : Result:=0;
  f_GetStateCount : Result:=Y0.Count;
  f_GetInit       : Result:=it^;
  f_GetCount      : begin
                     CY.arr^[0]:=Y0.Count;
                     CU.arr^[0]:=Y0.Count
                    end;
  f_InitTime      : begin
                     time:=at;dtime:=0
                    end;
  f_InitState,
  f_InitMem       : Move(Y0.arr^,AY.Ptr(0).arr^,Y0.Count*SOfR);
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep      : for j:=0 to Y0.Count-1 do AY.Ptr(0).arr^[j]:=AU.Ptr(0).arr^[j]-AX[j];
  f_GetState      : begin
                     for j:=0 to Y0.Count-1 do AX[j]:=AU.Ptr(0).arr^[j];
                     dtime:=at-time;
                     time:=at
                    end;
  f_JacobyState   : for j:=0 to Y0.Count-1 do ADX[j]:=AU.Ptr(0).arr^[j];
  f_GetDelayTime  : AX[0]:=dtime;
//  f_SteadyState   : Move(AY.Ptr(0).arr^,Y0.arr^,Y0.Count*SOfR);
 end
end;
END.