unit Logs;
{!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

		  Л О Г И Ч Е С К И Е     Б Л О К И

     Реализована буленовская логика по следующим принципам:
     1. В каждом логическом блоке Пользователь задает числовые значения,
        соответствующие "TRUE" и "FALSE" (по умолчанию заданы
        стандартные значения "TRUE"=1 и "FALSE"=0).
        В соответствии с этими значениями входные действительные числа
        приводятся к буленовскому типу, а буленовский результат
        действия блока преобразуется в выходные действительные числа.
        Подразумевается, что входной сигнал - FALSE, если он точно равен FALSE,
        иначе этот входной сигнал - TRUE.
     2. Размер вектора выхода равен размеру первого входного порта.
     3. Для всех блоков (кроме "НЕ") второй вход может быть задан
        как скалярным, так и векторным. В случае скаляра в блоках
        сравнения каждый элемент первого входа сравнивается со
        скалярным (первым) элементом второго входа. В случае вектора
        сравнение происходит поэлементно (в этом случае размерности
        всех входов и выходов одинаковы).

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!}
interface

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

function TLog0(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 TLog1(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 TLog2(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 TLog3(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 TLog4(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 TLog5(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 TLog6(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 TLog7(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 TLog8(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 TLog9(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 TLog10(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 TLog(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 TXOR(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 TLog13(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 TLog14(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 TLog15(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 TLog16(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 TLog17(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 TLog10Rst(at,adt:RealType;var AU,AY:TPtrExt;var AX,ADX:PExtArr;
               var Prop:TPtrArray;var Vars : Pointer;Action:Integer;var F:File):Integer;export;

{********************************************************************************************************}

                               IMPLEMENTATION

{********************************************************************************************************}
type
PLogRec = ^TLogRec;
TLogRec = record
  tf      : TExtArray;
  what    : ^Integer;
 end;

PLog11Rec = ^TLog11Rec;
TLog11Rec = record
  tf      : TExtArray;
  what    : ^Integer;
  log_type: ^Integer
 end;

PLog12Rec = ^TLog12Rec;
TLog12Rec = record
  tf      : TExtArray;
  log_type: ^Integer
 end;

PLog13Rec = ^TLog13Rec;
TLog13Rec = record
  tf      : TExtArray;
  N       : ^Integer
 end;

PLog17Rec = ^TLog17Rec;
TLog17Rec = record
  N       : ^Integer;
  Y0      : TExtArray;
 end;

PLog9Rec = ^TLog9Rec;
TLog9Rec = record
  ninp,m  : ^Integer;
  inp     : ^RealType;
  Yout     : TExtArray;
 end;

PLog10Rec = ^TLog10Rec;
TLog10Rec = record
  inp     : ^RealType;
  Yout    : TExtArray;
  tau     : TExtArray;
  faction : ^Integer;
 end;

PLog10Var = ^TLog10Var;
TLog10Var = record
  flag : PBoolArr;
  t    : TExtArray
 end;

PLog16Rec = ^TLog16Rec;
TLog16Rec = record
  N : ^Integer;
  Ymin,Ymax : TExtArray;
  what : ^Integer;
end;
{---------------------------------------------------------------------------
 ЛОГИЧЕСКОЕ "И"
---------------------------------------------------------------------------}
function TLog0Convert(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: with PLogRec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);

                   //Тип логической операции - ИЛИ
                   MVTU.SetBlockProp(BlockId,'log_type','0',Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog0;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLogRec(Prop.arr)^,tf do
 case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog0Convert);
 f_GetDeriCount,
 f_GetStateCount,
 f_GetInit    :  Result:=0;
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  for j:=0 to AY.Ptr(0).Count-1 do begin
                  if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
		  if (x <> 0) and (AU.Ptr(0).arr^[j] <> 0)
		   then AY.Ptr(0).arr^[j]:=arr^[0]
		    else AY.Ptr(0).arr^[j]:=arr^[1]
		 end;
 end
end;
{---------------------------------------------------------------------------
 ЛОГИЧЕСКОЕ "ИЛИ"
---------------------------------------------------------------------------}
function TLog1Convert(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: with PLogRec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);

                   //Тип логической операции - ИЛИ
                   MVTU.SetBlockProp(BlockId,'log_type','1',Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog1;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLogRec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog1Convert);
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  : for j:=0 to AY.Ptr(0).Count-1 do begin
                 if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
		  if (x <> 0) or (AU.Ptr(0).arr^[j] <> 0)
                   then AY.Ptr(0).arr^[j]:=arr^[0]
                    else AY.Ptr(0).arr^[j]:=arr^[1]
		end;
 end
end;
{---------------------------------------------------------------------------
 ЛОГИЧЕСКОЕ "НЕ"
---------------------------------------------------------------------------}
function TLog2Convert(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,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog2;
var j : Integer;
begin
 Result:=0;
 with TSourceRec(Prop.arr^[0]).Parms do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog2Convert);
 f_GetCount   :  CY.arr^[0]:=CU.arr^[0];
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  for j:=0 to AY.Ptr(0).Count-1 do
		  if (AU.Ptr(0).arr^[j] = 0)
                   then AY.Ptr(0).arr^[j]:=arr^[0]
		    else AY.Ptr(0).arr^[j]:=arr^[1];
 end
end;
{---------------------------------------------------------------------------
 БОЛЬШЕ
---------------------------------------------------------------------------}
function TLog3Convert(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: with PLogRec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog3;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLogRec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog3Convert);
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState     : for j:=0 to AY.Ptr(0).Count-1 do begin
                    if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
 		    if AU.Ptr(0).arr^[j] > x
                     then AY.Ptr(0).arr^[j]:=arr^[0]
		      else AY.Ptr(0).arr^[j]:=arr^[1]
                   end;
 end
end;
{---------------------------------------------------------------------------
 МЕНЬШЕ
---------------------------------------------------------------------------}
function TLog4Convert(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: with PLogRec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog4;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLogRec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog4Convert);
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  for j:=0 to AY.Ptr(0).Count-1 do begin
                  if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
 		  if AU.Ptr(0).arr^[j] < x
                   then AY.Ptr(0).arr^[j]:=arr^[0]
		    else AY.Ptr(0).arr^[j]:=arr^[1]
                 end;
 end
end;
{---------------------------------------------------------------------------
 РАВНО
---------------------------------------------------------------------------}
function TLog5Convert(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: with PLogRec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog5;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLogRec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog5Convert);
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  for j:=0 to AY.Ptr(0).Count-1 do begin
                  if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
		  if AU.Ptr(0).arr^[j] = x
                   then AY.Ptr(0).arr^[j]:=arr^[0]
		    else AY.Ptr(0).arr^[j]:=arr^[1]
                 end;
 end
end;
{---------------------------------------------------------------------------
 НЕ РАВНО
---------------------------------------------------------------------------}
function TLog6Convert(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: with PLogRec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog6;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLogRec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog6Convert);
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  for j:=0 to AY.Ptr(0).Count-1 do begin
                  if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
 		  if AU.Ptr(0).arr^[j] <> x
                   then AY.Ptr(0).arr^[j]:=arr^[0]
		    else AY.Ptr(0).arr^[j]:=arr^[1]
                 end;
 end
end;
{---------------------------------------------------------------------------
 БОЛЬШЕ ИЛИ РАВНО
---------------------------------------------------------------------------}
function TLog7Convert(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: with PLogRec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog7;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLogRec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog7Convert);
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  for j:=0 to AY.Ptr(0).Count-1 do begin
                  if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
		  if AU.Ptr(0).arr^[j] >= x
                   then AY.Ptr(0).arr^[j]:=arr^[0]
		    else AY.Ptr(0).arr^[j]:=arr^[1]
                 end;
 end
end;
{---------------------------------------------------------------------------
 МЕНЬШЕ ИЛИ РАВНО
---------------------------------------------------------------------------}
function TLog8Convert(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: with PLogRec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog8;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLogRec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog8Convert);
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  for j:=0 to AY.Ptr(0).Count-1 do begin
                  if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
		  if AU.Ptr(0).arr^[j] <= x
                   then AY.Ptr(0).arr^[j]:=arr^[0]
		    else AY.Ptr(0).arr^[j]:=arr^[1]
                 end;
 end
end;
{---------------------------------------------------------------------------
 Логические операции "И", "ИЛИ" и операции отношения '>','<','=','>=','<=','<>',
 требующие два операнда
---------------------------------------------------------------------------}
function TLogConvert(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: with PLog11Rec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   //Тип второго операнда
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);

                   //Тип логической операции - ИЛИ
                   MVTU.SetBlockProp(BlockId,'log_type',PChar(IntToStr(log_type^)),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog;
var j : Integer;
    x : RealType;
    f : Boolean;
begin
 Result:=0;
 with PLog11Rec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLogConvert);
 f_GetCount   :  begin
                  if what^ = 0 then CU.arr^[1]:=1 else CU.arr^[1]:=CU.arr^[0];
                  CY.arr^[0]:=CU.arr^[0]
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  for j:=0 to AY.Ptr(0).Count-1 do begin
                  if what^ = 0 then x:=AU.Ptr(1).arr^[0] else x:=AU.Ptr(1).arr^[j];
                  case log_type^ of
                   0:f:=(x <> 0) and (AU.Ptr(0).arr^[j] <> 0);
                   1:f:=(x <> 0) or  (AU.Ptr(0).arr^[j] <> 0);
                   2:f:=AU.Ptr(0).arr^[j] > x;
                   3:f:=AU.Ptr(0).arr^[j] < x;
                   4:f:=AU.Ptr(0).arr^[j] = x;
                   5:f:=AU.Ptr(0).arr^[j] <> x;
                   6:f:=AU.Ptr(0).arr^[j] >= x;
                   7:f:=AU.Ptr(0).arr^[j] <= x;
                   else f:=false;
                  end;
		  if f then AY.Ptr(0).arr^[j]:=arr^[0]
		   else AY.Ptr(0).arr^[j]:=arr^[1]
                 end;
 end
end;
{---------------------------------------------------------------------------
 Логические операции "XOR", "Not XOR"
---------------------------------------------------------------------------}
function TXORConvert(Action:  integer;
                             Vars:    Pointer;
                             Prop:    TPtrArray;
                             PropStr: TStringList;
                             BlockId: integer;
                            var MVTU: IMVTU_Server):integer;
  const RecName1:PChar = 'XOR';
        RecName2:PChar = 'NOT XOR';
  var SL:  TStringList;
      Res: integer;
begin
  with PLog12Rec(Prop.arr)^ do
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: case log_type^ of
                      0: Result:=integer(RecName1);
                      1: Result:=integer(RecName2);
                    end;
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert:  try
                   SL:=TStringList.Create;

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[0]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TXOR;
var j       : Integer;
    f,f1,f2 : Boolean;
begin
 Result:=0;
 with PLog12Rec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TXORConvert);
 f_GetCount   :  begin
                  CU.arr^[0]:=max(2,CU.arr^[0]);
                  CY.arr^[0]:=1
                 end;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  begin
                  f:=false;
                  f1:=(AU.Ptr(0).arr^[0] <> 0);
                  for j:=1 to AU.Ptr(0).Count-1 do begin
                   f:=false;
                   f2:=(AU.Ptr(0).arr^[j] <> 0);
                   if f1 or f2 then begin
                    f:=true;
                    if f1 and f2 then f:=false
                   end;
                   if log_type^ = 1 then f:=not f;
                   f1:=f
                  end;
		  if f then AY.Ptr(0).arr^[0]:=arr^[0]
		   else AY.Ptr(0).arr^[0]:=arr^[1]
                 end;
 end
end;
{---------------------------------------------------------------------------
 Триггер
 Блок имеет три векторных входа одинаковой
 размерности N, которая задается в параметрах блока.
 Третий вход - начальные условия для триггера.
 Алгоритм работы блока:
 1. Если u1(t[k]) = 0 and u2(t[k]) = 0, то y(t[k])=y(t[k-1])
 2. Если u1(t[k]) = 1 and u2(t[k]) = 0, то y(t[k])=1
 3. Если u1(t[k]) = 0 and u2(t[k]) = 1, то y(t[k])=0
 4. Если u1(t[k]) = 1 and u2(t[k]) = 1, то выход не изменяется
---------------------------------------------------------------------------}
function TLog13Convert(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,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog13;
var j     : Integer;
    x1,x2 : RealType;
begin
 Result:=0;
 with PLog13Rec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog13Convert);
 f_GetStateCount:Result:=N^;
 f_GetCount   :  begin
                  for j:=0 to CU.Count-1 do CU.arr^[j]:=N^;
                  for j:=0 to CY.Count-1 do CY.arr^[j]:=N^
                 end;
 f_InitMem    :  begin
                  time:=at;
                  dtime:=0
                 end;
 f_InitState  :  for j:=0 to N^-1 do
                   if AU.Ptr(2).arr^[j] = 0 then begin
                    AY.Ptr(0).arr^[j]:=arr^[1];
                    AY.Ptr(1).arr^[j]:=arr^[0]
                   end
                   else begin
                    AY.Ptr(0).arr^[j]:=arr^[0];
                    AY.Ptr(1).arr^[j]:=arr^[1]
                   end;
  f_UpdateOuts,
  f_UpdateJacoby,
  f_GoodStep      : for j:=0 to N^-1 do begin
                     x1:=AU.Ptr(0).arr^[j];
                     x2:=AU.Ptr(1).arr^[j];
                     if (x1 = 0) then begin
                      if x2 = 0 then AY.Ptr(0).arr^[j]:=AX[j]
                       else AY.Ptr(0).arr^[j]:=arr^[1]
                     end
                     else begin
                      if x2 = 0 then AY.Ptr(0).arr^[j]:=arr^[0]
                     end;
                     if AY.Ptr(0).arr^[j] = arr^[0]
                      then AY.Ptr(1).arr^[j]:=arr^[1]
                       else AY.Ptr(1).arr^[j]:=arr^[0]
                    end;
  f_RestoreOuts   : for j:=0 to N^-1 do begin
                     AY.Ptr(0).arr^[j]:=AX[j];
                     if AY.Ptr(0).arr^[j] = arr^[0]
                      then AY.Ptr(1).arr^[j]:=arr^[1]
                       else AY.Ptr(1).arr^[j]:=arr^[0]
                    end;
  f_GetState      : begin
                     for j:=0 to N^-1 do AX[j]:=AY.Ptr(0).arr^[j];
                     dtime:=at-time;
                     time:=at
                    end;
  f_JacobyState   : for j:=0 to N^-1 do ADX[j]:=AY.Ptr(0).arr^[j];
  f_GetDelayTime  : AX[0]:=dtime;
 end
end;
{---------------------------------------------------------------------------
 Обычный триггер
 Блок имеет два векторных входа одинаковой
 размерности N.
 Алгоритм работы блока:
 1. Если u1(t[k]) = 0 and u2(t[k]) = 0, то y(t[k])=y(t[k-1])
 2. Если u1(t[k]) = 1 and u2(t[k]) = 0, то y(t[k])=1
 3. Если u1(t[k]) = 0 and u2(t[k]) = 1, то y(t[k])=0
 4. Если u1(t[k]) = 1 and u2(t[k]) = 1, то выход 0
---------------------------------------------------------------------------}
function TLog17Convert(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,'y0',PChar(ConvertVector(PropStr[1])),Res);
                 finally
                 end;
  end;
end;

function TLog17;
var j     : Integer;
    x1,x2 : RealType;
label 1;
begin
 Result:=0;
 with PLog17Rec(Prop.arr)^ do
 case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog17Convert);
 f_GetDeriCount,
 f_GetInit    :  Result:=0;
 f_GetStateCount:Result:=N^;
 f_GetCount   :  begin
                  for j:=0 to CU.Count-1 do CU.arr^[j]:=N^;
                  for j:=0 to CY.Count-1 do CY.arr^[j]:=N^
                 end;
 f_InitMem    :  begin
                  time:=at;
                  dtime:=0
                 end;
  f_InitState :  begin
                  for j:=0 to N^-1 do if j >= Y0.Count then AX[j]:=0 else AX[j]:=Y0.arr^[j];
                  goto 1;
                 end;
  f_UpdateOuts,
  f_UpdateJacoby,
  f_GoodStep      :
1:                  for j:=0 to N^-1 do begin
                     x1:=AU.Ptr(0).arr^[j];
                     x2:=AU.Ptr(1).arr^[j];
                     if (x1 = 0) then begin
                      if x2 = 0 then AY.Ptr(0).arr^[j]:=AX[j]
                       else AY.Ptr(0).arr^[j]:=0
                     end
                     else begin
                      if x2 = 0 then AY.Ptr(0).arr^[j]:=1 else AY.Ptr(0).arr^[j]:=0
                     end;
                    end;
  f_RestoreOuts   : for j:=0 to N^-1 do AY.Ptr(0).arr^[j]:=AX[j];
  f_GetState      : begin
                     for j:=0 to N^-1 do AX[j]:=AY.Ptr(0).arr^[j];
                     dtime:=at-time;
                     time:=at
                    end;
  f_JacobyState   : for j:=0 to N^-1 do ADX[j]:=AY.Ptr(0).arr^[j];
  f_GetDelayTime  : AX[0]:=dtime;
 end
end;
{---------------------------------------------------------------------------
 M из N
 Число входных логических сигналов равно N.
 Если как минимум M из них - ИСТИНА, то
 выходной сигнал - ИСТИНА, иначе - ЛОЖЬ
---------------------------------------------------------------------------}
function TLog9Convert(Action:  integer;
                             Vars:    Pointer;
                             Prop:    TPtrArray;
                             PropStr: TStringList;
                             BlockId: integer;
                            var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'M из N';
  var SL:  TStringList;
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    //Конвертируем и устанавливаем параметры при помощи интерфейса МВТУ
    cnv_Convert: try
                   SL:=TStringList.Create;

                   MVTU.SetBlockProp(BlockId,'nport',PChar(PropStr[0]),Res);
                   MVTU.ExecutePropScript(BlockId,Res,Res);
                   MVTU.SetBlockProp(BlockId,'m',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'inp',PChar(PropStr[2]),Res);

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[3]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog9;
var i,j,k : Integer;
begin
 Result:=0;
 with PLog9Rec(Prop.arr)^ do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog9Convert);
 f_GetCount      : CY.arr^[0]:=1;
 f_UpdateOuts,
 f_RestoreOuts,
 f_UpdateJacoby,
 f_GoodStep,
 f_InitState  :  begin
                  k:=0;
                  for i:=0 to AU.Count-1 do
                  for j:=0 to AU.Ptr(i).Count-1 do if AU.Ptr(i).arr^[j] = inp^ then inc(k);
                  if k >= m^ then AY.Ptr(0).arr^[0]:=Yout.arr^[0]
                  else AY.Ptr(0).arr^[0]:=Yout.arr^[1]
                 end;
 end{END CASE}
end;{END TLog9}
{---------------------------------------------------------------------------
  Временная задержка логической ИСТИНЫ
 На выходе - ИСТИНА, если поступающий на вход сигнал - ИСТИНА в течение
 не менее заданного промежутка времени
---------------------------------------------------------------------------}
function TLog10Convert(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: with PLog10Rec(Prop.arr)^ do try
                   SL:=TStringList.Create;

                   MVTU.SetBlockProp(BlockId,'inp',PChar(PropStr[0]),Res);

                   //Парсим свойство заданное в одной строчке
                   ExtractStrings([' ',';'],[' '],PChar(PropStr[1]),SL);

                   MVTU.SetBlockProp(BlockId,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   MVTU.SetBlockProp(BlockId,'tau',PChar(ConvertVector(PropStr[2])),Res);
                   MVTU.SetBlockProp(BlockId,'faction',PChar(IntToStr(faction^)),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog10;
var j : Integer;
begin
 Result:=0;
 with PLog10Rec(Prop.arr)^ do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog10Convert);
 f_GetStateCount : Result:=tau.Count;
 f_GetCount      : begin
                    CU.arr^[0]:=tau.Count;
                    CY.arr^[0]:=tau.Count
                   end;
 f_Create        : begin
                    Vars:=New(PLog10Var);
                    with PLog10Var(Vars)^ do begin
                     t:=TExtArray.Create(1);
                     GetMem(flag,SizeOf(Boolean));
                    end
                   end;
 f_Free          : begin
                    with PLog10Var(Vars)^ do begin
                     FreeMem(flag,t.Count*SizeOf(Boolean));
                     t.Free
                    end;
                    Dispose(Vars)
                   end;
 f_InitMem       : with PLog10Var(Vars)^ do begin
                    if tau.Count > t.Count then begin
                     FreeMem(flag,t.Count*SizeOf(Boolean));
                     GetMem(flag,tau.Count*SizeOf(Boolean));
                     t.ChangeCount(tau.Count)
                    end;
                    for j:=0 to tau.Count-1 do begin
                     flag^[j]:=False;
                     t.arr^[j]:=at
                    end
                   end;
 f_InitState  :  with PLog10Var(Vars)^ do
                 for j:=0 to tau.Count-1 do begin
     		   if (AU.Ptr(0).arr^[j] = inp^) then
                    if not flag^[j] then begin
                     t.arr^[j]:=at;
                     flag^[j]:=True
                    end;
                   AY.Ptr(0).arr^[j]:=Yout.arr^[1];
                   if flag^[j] then
                    case faction^ of
                     1   : AY.Ptr(0).arr^[j]:=Yout.arr^[0];
                     0,2 : if (at-t.arr^[j]) >= tau.arr^[j] then
                            AY.Ptr(0).arr^[j]:=Yout.arr^[0];
                    end
                 end;
 f_GetState   : for j:=0 to tau.Count-1 do AX[j]:=AY.Ptr(0).arr^[j];
 f_RestoreOuts: for j:=0 to tau.Count-1 do AY.Ptr(0).arr^[j]:=AX[j];
 f_UpdateOuts,
 f_UpdateJacoby,
 f_GoodStep   :  with PLog10Var(Vars)^ do
                  for j:=0 to AU.Ptr(0).Count-1 do
                   if (AU.Ptr(0).arr^[j] = inp^)then begin
                    if not flag^[j] then begin
                     t.arr^[j]:=at;
                     flag^[j]:=True
                    end;
                   if flag^[j] then
                    case faction^ of
                     1   : AY.Ptr(0).arr^[j]:=Yout.arr^[0];
                     0,2 : if (at-t.arr^[j]) >= tau.arr^[j] then
                            AY.Ptr(0).arr^[j]:=Yout.arr^[0];
                    end;
                   end
                   else begin
                    if flag^[j] then begin
                     t.arr^[j]:=at;
                     flag^[j]:=False
                    end;
                    if not flag^[j] then
                     case faction^ of
                      0   : AY.Ptr(0).arr^[j]:=Yout.arr^[1];
                      1,2 : if (at-t.arr^[j]) >= tau.arr^[j] then
                             AY.Ptr(0).arr^[j]:=Yout.arr^[1];
                     end;
                   end;
 end
end;{END TLog10}

function TLog10Rst;
begin
 Result:=0;
 with PLog10Rec(Prop.arr)^,PLog10Var(Vars)^ do case Action of
 f_ReadRez,
 f_ReadRst   : try
                BlockRead(F,t.arr^,tau.Count*SOfR);
                BlockRead(F,flag^,tau.Count*SOfB)
               except
                Result:=er_ReadFile
               end;
 f_WriteRez,
 f_WriteRst  : try
                BlockWrite(F,t.arr^,tau.Count*SOfR);
                BlockWrite(F,flag^,tau.Count*SOfB)
               except
                Result:=er_WriteFile
               end;
 end
end;

{---------------------------------------------------------------------------
 Radio-button
 Блок реализует работу группы логических сигналов по принципу
 "Один из многих". На вход блока подается векторный логический сигнал

 Алгоритм работы блока:
---------------------------------------------------------------------------}
function TLog14Convert(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,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   MVTU.SetBlockProp(BlockId,'n',PChar(PropStr[1]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog14;
var j,k : Integer;
label 1;
begin
 Result:=0;
 with PLog13Rec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog14Convert);
 f_EditErr    : if N^ > AY.Ptr(0).Count then Result:=er_RangeMax;
//                 else if N^ < 1 then Result:=er_RangeMin;
 f_GetStateCount:Result:=1;
 f_GetCount   :  CY.arr^[0]:=CU.arr^[0];
 f_InitState  :  begin
{                  N^:=min(N^,AY.Ptr(0).Count);
                  N^:=max(1,N^);}
                  AX[0]:=N^;
{                  for j:=0 to AY.Ptr(0).Count-1 do
                   if j = N^-1 then AY.Ptr(0).arr^[j]:=arr^[0]
                    else AY.Ptr(0).arr^[j]:=arr^[1]}
                  goto 1;
                 end;
 f_RestoreOuts : begin
                  N^:=round(AX[0]);
1:                for j:=0 to AY.Ptr(0).Count-1 do
                   if j = N^-1 then AY.Ptr(0).arr^[j]:=arr^[0]
                    else AY.Ptr(0).arr^[j]:=arr^[1]
                 end;
 f_GoodStep   :  begin
                  k:=0;
                  for j:=0 to AY.Ptr(0).Count-1 do
                   if (AU.Ptr(0).arr^[j] <> 0.0) {and (j <> N^-1)} then begin
{                     AY.Ptr(0).arr^[j]:=arr^[0];
                     AY.Ptr(0).arr^[N^-1]:=arr^[1];}
                     N^:=j+1;
                     inc(k)
{                     break}
                    end;
                  if k <> 1 then exit;

                  for j:=0 to AY.Ptr(0).Count-1 do AY.Ptr(0).arr^[j]:=arr^[1];
                  AY.Ptr(0).arr^[N^-1]:=arr^[0];
                  AX[0]:=N^;
                 end;
 end
end;

{---------------------------------------------------------------------------
 Radio-button
 Блок реализует работу группы логических сигналов по принципу
 "Один из многих". На вход блока подается номер активного элемента массива

 Алгоритм работы блока:
---------------------------------------------------------------------------}
function TLog15Convert(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,'true_val',PChar(SL[0]),Res);
                   MVTU.SetBlockProp(BlockId,'false_val',PChar(SL[1]),Res);

                   MVTU.SetBlockProp(BlockId,'n',PChar(PropStr[1]),Res);
                 finally
                   SL.Free;
                 end;
  end;
end;

function TLog15;
var j,k     : Integer;
begin
 Result:=0;
 with PLog13Rec(Prop.arr)^,tf do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog15Convert);
 f_EditErr    : if N^ <= 0 then Result:=er_RangeMin;
 f_GetCount   :  begin
                  CY.arr^[0]:=N^;
                  CU.arr^[0]:=1;
                 end;
 f_InitState,
 f_RestoreOuts,
 f_GoodStep      : begin
                    k:=round(AU.Ptr(0).arr^[0]);
{                    k:=max(k,1);
                    k:=min(k,N^);}
                    for j:=0 to N^-1 do
                     if (j = k-1) then AY.Ptr(0).arr^[j]:=arr^[0]
                      else AY.Ptr(0).arr^[j]:=arr^[1]
                   end;
 end
end;

{---------------------------------------------------------------------------
Счетчик импульсов
 Алгоритм работы блока:
---------------------------------------------------------------------------}
function TLog16Convert(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 PLog16Rec(Prop.arr)^ do try
                   MVTU.SetBlockProp(BlockId,'ymin',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'ymax',PChar(PropStr[2]),Res);
                   MVTU.SetBlockProp(BlockId,'what',PChar(IntToStr(what^)),Res);
                 finally
                 end;
  end;
end;

function TLog16;
var j : Integer;
    x : RealType;
begin
 Result:=0;
 with PLog16Rec(Prop.arr)^ do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TLog16Convert);
 f_EditErr    : if (Ymin.Count < N^)or(Ymax.Count < N^) then Result:=er_Count;
 f_GetStateCount:Result:=2*N^;
 f_GetCount   :  begin
                  CY.arr^[0]:=N^;
                  CU.arr^[0]:=N^;
                 end;
 f_InitState  : for j:=0 to N^-1 do begin
                 AX[j]:=0;
                 AX[j+N^]:=1;
                 x:=AU.Ptr(0).arr^[j];
                 case what^ of
                 0: if (x >= Ymin.arr^[j]) and (x <= Ymax.arr^[j]) then begin
                     if AX[j+N^] = 1.0 then begin
                      AX[j]:=AX[j]+1.0;
                      AX[j+N^]:=0.0
                     end
                    end else AX[j+N^]:=1.0;
                 1: if (x <= Ymin.arr^[j]) or (x >= Ymax.arr^[j]) then begin
                     if AX[j+N^] = 1.0 then begin
                      AX[j]:=AX[j]+1.0;
                      AX[j+N^]:=0.0
                     end
                    end else AX[j+N^]:=1.0;
                 end;
                 AY.Ptr(0).arr^[j]:=AX[j];
                end;
 f_RestoreOuts: for j:=0 to N^-1 do AY.Ptr(0).arr^[j]:=AX[j];
 f_GoodStep   : for j:=0 to N^-1 do begin
                 x:=AU.Ptr(0).arr^[j];
                 case what^ of
                 0: if (x >= Ymin.arr^[j]) and (x <= Ymax.arr^[j]) then begin
                     if AX[j+N^] = 1.0 then begin
                      AX[j]:=AX[j]+1.0;
                      AX[j+N^]:=0.0
                     end
                    end else AX[j+N^]:=1.0;
                 1: if (x <= Ymin.arr^[j]) or (x >= Ymax.arr^[j]) then begin
                     if AX[j+N^] = 1.0 then begin
                      AX[j]:=AX[j]+1.0;
                      AX[j+N^]:=0.0
                     end
                    end else AX[j+N^]:=1.0;
                 end;
                 AY.Ptr(0).arr^[j]:=AX[j];
                end;
 end
end;

end.