unit Sinks;

interface

uses WinTypes,WinProcs,Classes,SysUtils,GlType,GlProc,MathObj,Tbls,MVTU_TLB;

type
PToFileVar = ^TToFileVar;
TToFileVar = packed record
  itime    : Integer;
  FText    : TextFile;
  IsOpened : Boolean;
 end;

PFromFileVar = ^TFromFileVar;
TFromFileVar = packed record
  FText    : TextFile;
  px       : TExtArray;
  py       : PExtPtrArray;
 end;

PFromFile3Var = ^TFromFile3Var;
TFromFile3Var = packed record
  Tbl      : array of RealType;
  RowCount,
  ColCount : Integer;
 end;

PFromFile4Var = ^TFromFile4Var;
TFromFile4Var = packed record
  RowCount : Integer;
  FText    : TextFile;
  IsOpen   : Boolean
 end;

function TToFile(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:PToFileVar;Action:Integer):Integer;export;
function TFromFile1(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:PFromFileVar;Action:Integer):Integer;export;
function TFromFile2(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:PFromFileVar;Action:Integer):Integer;export;
function TFromFile3(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:PFromFile3Var;Action:Integer):Integer;export;
function TFromFile4(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:PFromFile4Var;Action:Integer):Integer;export;
function TFromFile5(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:TTable2;Action:Integer):Integer;export;
function TStopRun(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 TLAE(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 TLAE1(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 TLAE2(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

{********************************************************************************************************}
uses LinAlg,LUD;

type
PToFileRec = ^TToFileRec;
TToFileRec = packed record
  Parms    : TExtArray;
  FileName : PString;
  Count    : ^Integer;
  FForm    : ^Integer;
 end;

PFromFileRec = ^TFromFileRec;
TFromFileRec = packed record
  Count    : ^Integer;
  FileName : PString;
  k        : ^RealType;
 end;

PFromFile3Rec = ^TFromFile3Rec;
TFromFile3Rec = packed record
  Count    : ^Integer;
  FileName : PString;
 end;

PFromFile4Rec = ^TFromFile4Rec;
TFromFile4Rec = packed record
  Count    : ^Integer;
  FileName : PString;
  Tau      : PRealType;
 end;

PFromFile5Rec = ^TFromFile5Rec;
TFromFile5Rec = packed record
  Count    : ^Integer;
  FileName : PString;
end;

PLAERec = ^TLAERec;
TLAERec = packed record
 Count    : ^Integer;
end;

PLAEVar = ^TLAEVar;
TLAEVar = packed record
 A,B : TExtArray;
 Idn : TIntArray
end;

PStopRunRec = ^TStopRunRec;
TStopRunRec = packed record
 Mes       : PChar;
 MinV,MaxV : ^RealType
end;

{-------------------------------------------------------------------------------
 ВХОДНЫЕ ПАРАМЕТРЫ:
 ВЫХОДНЫЕ ПАРАМЕТРЫ:
-------------------------------------------------------------------------------}
function fl_ReadString(S:String;var fComment:Boolean):String;
var  j1,j2  : Integer;
begin
   S:=Trim(S);
   Result:=S;
   j1:=Pos('{',S);
   if (j1 = 0)and(not fComment) then exit
   else begin
    j2:=Pos('}',S);
    if not fComment then Result:=Copy(S,1,j1-1) else Result:='';
    fComment:=j2 = 0;
    if not fComment then Result:=Result+Copy(S,j2+1,Length(S));
    Result:=Trim(Result)
   end;
end;

{-------------------------------------------------------------------------------
 Функция возвращает число ненулевых строк
 в текстовом файле "FileName"
-------------------------------------------------------------------------------}
function fl_GetParamCount(FileName:String):Integer;
var  fText   : TextFile;
     S       : String;
     f       : Boolean;
begin
   AssignFile(fText,ExpandFileName(FileName));
   Reset(fText);
   Result:=0;
   f:=false;
   try
    while not SeekEof(fText) do begin
     ReadLn(fText,S);
     S:=Trim(S);
     S:=fl_ReadString(S,f);
     if S <> '' then Inc(Result)
    end;
   finally
    CloseFile(fText);
   end;
end;

{!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

                  Б Л О К И    О Т О Б Р А Ж Е Н И Я     И Н Ф О Р М А Ц И И

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

{---------------------------------------------------------------------------
 Запись таблицы в файл
---------------------------------------------------------------------------}
function TToFileConvert(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 PToFileRec(Prop.arr)^ do try
                   MVTU.SetBlockProp(BlockId,'step',PChar(ConvertVector(PropStr[0])),Res);
                   MVTU.SetBlockProp(BlockId,'filename',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'count',PChar(PropStr[2]),Res);
                   MVTU.ExecutePropScript(BlockId,Res,Res);
                   MVTU.SetBlockProp(BlockId,'fform',PChar(IntToStr(fform^)),Res);
                 finally
                 end;
  end;
end;

function TToFile;

procedure WriteToTextFile;
var SS    : String[20];
    x     : RealType;
    i,k   : Integer;
begin
 with PToFileRec(Prop.arr)^,Vars^ do begin
//  Append(FText);
  case FForm^ of
    0:SS:=FloatToStrF(at,ffExponent,4,2);
    1:SS:=FloatToStrF(at,ffExponent,7,2);
    2:SS:=FloatToStrF(at,ffExponent,10,2);
    3:SS:=FloatToStrF(at,ffExponent,13,2);
  end;
  Write(FText,SS);
  case FForm^ of
    0: for k:=0 to AU.Count-1 do with AU.Ptr(k) do
         for i:=0 to Count-1 do begin
           x:=arr^[i];
           SS:=FloatToStrF(x,ffExponent,4,2);
           Write(FText,' ',SS)
          end;
    1: for k:=0 to AU.Count-1 do with AU.Ptr(k) do
         for i:=0 to Count-1 do begin
           x:=arr^[i];
           SS:=FloatToStrF(x,ffExponent,7,2);
           Write(FText,' ',SS)
          end;
    2: for k:=0 to AU.Count-1 do with AU.Ptr(k) do
         for i:=0 to Count-1 do begin
           x:=arr^[i];
           SS:=FloatToStrF(x,ffExponent,10,2);
           Write(FText,' ',SS)
          end;
    3: for k:=0 to AU.Count-1 do with AU.Ptr(k) do
         for i:=0 to Count-1 do begin
           x:=arr^[i];
           SS:=FloatToStrF(x,ffExponent,13,2);
           Write(FText,' ',SS)
          end;
  end;
  Writeln(FText,' ');
//  Close(FText);
  repeat time:=time+dtime until time >= at;
  Inc(itime);
  if itime > Parms.Count-1 then itime:=0;
  dtime:=Parms.arr^[itime]
 end
end;

begin
 Result:=0;
 with PToFileRec(Prop.arr)^ do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TToFileConvert);
 f_EditErr    : Result:=Find_Error([er_noDirExist],[FileName],1);
 f_InitMem    : with PToFileVar(Vars)^ do begin
                  IsOpened:=False;
                  try
                   Assign(FText,FileName^);
                   ReWrite(FText);
                   IsOpened:=True;
                  except
                   IsOpened:=False;
//                   Result:=er_File
                  end
                end;
 f_Create     : Vars:=New(PToFileVar);
 f_InitTime   : with PToFileVar(Vars)^ do begin
                  itime:=0;
                  dtime:=Parms.arr^[itime];
                  time:=at
                end;
 f_RestoreOuts: WriteToTextFile;
 f_Free       : Dispose(Vars);
 f_Stop       : with PToFileVar(Vars)^ do if IsOpened then CloseFile(FText);
 f_GoodStep   : if at >= time then  WriteToTextFile
 end{END CASE}
end;{END TToFile}
{---------------------------------------------------------------------------
 Чтение таблицы из файла
 В файле в текстовом виде представлена двухмерная таблица данных.
 Первый столбец - независимая переменная - время;
 в остальных столбцах - зависящие от времени переменные.
 Размер столбцов произволен, но одинаков для всех столбцов.
 В качестве параметров блока задаются имя файла FileName и количество
 зависимых переменных Count в таблице.
 Выходом блока является вектор из Count чисел
 Обязательные условия - Count >= 1, независимая переменная в столбце монотонно
 возрастает.
---------------------------------------------------------------------------}
 function ReadDataFromFile(var theData : PFromFileVar; dSize:Integer;
                               FileName : string) : integer;
 var i,j : Integer;
     a   : RealType;
 begin
   Result := 0;
   theData := New(PFromFileVar);
   with theData^ do begin
     GetMem(py,dSize*SOfP); px:=TExtArray.Create(1);
     for i:=0 to dSize-1 do py^[i]:=TExtArray.Create(1);
     try
       Assign(FText,FileName); ReSet(FText); j:=0;
       try
         while not SeekEof(FText) do begin
           if SeekEoln(FText) then Readln(FText);
           Read(FText,a); for i:=0 to dSize-1 do Read(FText,a);
           Inc(j)
         end;
         ReSet(FText);          px.changecount(j);
         for i:=0 to dSize-1 do py^[i].changecount(j);
         for j := 0 to px.Count-1 do begin
           if SeekEoln(FText) then Readln(FText);
           Read(FText,px.arr^[j]);
           for i:=0 to dSize-1 do Read(FText,py^[i].arr^[j])
         end
       finally
         Close(FText)
       end
     except
       Result:=er_ReadFile;
       for i:=0 to dSize-1 do py^[i].Free;
       FreeMem(py,dSize*SOfP); px.Free;
       Dispose(TheData);       TheData:=nil
     end
   end
 end;
 procedure FreeFileData( var theData : PFromFileVar; dSize:Integer );
 var i : Integer;
 begin
   if assigned(theData) then with theData^ do begin
     for i:=0 to dSize-1 do py^[i].Free;
     FreeMem(py,dSize*SOfP);
     px.Free;
     Dispose(theData);
     theData:=nil
   end
 end;

function TFromFile1Convert(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,'count',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'filename',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'k',PChar(PropStr[2]),Res);
                 finally
                 end;
  end;
end;

function TFromFile1;
begin
 Result:=0;
 with PFromFileRec(Prop.arr)^ do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TFromFile1Convert);
 f_EditErr    : Result:=Find_Error([er_noDirExist,er_noFileExist,er_parzero],
                                   [FileName,FileName,k],3);
 f_GetInit    : Result:=1;
 f_GetCount   : CY.arr^[0]:=count^;
 f_InitMem    : Result:= ReadDataFromFile(Vars,count^,FileName^);
 f_Stop       : FreeFileData(Vars,count^);
 f_InitState,
 f_RestoreOuts,
 f_UpdateOuts,
 f_UpdateJacoby,
 f_GoodStep   : with Vars^ do GetTableData(px.count-1,at/k^,py,px,AY.Ptr(0));
 end{END CASE}
end;{END TFromFile1}
{---------------------------------------------------------------------------
 Чтение таблицы из файла
 В файле в текстовом виде представлена двухмерная таблица данных.
 Первый столбец - независимая переменная - вход в блок;
 в остальных столбцах - зависящие от входа переменные.
 Размер столбцов произволен, но одинаков для всех столбцов.

 Обязательные условия - Count >= 1, независимая переменная в столбце монотонно
 возрастает.
---------------------------------------------------------------------------}
function TFromFile2Convert(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,'count',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'filename',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'k',PChar(PropStr[2]),Res);
                 finally
                 end;
  end;
end;

function TFromFile2;
begin
 Result:=0;
 with PFromFileRec(Prop.arr)^ do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TFromFile2Convert);
 f_EditErr    : Result:=Find_Error([er_noDirExist,er_noFileExist,er_parzero],
                                   [FileName,FileName,k],3);
 f_GetCount   : begin
                 CY.arr^[0]:=count^;
                 CU.arr^[0]:=1
                end;
 f_InitMem    : Result:= ReadDataFromFile(Vars,count^,FileName^);
 f_Stop       : FreeFileData(Vars,count^);
 f_RestoreOuts,
 f_InitState,
 f_UpdateOuts,
 f_UpdateJacoby,
 f_GoodStep   : with Vars^ do GetTableData(px.count-1,AU.Ptr(0).arr^[0]/k^,py,px,AY.Ptr(0));
 end{END CASE}
end;{END TFromFile2}

{---------------------------------------------------------------------------
 Чтение таблицы из файла
 В файле в текстовом виде представлена двухмерная таблица данных.
 Размер столбцов произволен, но одинаков для всех столбцов.
 В качестве параметров блока задаются имя файла FileName и количество
 столбцов Count в таблице.
 Выходом блока является двухмерная таблица, отсортированная по столбцам размером
 Count*Rows чисел, где Rows - число прочитанных строк
 Обязательные условия - Count >= 1.
---------------------------------------------------------------------------}
function TFromFile3Convert(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,'count',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'filename',PChar(PropStr[1]),Res);
                 finally
                 end;
  end;
end;

function TFromFile3;
var i,j,k  : Integer;
    FText  : TextFile;
    S,S1   : String;
    fc     : Boolean;
begin
 Result:=0;
 with PFromFile3Rec(Prop.arr)^ do case Action of
 f_GetConvertFuncAdr: Result:=integer(@TFromFile3Convert);
 f_EditErr       : Result:=Find_Error([er_noDirExist,er_noFileExist],[FileName,FileName],2);
 f_GetInit       : Result:=1;
 f_GetCount      : with Vars^ do
                    for i:=0 to Count^-1 do CY.arr^[i]:=RowCount;
 f_Create        : begin
                    Vars:=New(PFromFile3Var);
                    with Vars^ do begin
                     RowCount:=0;
                     ColCount:=0;
                     SetLength(Tbl,RowCount*ColCount);
                    end
                   end;
 f_Free          : begin
                    SetLength(PFromFile3Var(Vars)^.Tbl,0);
                    Dispose(Vars);
                   end;
 f_InitObjects   : with Vars^ do begin
                    RowCount:=fl_GetParamCount(FileName^);
                    ColCount:=Count^;
                    SetLength(Tbl,RowCount*ColCount);
                    AssignFile(FText,ExpandFileName(FileName^));
                    ReSet(FText);
                    fc:=false;j:=0;
                    try
                     while not SeekEof(FText) do begin
                      ReadLn(FText,S);
                      S:=Trim(S);
                      S:=fl_ReadString(S,fc);
                      if S = '' then continue;
                      S:=Trim(S);
                      for i:=0 to ColCount-1 do begin
                       k:=Pos(' ',S);
                       if k = 0 then S1:=S else S1:=Copy(S,1,k-1);
                       if k = 0 then S:='' else S:=Copy(S,k+1,Length(S));
                       S:=Trim(S);
                       k:=Pos('=',S1);
                       if k >= 0 then S1:=Copy(S1,k+1,Length(S1));
                       try
                        Tbl[i*RowCount+j]:=StrToFloat(S1)
                       except
                        Tbl[i*RowCount+j]:=0
                       end;
                      end;
                      Inc(j);
                     end
                    finally
                     CloseFile(FText)
                    end;
                  end;
 f_InitState,
 f_RestoreOuts : with Vars^ do
                  for i:=0 to Count^-1 do
                   Move(Tbl[i*RowCount],AY.Ptr(i).arr^,RowCount*SOfR);
 end{END CASE}
end;{END TFromFile3}

{------------------------------------------------------------------------------}
function TFromFile4Convert(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,'count',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'filename',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'tau',PChar(PropStr[2]),Res);
                 finally
                 end;
  end;
end;

function TFromFile4;
var i      : Integer;
    S      : String;
label 1;
begin
 Result:=0;
 with PFromFile4Rec(Prop.arr)^ do
 case Action of
 f_GetConvertFuncAdr: Result:=integer(@TFromFile4Convert);
 f_EditErr       : Result:=Find_Error([er_noDirExist,er_noFileExist],[FileName,FileName],2);
 f_GetStateCount,
 f_GetInit       : Result:=1;
 f_GetCount      : CY.arr^[0]:=Count^;
 f_Create        : begin
                    GetMem(Vars,SizeOf(TFromFile4Var));
                    with Vars^ do begin
                     RowCount:=0;
                     IsOpen:=False;
                    end
                   end;
 f_Free          : begin
                    with Vars^ do if IsOpen then CloseFile(FText);
                    FreeMem(Vars,SizeOf(TFromFile4Var));
                   end;
 f_InitObjects : with Vars^ do begin
                    if IsOpen then begin
                     CloseFile(FText);
                     IsOpen:=False
                    end;
                    AssignFile(FText,ExpandFileName(FileName^));
                    ReSet(FText);RowCount:=0;
                    try
                     while not SeekEof(FText) do begin
                      ReadLn(FText,S);
                      S:=Trim(S);
                      if S <> '' then inc(RowCount)
                     end
                    finally
                     CloseFile(FText)
                    end;
                    ReSet(FText);
                    IsOpen:=True;
                 end;
 f_InitTime    : time:=at;
 f_Stop        : with Vars^ do if IsOpen then begin
                  CloseFile(FText);
                  IsOpen:=False
                 end;
 f_RestoreOuts : with Vars^ do begin
                  if Round(AX[0]) >= RowCount then exit;
                  for i:=1 to Round(AX[0])-1 do ReadLn(FText);
                  for i:=0 to Count^-1 do Read(FText,AY.Ptr(0).arr^[i]);
                  ReadLn(FText);
                 end;
 f_InitState   : begin
                  AX[0]:=0;
                  goto 1;
                 end;
 f_UpdateJacoby,
 f_GoodStep    : if time-at <= adt/2 then
1:               with Vars^ do begin
                  if Round(AX[0]) >= RowCount then exit;
                  for i:=0 to Count^-1 do Read(FText,AY.Ptr(0).arr^[i]);
                  ReadLn(FText);
                  AX[0]:=AX[0]+1.0;
                  Time:=Time+Tau^
                 end;
 end{END CASE}
end;
{---------------------------------------------------------------------------
 Таблично заданная функция от двух аргументов
 В файле в текстовом виде представлена таблично заданная функция двух аргументов.
 В качестве параметров блока задаются имя файла FileName, количество
 значений первого аргумента N1 (в первой строке таблицы), количество значений второго
 аргумента N2 (в первом столбце таблицы), а также число одновременно вычисляемых значений
 функции Count.
 Блок имеет два векторны входа и один векторный выход. Размерности
 всех входов/выходов одинаковы и равны Count.
 На первый вход поступает вектор размерностью Count значений первого аргумента,
 на второй вход - вектор размерностью Count значений второго аргумента,
 Выходом блока является вектор размерностью Count значений функции.
 Обязательные условия - Count >= 1.
---------------------------------------------------------------------------}
function TFromFile5Convert(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,'filename',PChar(PropStr[1]),Res);
                 finally
                 end;
  end;
end;

function TFromFile5;
var i      : Integer;
begin
 Result:=0;
 with PFromFile5Rec(Prop.arr)^ do
 case Action of
 f_GetConvertFuncAdr: Result:=integer(@TFromFile5Convert);
 f_EditErr       : Result:=Find_Error([er_noDirExist,er_noFileExist],[FileName,FileName],2);
 f_GetCount      : begin
                    CU.arr^[0]:=Count^;
                    CU.arr^[1]:=Count^;
                    CY.arr^[0]:=Count^;
                   end;
 f_Create        : Vars:=TTable2.Create('');
 f_Free          : Vars.Free;
 f_InitObjects   : Vars.OpenFromFile(FileName^);
 f_InitState,
 f_RestoreOuts,
 f_UpdateOuts,
 f_UpdateJacoby,
 f_GoodStep     : with Vars do
                   for i:=0 to Count^-1 do
                    AY.Ptr(0).arr^[i]:=GetFunValue(AU.Ptr(0).arr^[i],AU.Ptr(1).arr^[i]);
 end{END CASE}
end;
{------------------------------------------------------------------------------}
function TLAEConvert(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,'count',PChar(PropStr[0]),Res);
                 finally
                 end;
  end;
end;

function TLAE;
var j   : Integer;
    fLU : Boolean;
begin
 Result:=0;
 with PLAERec(Prop.arr)^ do CASE Action of
  f_GetConvertFuncAdr: Result:=integer(@TLAEConvert);
  f_GetCount : begin
                CU.arr^[1]:=Count^;
                CU.arr^[0]:=Sqr(Count^);
                CY.arr^[0]:=Count^
               end;
  f_Create   : begin
                GetMem(Vars,SizeOf(TLAEVar));
                with PLAEVar(Vars)^ do begin
                 A:=TExtArray.Create(1);
                 B:=TExtArray.Create(1);
                 Idn:=TIntArray.Create(1)
                end
               end;
  f_Free     : begin
                with PLAEVar(Vars)^ do begin
                 A.Free;
                 B.Free;
                 Idn.Free
                end;
                FreeMem(Vars,SizeOf(TLAEVar))
               end;
  f_InitObjects:
               with PLAEVar(Vars)^ do begin
                A.ChangeCount(Sqr(Count^));
                B.ChangeCount(Count^);
                Idn.ChangeCount(Count^)
               end;
  f_InitState,
  f_UpdateJacoby,
  f_RestoreOuts,
  f_UpdateOuts,
  f_GoodStep : with PLAEVar(Vars)^ do begin
                fLU:=false;
                for j:=0 to A.Count-1 do begin
                 fLU:=A.arr^[j] <> AU.Ptr(0).arr^[j];
                 if fLU then break;
                end;
                Move(AU.Ptr(0).arr^,A.arr^,A.Count*SOfR);
                if fLU then Result:=ludcmp(a.arr^,b.arr^,idn.arr^,Count^);
                if Result > 0 then exit;
                Move(AU.Ptr(1).arr^,B.arr^,Count^*SOfR);
                lubksb(a.arr^,b.arr^,idn.arr^,Count^);
                Move(B.arr^,AY.Ptr(0).arr^,Count^*SOfR)
               end;
 END
end;
{------------------------------------------------------------------------------}
function TLAE1Convert(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,'count',PChar(PropStr[0]),Res);
                 finally
                 end;
  end;
end;

function TLAE1;
var i,j : Integer;
    sum : RealType;
begin
 Result:=0;
 with PLAERec(Prop.arr)^ do
 CASE Action of
  f_GetConvertFuncAdr: Result:=integer(@TLAE1Convert);
  f_GetCount : begin
                CU.arr^[1]:=Count^;
                CU.arr^[0]:=Sqr(Count^);
                CY.arr^[0]:=Count^
               end;
  f_InitState,
  f_UpdateJacoby,
  f_RestoreOuts,
  f_UpdateOuts,
  f_GoodStep : for i:=0 to Count^-1 do begin
                sum:=0;
                for j:=0 to Count^-1 do sum:=sum+AU.Ptr(0).arr^[i*Count^+j]*AU.Ptr(1).arr^[j];
                AY.Ptr(0).arr^[i]:=sum
               end;
 END
end;
{------------------------------------------------------------------------------}
function TLAE2Convert(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,'count',PChar(PropStr[0]),Res);
                 finally
                 end;
  end;
end;

function TLAE2;
var i,j : Integer;
begin
 Result:=0;
 with PLAERec(Prop.arr)^ do CASE Action of
  f_GetConvertFuncAdr: Result:=integer(@TLAE2Convert);
  f_GetCount : begin
                CU.arr^[0]:=Sqr(Count^);
                CY.arr^[0]:=Sqr(Count^);
               end;
  f_InitState,
  f_UpdateJacoby,
  f_RestoreOuts,
  f_UpdateOuts,
  f_GoodStep : for i:=0 to Count^-1 do
                for j:=0 to Count^-1 do
                 AY.Ptr(0).arr^[i*Count^+j]:=AU.Ptr(0).arr^[j*Count^+i]
 END
end;
{---------------------------------------------------------------------------
Остановка моделирования, если входной сигнал
входит в пределы заданного диапазона
---------------------------------------------------------------------------}
function TStopRunConvert(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,'msg',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'xmin',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'xmax',PChar(PropStr[2]),Res);
                 finally
                 end;
  end;
end;

function TStopRun;

const
   {$IFDEF ENGLVER}
   txtStopMessage = 'You wish to stop calculation ?';
   {$ELSE}
   txtStopMessage = 'Остановить расчет ?';
   {$ENDIF}
begin
 Result:=0;
 with PStopRunRec(Prop.arr)^ do
 case Action of
  f_GetConvertFuncAdr: Result:=integer(@TStopRunConvert);
  f_GetCount      : CU.arr^[0]:=1;
  f_Create        : GetMem(Vars,SOfB);
  f_Free          : FreeMem(Vars,SOfB);
  f_InitTime      : Boolean(Vars^):=True;
  f_RestoreOuts,
  f_UpdateOuts,
  f_GoodStep      : if (AU.Ptr(0).arr^[0] <= MaxV^) and
		       (AU.Ptr(0).arr^[0] >= MinV^) then begin
                     if Boolean(Vars^) then
                      if StrLen(Mes) = 0 then Result:=er_StopRun
                       else if MessageBox(0,Mes,txtStopMessage,
                       mb_IconStop or mb_YesNo) = idYes then Result:=er_StopRun;
                     Boolean(Vars^):=False
                    end;
 end
end;
{------------------------------------------------------------------------------}
END.