unit Srcs;
{!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

			И С Т О Ч Н И К И    С И Г Н А Л А

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!}


interface

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

function TTimeStep(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 TClock(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 TStep(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 TConst(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 TPolynom(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 TSineWave(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 TExponent(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 TInvert(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 TPila(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 TObPila(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 TLom(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 TLom1(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 TTreug(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 TMeandr(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 TQuad(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 TNorm(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;

type
 TSourceRec = record
  Parms : TExtArray
 end;

 PConstRec = ^TConstRec;
  TConstRec = record
  k : ^RealType;
 end;

 PConst2Rec = ^TConst2Rec;
 TConst2Rec = record
  k0,k1 : ^RealType;
 end;

 PLomRec = ^TLomRec;
 TLomRec = record
  X,Y : TExtArray;
 end;

 PNormRec = ^TNormRec;
 TNormRec = record
  M,D,Tau : PRealType;
 end;

 const  ymax=1.0e300;
 var
        mant10_max,
        mante_max  : RealType;
{********************************************************************************************************}

                               IMPLEMENTATION

{********************************************************************************************************}
{---------------------------------------------------------------------------

---------------------------------------------------------------------------}

  //Эта функция обеспечивает конвертацию блока из 3-й версии в 4-ю через
  //интерфейс IMVTU_Server
function TTimeStepConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Шаг интегрирования';
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin

                   //В данном случае блок просто не имеет свойств

                 end;
  end;
end;

function TTimeStep;
begin
 Result:=0;
 case Action of
 //По этому флагу возвращаем адрес функции конверсии блока
 f_GetConvertFuncAdr: Result:=integer(@TTimeStepConvert);

 f_GetInit       : Result:=1;
 f_GetCount      : CY.arr^[0]:=1;
 f_InitTime 	 : time:=at;
 f_InitState     : AY.Ptr(0).arr^[0]:=adt;
 f_RestoreOuts,
 f_InitMem,
 f_UpdateJacoby  : AY.Ptr(0).arr^[0]:=at-time;
 f_GoodStep   :  begin
                  AY.Ptr(0).arr^[0]:=at-time;
                  time:=at
                 end;
 end{END CASE}
end;{END TTimeStep}
{---------------------------------------------------------------------------
 Модельное время - y = time
---------------------------------------------------------------------------}
function TClockConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Часы';
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: begin

                   //В данном случае блок просто не имеет свойств

                 end;
  end;
end;

function TClock;
begin
 Result:=0;
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TClockConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_RestoreOuts,
  f_InitState,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : AY.Ptr(0).arr^[0]:=at;
 end
end;
{---------------------------------------------------------------------------
 Ступенька - y = y0 при t <= timestep ; y = yk при  t > timestep
---------------------------------------------------------------------------}

function TStepConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Ступенька';
  var
      SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;
                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'t',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'y0',PChar(SL[1]),Res);
                   MVTU.SetBlockProp(BlockId,'yk',PChar(SL[2]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;


function TStep;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TStepConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState     : AY.Ptr(0).arr^[0]:=arr^[1];
  f_RestoreOuts,
  f_UpdateOuts,
  f_UpdateJacoby,
  f_GoodStep      : if arr^[0] < at then AY.Ptr(0).arr^[0]:=arr^[2]
                     else AY.Ptr(0).arr^[0]:=arr^[1];
 end
end;
{---------------------------------------------------------------------------
 Константа - y = y0
---------------------------------------------------------------------------}
function TConstConvert(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,'a',PChar(PropStr[0]),Res);
                 end;
  end;
end;


function TConst;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TConstConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_UpdateOuts,
  f_GoodStep      : AY.Ptr(0).arr^[0]:=arr^[0];
 end
end;
{---------------------------------------------------------------------------
 Полином - y = a0 + a1*t + a2*t^2 + ... an*t^[n-1]
---------------------------------------------------------------------------}
function TPolynomConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Полином n-й степени';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   MVTU.SetBlockProp(BlockId,'a',PChar(ConvertVector(PropStr[0])),Res);
                 finally
                 end;
  end;
end;

function TPolynom;
var i       : Integer;
    Sum,Mul : RealType;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TPolynomConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : begin
		  Sum:=0.0;Mul:=1.0;
		  for i:=0 to Count-1 do begin
                   if abs(sum) > ymax then begin Result:=er_overflow_y;break end;
		   Sum:=Sum+arr^[i]*Mul;
		   Mul:=Mul*at
		  end;
		  AY.Ptr(0).arr^[0]:=Sum
		 end;
 end
end;
{---------------------------------------------------------------------------
Синусоида - y=A*SIN[B*t+C]
---------------------------------------------------------------------------}
function TSinConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Синусоида';
  var
      SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;
                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'a',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'w',PChar(SL[1]),Res);
                   MVTU.SetBlockProp(BlockId,'f',PChar(SL[2]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TSineWave;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TSinConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : AY.Ptr(0).arr^[0]:=arr^[0]*SIN(arr^[1]*at+arr^[2]);
 end{END CASE}
end;{END TSineWave}
{---------------------------------------------------------------------------
Экспонента - y=A*EXP[B*t+C]
---------------------------------------------------------------------------}
function TExpConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Экспонента';
  var
      SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;
                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'a',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'b',PChar(SL[1]),Res);
                   MVTU.SetBlockProp(BlockId,'c',PChar(SL[2]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;


function TExponent;
var x : RealType;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TExpConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : begin
                  x:=arr^[1]*at+arr^[2];
                  x:=arr^[0]*EXP(x);
                  if abs(x) > ymax then begin Result:=er_overflow_y;exit end;
                  AY.Ptr(0).arr^[0]:=x
                 end;
 end{END CASE}
end;{END TExponent}
{---------------------------------------------------------------------------
Гипербола - y=A/[B+t]
---------------------------------------------------------------------------}
function TInvertConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Гипербола';
  var
      SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;
                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'k',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'eps',PChar(SL[1]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;


function TInvert;
var x : RealType;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TInvertConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : begin
                  x:=(at+arr^[1]);
                  if x = 0.0 then begin Result:=er_zerodivide;exit end;
                  x:=arr^[0]/x;
                  if abs(x) > ymax then begin Result:=er_overflow_y;exit end;
                  AY.Ptr(0).arr^[0]:=x
                 end;
 end{END CASE}
end;{END TInvert}
{---------------------------------------------------------------------------
Пилообразный сигнал со смещением по вертикали
---------------------------------------------------------------------------}
function TPilaConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Пила';
  var
      SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;
                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'y',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'t',PChar(SL[1]),Res);
                   MVTU.SetBlockProp(BlockId,'dy',PChar(SL[2]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;


function TPila;
var x : RealType;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TPilaConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : begin
                  if arr^[1] = 0.0 then begin Result:=er_zerodivide;exit end;
                  x:=arr^[0]/arr^[1]*(-arr^[1]*trunc(at/arr^[1])+at)+arr^[2];
                  if abs(x) > ymax then begin Result:=er_overflow_y;exit end;
                  AY.Ptr(0).arr^[0]:=x
                 end;
 end
end;
{--------------------------------------------------------------------------
Обратный пилообразный сигнал со смещением по вертикали
---------------------------------------------------------------------------}
function TObPilaConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Обратная пила';
  var
      SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;
                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'y',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'t',PChar(SL[1]),Res);
                   MVTU.SetBlockProp(BlockId,'dy',PChar(SL[2]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TObPila;
var x : RealType;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TObPilaConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts    : begin
                     if arr^[1] = 0.0 then begin Result:=er_zerodivide;exit end;
                     x:=arr^[0]/arr^[1]*(arr^[1]*(trunc(at/arr^[1])+1)-at)+arr^[2];
                     if abs(x) > ymax then begin Result:=er_overflow_y;exit end;
                     AY.Ptr(0).arr^[0]:=x
                    end;
 end{END CASE}
end;{END TObPila}
{---------------------------------------------------------------------------
Кусочно-линейный сигнал, задаваемый пользователем
---------------------------------------------------------------------------}
function TLomConvert(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,'t',PChar(ConvertVector(PropStr[0])),Res);
                   MVTU.SetBlockProp(BlockId,'y',PChar(ConvertVector(PropStr[1])),Res);
                 end;
  end;
end;

function TLom;
begin
 Result:=0;
 with PLomRec(Prop.arr)^ do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TLomConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : AY.Ptr(0).arr^[0]:=GetVectorData(X.Count-1,at,Y.arr^,X.arr^);
 end{END CASE}
end;{END TLom}
{---------------------------------------------------------------------------
Кусочно-постоянный сигнал, задаваемый пользователем
---------------------------------------------------------------------------}
function TLom1Convert(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,'t',PChar(ConvertVector(PropStr[0])),Res);
                   MVTU.SetBlockProp(BlockId,'y',PChar(ConvertVector(PropStr[1])),Res);
                 end;
  end;
end;

function TLom1;
var j   : Integer;
    s   : RealType;
begin
 Result:=0;
 with PLomRec(Prop.arr)^ do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TLom1Convert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : begin
		  s:=0;
		  for j:=0 to X.Count-1 do begin
		   s:=s+X.arr^[j];
		   if s > at then begin
		    AY.Ptr(0).arr^[0]:=Y.arr^[j];
		    break
		   end
		  end;
		  if s <= at then AY.Ptr(0).arr^[0]:=Y.arr^[Y.Count-1]
		 end;
 end{END CASE}
end;{END TLom}
{---------------------------------------------------------------------------
Треугольный сигнал
---------------------------------------------------------------------------}
function TTreugConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Треугольный сигнал';
  var
      SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;
                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'y',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'t',PChar(SL[1]),Res);
                   MVTU.SetBlockProp(BlockId,'dy','0',Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TTreug;
var i,k : Integer;
    x   : RealType;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TTreugConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts : begin
                  if arr^[1] = 0.0 then begin Result:=er_zerodivide;exit end;

		  if 2*trunc(at/arr^[1]) = trunc(2*at/arr^[1]) then
		  begin k:=1;i:=0 end else begin k:=-1;i:=1 end;

                  x:=2*k*arr^[0]/arr^[1]*(at-arr^[1]*(trunc(at/arr^[1])+i));
                  if abs(x) > ymax then begin Result:=er_overflow_y;exit end;

		  AY.Ptr(0).arr^[0]:=x
		 end;
 end{END CASE}
end;{END TTreug}
{---------------------------------------------------------------------------
Прямоугольный сигнал
---------------------------------------------------------------------------}
function TMeandrConvert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Меандр';
  var
      SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;
                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'y1',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'t1',PChar(SL[1]),Res);
                   MVTU.SetBlockProp(BlockId,'y2',PChar(SL[2]),Res);
                   MVTU.SetBlockProp(BlockId,'t2',PChar(SL[3]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TMeandr;
var x : RealType;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TMeandrConvert);
  f_GetInit       : Result:=1;
  f_GetCount      : CY.arr^[0]:=1;
  f_InitState,
  f_RestoreOuts,
  f_UpdateJacoby,
  f_GoodStep,
  f_UpdateOuts :  begin
                   if arr^[1] = 0.0 then begin Result:=er_zerodivide;exit end;
                   x:=at-(arr^[1]+arr^[3])*trunc(at/(arr^[1]+arr^[3]));
                   if abs(x) > ymax then begin Result:=er_overflow_y;exit end;
                   if x >= arr^[1] then x:=arr^[2] else x:=arr^[0];
                   AY.Ptr(0).arr^[0]:=x
                  end;
 end{END CASE}
end;{END TMeandr}
{---------------------------------------------------------------------------
	Белый шум

Блок генерирует псевдослучайную последовательность вещественных чисел,
равномерно распределенных в диапазоне от y_miп до y_max.
Для работы  блока необходимо задать ни;нюю y_miп и верхнюю y_max границы
диапазона.
---------------------------------------------------------------------------}
function TQuadConvert(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: try
                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'xmin',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'xmax',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'qt',PChar(PropStr[2]),Res);
                 finally
                 end;
  end;
end;

function TQuad;
begin
 Result:=0;
 with PNormRec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TQuadConvert);
  f_GetStateCount,
  f_GetInit      : Result:=1;
  f_GetCount     : CY.arr^[0]:=1;
  f_InitTime     : time:=at;
  f_RestoreOuts  : AY.Ptr(0).arr^[0]:=AX[0];
  f_InitState,
  f_UpdateJacoby,
  f_GoodStep     : if time-at <= adt/2 then begin
                    AY.Ptr(0).arr^[0]:=M^+(D^-M^)*RanVal1;
                    AX[0]:=AY.Ptr(0).arr^[0];
                    time:=time+Tau^
                   end;
 end{END CASE}
end;{END TQuad}
{---------------------------------------------------------------------------
	Нормальный шум

Блок генерирует  псевдослучайную  последовательность  нормально
распределенных (по Гауссу) вещественных чисел. Для работы блока необходимо
задать математическое о;идание M и дисперсию D  закона распределения.
---------------------------------------------------------------------------}
function TNormConvert(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: try
                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'m',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'d',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'qt',PChar(PropStr[2]),Res);
                 finally
                 end;
  end;
end;

function TNorm;
var S1,S2,Sum,Fac : RealType;
begin
 Result:=0;
 with PNormRec(Prop.arr)^ do case Action of
  f_GetConvertFuncAdr: Result:=integer(@TNormConvert);
  f_GetStateCount,
  f_GetInit     : Result:=1;
  f_GetCount    : CY.arr^[0]:=1;
  f_InitTime    : time:=at;
  f_RestoreOuts : AY.Ptr(0).arr^[0]:=AX[0];
  f_InitState,
  f_UpdateJacoby,
  f_GoodStep    : if time-at <= adt/2 then begin
		   repeat
		    S1 := RanVal1;
		    S2 := RanVal1;
		    S1 := 2 * S1 - 1;
		    S2 := 2 * S2 - 1;
		    Sum := sqr(S1) + sqr(S2);
		   until (Sum < 1);
		   if Sum <> 0 then Fac := sqrt (2*abs(ln(Sum))/Sum) else Fac:=0;
		   AY.Ptr(0).arr^[0]:=D^*s1*Fac+M^;
                   AX[0]:=AY.Ptr(0).arr^[0];
                   time:=time+Tau^
		 end;
 end{END CASE}
end;{END TNorm}

end.