Перевод программы с Pascal на C#

KT*T=600
 KU=200.
uses crt,graph;
CONST
    MaxT=15;
    MaxU=100; 
    MaxV=100; 
    MaxRB=100;
    MaxH=100;
Type
    MassVetType=array[1..MaxV] of integer; 
Var
 
    U1,U2:MassVetType;
    M:Array [1..MaxV div 2,1..MaxV div 2] of Integer; 
    P:MassVetType;
    i,j,CH,CRB,CE,CC,CR,CT,CD,CU,CV,KT,KU:integer;
    Impulse,IC,Peredat,InputU,OutputU:byte;
    CheckOnly:byte;
    TR :array[1..MaxT]of record
                  TTP   :byte;  
                  B,E,K :integer;   
             end;
   TTE,MFTE,CBEO,RUE,TAU,TTK,MFTK,CBKO,RUK,
   TAUU,B,Bu,TTD,MFTD,CBDO,RUD,TAUD:real;
   RB,RK,RD:real;
   Level0,Level1:real;
   KFrontF,KBackF:real;
   KInU,KOutU:byte;
   Method:byte;
   MDU,M1,M2,
   TT,
   TIMP,TSAD,
   H,
   HP,TP,TK:real;
   UR:array [1..MaxRB] of real;
   C:array [1..MaxRB] of real;
   R:array [1..MaxH] of real;
   F: Text;
   Chr:Char;
   Strg:String[7];
   SUR_N:integer;
   UR_N:array [1..10] of integer;
   SUH_N:integer;
   UH_N:array [1..10] of integer;
   GRPH:boolean;
 
 
 
PROCEDURE READDATA ;
begin
KT:=60;KU:=40;
M1:=0.05;
M2:=0.001;
TTE:=2.2E-8;
TTK:=1.7E-6;
TTD:=9.0E-8;
MFTE:=0.033;
MFTK:=0.036;
MFTD:=0.034;
CBEO:=3.4E-2;
CBKO:=4.0E-2;
CBDO:=4.0E-2;
B:=100;
Bu:=1;
TAU:=2.0E-1;
TAUU:=6.2E-1;
TAUD:=6.0E-1;
RUE:=1.0E3;
RUK:=1.0E3;
RUD:=1.0E3;
RB:=0.1;
RK:=0.012;
RD:=0.1;
GRPH:=true;
HP:=0.01;
Impulse:=0;
TSAD:=30;
TIMP:=30;
Peredat:=0;
IC:=0;
KFrontF:=1; KBackF:=1;
KInU:=50;   KOutU:=20;
Method:=2;
CheckOnly:=0;
Level1:=2.4;   Level0:=0.4;  
  Assign(F, ParamStr(1));
  Reset(F);
  while not Eof(F) do
  begin
    Strg:='';
    repeat
      read(F,Chr);
      Strg:=Strg+Chr;
    until (Chr='=');
 
    case Strg[1] of
      'P':read(F,Peredat);
      'O':read(F,OutputU);
      'I':case Strg[2] of
           'M':read(F,Impulse);
       'N':read(F,InputU);
           'C':read(F,IC);
      end;
      'C':case Strg[2] of
       'T':read(F,CT);
       'D':read(F,CD);
       'E':read(F,CE);
           'H':read(F,CheckOnly);
       'C':read(F,CC);
       'R':read(F,CR);
       'U':read(F,CU);
       'V':read(F,CV);
       'B':case Strg[3] of
        'E':read(F,CBEO);
        'K':read(F,CBKO);
        'D':read(F,CBDO);
           end;
       '=':for j:=1 to CC do read(F,C[j]);
      end;
      'M':case Strg[2] of
       '1':read(F,M1);
       '2':read(F,M2);
           'E':read(F,Method);
       'F':case Strg[4] of
        'E':read(F,MFTE);
        'K':read(F,MFTK);
        'D':read(F,MFTD);
           end;
      end;
      'B':case Strg[2] of
       '=':read(F,B);
       'u':read(F,Bu);
      end;
      'T':case Strg[2] of
           'I':read(F,TIMP);
           'S':read(F,TSAD);
       'T':case Strg[3] of
        'E':read(F,TTE);
        'K':read(F,TTK);
        'D':read(F,TTD);
           end;
       'A':case Strg[4] of
        '=':read(F,TAU);
        'U':read(F,TAUU);
        'D':read(F,TAUD);
           end;
       'K':read(F,TK);
       'R':for j:=1 to CT+CD do
        begin readln(F);
              read(F,TR[j].TTP, TR[j].B, TR[j].E, TR[j].K);
        end;
      end;
      'R':case Strg[2] of
       'U':case Strg[3] of
         'E':read(F,RUE);
         'K':read(F,RUK);
         'D':read(F,RUD);
           end;
       '=':for i:=1 to CR do read(F,R[i]);
       'B':read(F,RB);
       'K':read(F,RK);
       'D':read(F,RD);
      end;
      'U':for i:=1 to CV do begin readln(F);
                  read(F,U1[i],U2[i]);
                end;
      'E':for j:=1 to CE do read(F,UR[j]);
      'K':case Strg[2] of
           'I':read(F,KInU);
           'O':read(F,KOutU);
       'U':read(F,KU);{ U koefficient }
       'T':read(F,KT);{ T koefficient }
           'F':read(F,KFrontF);
           'B':read(F,KBackF);
           end;
      'S':case Strg[6] of
       'R':begin
            read(F,SUR_N);
            for i:=1 to SUR_N do read(F,UR_N[i]);
           end;
       'H':begin
            read(F,SUH_N);
            for i:=1 to SUH_N do read(F,UH_N[i]);
           end;
      end;
      'L':case Strg[6] of
      '0':read(F,Level0);
      '1':read(F,Level1);
      end;
      'G':begin
        read(F,i); if i=0 then GRPH:=false;
      end;
      'H':read(F,HP);
 
    end;
   readln(F);
  end;
  close(F);
  clrscr;
  if ParamStr(2)<>'nowrite' then
    begin
      writeln('--- Исходные данные --- файл: ',ParamStr(1));
      writeln(' CT=',CT,' CD=',CD,' CE=',CE,' CC=',CC,' CR=',CR,' CU=',CU,' CV=',CV);
      writeln('Ветви:');
      for j:=1 to CV do write(' {',U1[j],',',U2[j],'}');
             writeln;
 
      writeln('Транзисторы и диоды:');
      for j:=1 to CT+CD do
         write('{',TR[j].TTP,TR[j].B,TR[j].E,TR[j].K,'}');
         writeln;
 
      for j:=1 to CE do write(' E[',j,']=',UR[j]:1:1);
            writeln;
      for j:=1 to CC do write(' C[',j,']=',C[j]:1:3);
            writeln;
      for i:=1 to CR do write(' R[',i,']=',R[i]:3:3);
            writeln;
 
      writeln('TK=',TK:1:0,' KU=',KU,' KT=',KT,' M1=',M1:1:3,' M2=',M2:1:3);
 
      write('Выводимые напряжения ');
      if GRPH then writeln('(графически):')
           else writeln('(таблично):');
      write('Ребер (',SUR_N,'):');
      for i:=1 to SUR_N do write(' ',UR_N[i]);
      writeln;
      write('Хорд (',SUH_N,'):');
      for i:=1 to SUH_N do write(' ',UH_N[i]);
      writeln; writeln('Шаг печати =',HP:1:3);
      writeln;
      writeln('Электрические параметры');
      writeln('MFTE=',MFTE:1:3,' MFTK=',MFTK:1:3,' MFTD=',MFTD:1:3);
      writeln('B=',B:3:3,' Bu=',Bu:3:3);
      writeln('TTE=',TTE:1:6,' TTK=',TTK:1:6,' TTD=',TTD:1:6);
      writeln('TAU=',TAU:1:6,' TAUU=',TAUU:1:6,' TAUD=',TAUD:1:6);
      writeln('CBEO=',CBEO:1:6,' CBKO=',CBKO:1:6,' CBDO=',CBDO:1:6);
      write('RB=',RB:3:2,' RK=',RK:3:2,' RD=',RD:3:2);
      writeln('RUE=',RUE:3:2,' RUK=',RUK:3:2,' RUD=',RUD:3:2);
      readkey;
      clrscr;
      writeln('---------------Дополнительные параметры файл: ',ParamStr(1),' -----');
      write('Импульсный режим - ');
      case Impulse=1 of
        true:writeln('включено.');
        false:writeln('выключено.');
      end;
      write('Режим передаточной функции - ');
      case Peredat=1 of
        true:begin
               writeln('включено.');
               writeln('Шаг входного напряжения - ',KInU);
               writeln('Шаг выходного напряжения - ',KOutU);
             end;
        false:writeln('выключено.');
      end;
      writeln('Время задержки - ',TSad:3:2,'нс.');
      writeln('Длительность импульса - ',TImp:3:2,'нс.');
      writeln('Тангенс наклона переднего фронта - ',KFrontF:3:3);
      writeln('Тангенс наклона заднего фронта - ',KBackF:3:3);
      writeln('Входное напряжение - ребро #',InputU);
      writeln('Выходное напряжение - ребро #',OutputU);
      write('Управляющее напряжение - ');
      case IC=1 of
        true:
          begin
             writeln('отрицательное');
             writeln('  ноль: -',Level0:3:2,' В, единица: -',Level1:3:2,' В.');
          end;
        false:
           begin
              writeln('положительное');
              writeln('  ноль: ',Level0,' В, единица: ',Level1,' В.');
           end;
      end;
      write('Метод интегрирования - ');
      case Method=1 of
        true: writeln('старый.');
        false: writeln('новый.');
      end;
      write('Коррекция дерева - ');
      case CheckOnly=1 of
        true: writeln('вручную');
        false: writeln('автоматически');
      end;
      readkey;
      clrscr;
  end;
END;

procedure CorrectTree;
 
var  TempNode:MassVetType;
     Tempfile:text;
     Help:text;
     Point,Point2:byte;
     Error,FlError:Boolean;
     i,j,k,l:integer;
     Ch:char;
 
procedure AddNode(tNode:integer);
begin
   inc(k);
   TempNode[k]:=tNode;
end;
 
function Search(sNode:integer):boolean;
var Fl:boolean;g:integer;
begin
  Fl:=false;
  for g:=1 to k do
    begin
      if sNode=TempNode[g] then Fl:=true;
    end;
  Search:=Fl;
end;
function Scan(Node:integer;pBegin,pEnd:byte;var Number:byte):boolean;
var Flag:boolean;
    x:integer;
begin
  Flag:=false;x:=pBegin;
  while ((x>=pBegin) and (x<=pEnd)) and not Flag do
    begin
      if (U1[x]=Node) or (U2[x]=Node) then
    begin Flag:=true; Number:=x-pBegin+1 end;
      inc(X);
    end;
  Scan:=Flag;
{  writeln('     Scan(',Node,',',pBegin,',',pEnd,',',Number,')',Flag);}
  writeln(Tempfile,'  Scan(',Node,',',pBegin,',',pEnd,',',Number,')',Flag);
end;
 
procedure ReadNumber(var Value:integer);
var TempCH:string;
    CHordOld:integer;
    CHord:integer;
begin
     readln(TempCh);
     CHordOld:=CE+CT*2+CD+CC;
     j:=0;Val(TempCh,CHord,j);
     if (TempCh<>'') and (TempCh<>' ') and (CHord<=CHordOld) and (CHord>0)
     then
       begin
         j:=0;Val(TempCh,Value,j);
         if j<>0 then writeln;
         exit;
       end
     else
      begin
       writeln;
       exit
      end
end;
 
procedure QueryForNumbers;
var i,j,k:byte;
begin
 writeln(' : ');
 write('  Ребер (',SUR_N,'):');
 for i:=1 to SUR_N do write(' ',UR_N[i]);
 writeln;
 write( ?(Y/N)');
 repeat
   Ch:=readkey;
 until UpCase(Ch) in ['Y','N'];
 writeln;
 if UpCase(Ch)='Y' then
   begin
     write;
     ReadNumber(SUR_N);
     writeln;
     for i:=1 to SUR_N do ReadNumber(UR_N[i]);
   end
end;
  Assign(Tempfile,'correct.rep');
  Rewrite(Tempfile);
  WriteLn(TempFile, ',ParamStr(1),'.');
  writeln(TempFile);
      Assign(Help,'help.rep');
      Rewrite(Help);
      writeln(Help, файла',ParamStr(1),'.');
  writeln(',ParamStr(1),'...');
  if CheckOnly=1 then writeln( );
  FlError:=false;
  for k:=1 to MaxH do TempNode[k]:=0;
  k:=1;
  for i:=1 to CT+CD do
    begin{1}
    Error:=false;
      if (TR[i].B=0) or Scan(TR[i].B,1,CE,Point)  or Search(TR[i].B) then
    begin
         writeln(Tempfile,'Transistor #',i,' - base OK.');
         if not Search(TR[i].B) then AddNode(TR[i].B);
    end
       else
     begin{2}
        if Scan(TR[i].B,CE+1,CE+CC,Point) then
          begin{3}
                Writeln(Tempfile,'     To condensator #',Point);
                while Scan(U1[CE+Point],CE+1,CE+CC,Point2) and (Point2<>Point) and not Error do{4}
                 for j:=1 to CT do
                    begin{5}
                      if  (U1[CE+Point2]=TR[j].B)
                or ( (U1[CE+Point2]=TR[j].E) and (i<>j) )
                        or (U1[CE+Point2]=TR[j].K)
                or Scan(U1[CE+Point2],CE+CC,CV,Point) then
                  begin{6}
                       Error:=true;            
                           FlError:=true;
                           AddNode(TR[i].B);
                           C[CC+1]:=C[1];
                           writeln(Tempfile,'* To resistor or transistor through condensator #',Point2);
                           write;
                           write(Help,'Емкость на базу ',i,'-го транзистора, ');
               for k:=CV downto CE+CC do
                             begin{7}
                               U1[k+1]:=U1[k];
                               U2[k+1]:=U2[k];
                             end;{7}
                           inc(CC);write(Tempfile,' CC=',CC);
                           inc(CV);writeln(Tempfile,' CV=',CV);
                           writeln(' ребро №',CE+CT*2+CD+CC);
                           writeln(Help,' ребро №',CE+CT*2+CD+CC);
                           U1[CE+CC]:=TR[i].B;
               U2[CE+CC]:=0;
                          end;{6}
            end;{5}
               end{3}
              else
                 begin{8}
                    C[CC+1]:=C[1];
                    Error:=true;
                    FlError:=true;
                    Write(Tempfile,'* To resistor');
                    write('Емкость на базу ',i,'-го транзистора,');
                    write(Help,'Емкость на базу ',i,'-го транзистора,');
               for k:=CV downto CE+CC do
                             begin{7}
                               U1[k+1]:=U1[k];
                               U2[k+1]:=U2[k];
                             end;{7}
                           inc(CC);write(Tempfile,' CC=',CC);
                           inc(CV);writeln(Tempfile,' CV=',CV);
                           writeln(' ребро №',CE+CT*2+CD+CC);
                           writeln(Help,' ребро №',CE+CT*2+CD+CC);
                    U1[CE+CC]:=TR[i].B;
            U2[CE+CC]:=0;
                 end;{8}
        if not Error then writeln(TempFile,'Transistor #',i,' - base OK.')
        else writeln(TempFile,'Transistor #',i,' - base corrected');
        if not Search(TR[i].B) then AddNode(TR[i].B);
    end;{2}
      if (TR[i].E=0) or Scan(TR[i].E,1,CE,Point)  or Search(TR[i].E) then
    begin
         writeln(TempFile,'Transistor #',i,' - emitter OK.');
         if not Search(TR[i].E) then AddNode(TR[i].E);
    end
       else
     begin{2}
        if Scan(TR[i].E,CE+1,CE+CC,Point) then{к емкости}
          begin{3}
                Writeln(TempFile,'     To condensator #',Point);
                while Scan(U1[CE+Point],CE+1,CE+CC,Point2) and (Point2<>Point) and not Error do{4}
                 for j:=1 to CT do
                    begin{5}
                      if  (U1[CE+Point2]=TR[j].E)
                or ( (U1[CE+Point2]=TR[j].B) and (i<>j) )
                        or (U1[CE+Point2]=TR[j].K)
                or Scan(U1[CE+Point2],CE+CC,CV,Point) then
                               Error:=true;              
                             begin{7}
                               U1[k+1]:=U1[k];
                               U2[k+1]:=U2[k];
                             end;{7}
                           inc(CC);write(TempFile,' CC=',CC);
                           inc(CV);writeln(TempFile,' CV=',CV);
                           writeln(' ребро №',CE+CT*2+CD+CC);
                           writeln(Help,' ребро №',CE+CT*2+CD+CC);
                           U1[CE+CC]:=TR[i].E;
               U2[CE+CC]:=0;
                          end;{6}
            end;{5}
               end{3}
              else
                 begin{8}
                    C[CC+1]:=C[1];
                    Error:=true;
                    FlError:=true;
                    Write(Tempfile,'* To resistor');
                    write('Емкость на эмиттер ',i,'-го транзистора,');
                    write(Help,'Емкость на эмиттер ',i,'-го транзистора,');
               for k:=CV downto CE+CC do
                             begin{7}
                               U1[k+1]:=U1[k];
                               U2[k+1]:=U2[k];
                             end;{7}
                           inc(CC);write(TempFile,' CC=',CC);
                           inc(CV);writeln(TempFile,' CV=',CV);
                           writeln(' ребро №',CE+CT*2+CD+CC);
                           writeln(Help,' ребро №',CE+CT*2+CD+CC);
                    U1[CE+CC]:=TR[i].E;
            U2[CE+CC]:=0;
                 end;{8}
           if not Error then writeln(TempFile,'Transistor #',i,' - emitter OK.')
       else writeln(TempFile,'Transistor #',i,' - emitter corrected.');
           if not Search(TR[i].E) then AddNode(TR[i].E);
    end;{2}

if i<=CT then{не диод}
      if (TR[i].K=0) or Scan(TR[i].K,1,CE,Point)  or Search(TR[i].K) then
    begin
         writeln(TempFile,'Transistor #',i,' - collector OK.');
         if not Search(TR[i].K) then AddNode(TR[i].E);
    end
       else
     begin{2}
        if Scan(TR[i].K,CE+1,CE+CC,Point) then{к емкости}
          begin{3}
                Writeln(TempFile,'     To condensator #',Point);
                while Scan(U1[CE+Point],CE+1,CE+CC,Point2) and (Point2<>Point) and not Error do{4}
                 for j:=1 to CT do
                    begin{5}
                      if  (U1[CE+Point2]=TR[j].B)
                or (U1[CE+Point2]=TR[j].E)
                        or (U1[CE+Point2]=TR[j].K)
                or Scan(U1[CE+Point2],CE+CC,CV,Point) then
                  begin{6}
                       Error:=true;              {нормализация}
                           FlError:=true;
                           AddNode(TR[i].K);
                           C[CC+1]:=C[1];
                           write(TempFile,'* To resistor or transistor through condensator #',Point2);
                           write('Емкость на коллектор ',i,'-го транзистора,');
                           write(Help,'Емкость на коллектор ',i,'-го транзистора,');
               for k:=CV downto CE+CC do
                             begin{7}
                               U1[k+1]:=U1[k];
                               U2[k+1]:=U2[k];
                             end;{7}
                           inc(CC);write(TempFile,' CC=',CC);
                           inc(CV);writeln(TempFile,' CV=',CV);
                           writeln(' ребро №',CE+CT*2+CD+CC);
                           writeln(Help,' ребро №',CE+CT*2+CD+CC);
                           U1[CE+CC]:=TR[i].K;
               U2[CE+CC]:=0;
                          end;{6}
            end;{5}
               end{3}
              else
                 begin{8}
                    C[CC+1]:=C[1];
                    Error:=True;
                    FlError:=true;
                    Write(TempFile,'* To resistor');
                    write('Емкость на коллектор ',i,'-го транзистора,');
                    write(Help,'Емкость на коллектор ',i,'-го транзистора,');
               for k:=CV downto CE+CC do
                             begin{7}
                               U1[k+1]:=U1[k];
                               U2[k+1]:=U2[k];
                             end;{7}
                           inc(CC);write(TempFile,' CC=',CC);
                           inc(CV);writeln(Tempfile,' CV=',CV);
                           writeln(' ребро №',CE+CT*2+CD+CC);
                           writeln(Help,' ребро №',CE+CT*2+CD+CC);
                    U1[CE+CC]:=TR[i].K;
            U2[CE+CC]:=0;
                 end;{8}
          if not Error then writeln(TempFile,'Transistor #',i,' - collector OK.')
      else writeln(TempFile,'Transistor #',i,' - collector OK.');
          if not Search(TR[i].K) then AddNode(TR[i].K);
    end;{2}
end;
for i:=1 to CU-1 do{коррекция для оставшихся узлов}
    if not Search(i) then
      begin
        if (Scan(i,1,CE,Point)) or (Scan(i,CE+1,CE+CC,Point2)) then
          begin
            AddNode(i);
          end
        else{не к емкости, напряжению или земле}
        begin
          C[CC+1]:=C[1];
          Error:=True;
          FlError:=true;
          Write(TempFile,'* To resistors');
          write('Емкость на узел №',i);
          write(Help,'Емкость на узел №',i);
               for k:=CV downto CE+CC do
                            begin{7}
                               U1[k+1]:=U1[k];
                               U2[k+1]:=U2[k];
                             end;{7}
                   inc(CC);write(TempFile,' CC=',CC);
                   inc(CV);writeln(Tempfile,' CV=',CV);
                   writeln(', ребро №',CE+CT*2+CD+CC);
                   writeln(Help,', ребро №',CE+CT*2+CD+CC);
                   U1[CE+CC]:=TR[i].K;
               U2[CE+CC]:=0;
        end;
 
 end;
 
if FlError then
  begin
   if CheckOnly=0 then
     begin
       WriteLn('дерево успешно откорректировано.');
       writeln(TempFile,'Дерево успешно откорректировано от неправильных размещений.');
     end
   else
     begin
       writeln('Расчет невозможен - имеются неправильные размещения.');
       writeln(Help,'Добавьте эти емкости, и дерево станет правильным.');
       Close(Help);
       readkey;
       halt(0)
     end;
  end
else
  begin
   writeln('коррекция не требуется.');
   writeln(TempFile,'Коррекция не требуется - дерево правильное.');
   Close(Help)
  end;
Close(Tempfile);
readkey;
if FlError then QueryForNumbers;
end;
{-------------------------B L O C K  1-----------------------------------------------}
 
PROCEDURE  Tr2Polusnik(y1,y2:massVetType; Var CU,CV:integer);
 
Var
   Nu1,Nu2:MassVetType;
   Cus,i,k,n:integer;
Begin
   k:=0;
   for i:=1 to CT do
     begin
     inc(k);
     if TR[i].TTP=0 then
       begin
       {Rb}
       Nu1[k]:=TR[i].B;
       inc(Cu);
       Cus:=Cu;
       Nu2[k]:=Cus;
       {Rk}
       inc(k);inc(Cu);
       Nu1[k]:=Cu;
       Nu2[k]:=TR[i].K;
       {Ce}
       inc(k);
       Nu1[k]:=Cus;
       Nu2[k]:=TR[i].E;
       {Ck}
       inc(k);
       Nu1[k]:=Cus;
       Nu2[k]:=Cu;
       end { if npn }
         else  { if pnp }
     begin
     {Rb}
     Nu2[k]:=TR[i].B;
     inc(Cu); Cus:=Cu;
     Nu1[k]:=Cus;
     {Rk}
     inc(k); inc(Cu);
     Nu1[k]:=TR[i].K;
     Nu2[k]:=Cu;
     {Ce}
     inc(k);
     Nu1[k]:=TR[i].E;
     Nu2[k]:=Cus;
     {Ck}
     inc(k);
     Nu1[k]:=Cu;
     Nu2[k]:=Cus;
     end; { if pnp }
     end;
 for i:=CT+1 to CT+CD do
    Begin
    inc(Cu); inc(k);
    {Rg} Nu1[k]:=TR[i].B; Nu2[k]:=Cu;
    {Cg} inc(k);
    Nu1[k]:=Cu;Nu2[k]:=TR[i].E;
    end;
 
 for i:=1 to CE do  begin
  u1[i]:=y1[i];
  u2[i]:=y2[i];
  end;
 i:=CE+1;j:=CE+CC+CR+2*CT+CD+1;k:=1;
 for n:=1 to CT do begin
   u1[j]:=Nu1[k];
   u2[j]:=Nu2[k];
   u1[j+1]:=Nu1[k+1];
   u2[j+1]:=Nu2[k+1];
   u1[i]:=Nu1[k+2];
   u2[i]:=Nu2[k+2];
   u1[i+1]:=Nu1[k+3];
   u2[i+1]:=Nu2[k+3];
   inc(i,2); inc(j,2); inc(k,4);
   end;
 for n:=1 to CD do begin
    u1[j]:=Nu1[k];
    u2[j]:=Nu2[k];
    u1[i]:=Nu1[k+1];
    u2[i]:=Nu2[k+1];
    inc(i); inc(j); inc(k,2);
    end;
 k:=CE+1;
 for n:=1 to CC+CR do begin
    u1[i]:=y1[k];
    u2[i]:=y2[k];
    inc(i);
    inc(k);
    end;
 CV:=CV+4*CT+2*CD;
 
for i:=1 to CT do begin R[CR+i*2-1]:=RB;
            R[CR+i*2]:=RK;
          end;
 
for i:=1 to CD do R[CR+CT*2+i]:=RD;
 
for i:=1 to CC do C[2*CT+CD+i]:=C[i];
 
CC:=CC+2*CT+CD;
END;
 
 
{-------------------B L O C K  3------------------------------------}
Procedure ChooseNormalTree(CU,CV:integer;U1,U2:MassVetType;
               var CRB,CH:integer; P:MassVetType);
var
    I,J:integer;
    TempFile:text;
Begin
CRb:=0;
For I:=1 To Cv Do
    Begin
    If U1[I]<>U2[I] Then
       Begin
       For J:=I+1 To Cv Do
    begin
       If U1[J]=U2[I] Then U1[J]:=U1[I];
       If U2[J]=U2[I] Then U2[J]:=U1[I];
    end;
       P[I]:=I;
       Inc(CRb)
       End
    End;
Ch:=Cv-CRb;
 {============== OUTPUT CRB,P ===================}
Assign(TempFile,'tree.rep');
ReWrite(TempFile);
writeln(TempFile,'Протокол выбора нормального дерева для файла ',ParamStr(1));
writeln(TempFile,'CRb:',Crb);
writeln(TempFile,'P:');
for i:=1 to Crb do begin
  writeln(TempFile,' ',i,'.',P[i]);
  end;
close(TempFile);
For J:=1 To CRb Do
    For I:=1 To Ch Do M[I,J]:=0;
End;
 
Procedure CreateM(CRB,CH:integer);
var
 i,j,mm,Q,KU,SN,n,K,K1,UU:integer;
 UPU,USU:array [1..MaxV div 2] of integer;
 
begin
  for i:=1 to MaxV div 2 do begin UPU[i]:=0;USU[i]:=0; end;
  j:=1;mm:=0;Q:=0;
{  while mm<CU-1 do
    begin
       KU:=0;i:=1;
       while i<=CRB do
     if U1[i]=-1 then i:=i+1
     else
        if U1[i]<>j then
         if U2[i]<>j then i:=i+1
         else
          begin
           if U1[i]=j then SN:=1
              else SN:=2;
           KU:=KU+1;
           if KU<=1 then
          begin
            Q:=Q+1; UPU[Q]:=i; i:=i+1
          end
           else
         begin
           Q:=Q-1; j:=j+1; n:=1;
           while n<=mm do
             if j=USU[n] then
               begin
             j:=j+1; n:=0
               end;
           continue;
         end;
          end;}
  while mm<=CU-1 do
    begin
      KU:=0; i:=0;
      while (i<=CRB) and (KU<=1) do
    begin
      if U1[i]<>0 then
        if (U1[i]=j) or (U2[i]=j) then
          begin
        if U1[i]=j then SN:=1
               else SN:=2;
        KU:=KU+1;
        Q:=Q+1;
        UPU[Q]:=i;
          end;
      i:=i+1;
    end;
      if KU<>1 then
    begin
      if KU>1 then Q:=Q-2;
      j:=j+1;
      n:=1;
        while n<=mm do
        begin
          if j=USU[n] then
            begin
               j:=j+1;
               n:=0;
            end;
          n:=n+1;
        end;
      continue;
     end;
      mm:=mm+1;
      USU[mm]:=j;
      UU:=UPU[Q];
      K1:=0;
      K:=CRB+1;
    while K<=CV do
      begin
        K1:=K1+1;
      if U1[K]<>U2[K] then
        if U1[K]=j then
          if SN=1 then begin
                 U1[K]:=U2[UU];
                 M[K1,UU]:=-1;
               end
              else begin
                 U1[K]:=U1[UU];
                 M[K1,UU]:=1;
               end
            else
        if U2[K]=j then
          if SN=2 then begin
                 U2[K]:=U1[UU];
                 M[K1,UU]:=-1;
               end
              else begin
                 U2[K]:=U2[UU];
                 M[K1,UU]:=1;
               end;
        K:=K+1;
      end;
      U1[UU]:=0;
      U2[UU]:=0;
      j:=1;
    end;
 clrscr;
 Writeln('M-матрица');
    for i:=1 to CH do
      begin
       for j:=1 to CRB do
      begin
       gotoxy(j*3,i+1);
       write(M[i,j]);
      end;
      end;
    readkey;
end;
 
procedure Solution;
var
 Gd,Gm:integer;
 TT,TP,S,RMDU,buf:real;
 i,j,KL,Code:integer;
 LUp,LDown:real;
 KSH:Longint;{интервал значений от -2147483648 до +2147483647}
 T0,T1,T2,T3:real;
   UH:array [1..MaxH] of real;
   TH:array [1..MaxH] of real;
   TC:array [1..MaxRB] of real;
   TD:array [1..MaxRB] of real;
   DUC,RDU:array [1..MaxRB] of real;
   outStr:string[3];numstr:string;
 
begin
 
if GRPH then
 begin
  Gd:=Detect;
  initgraph(Gd,Gm,'');
  setcolor(8);
  i:=1;
  while i*KU<240 do
  begin
  setcolor(8);
    line(20,240-i*KU,639,240-i*KU);
    line(20,240+i*KU,639,240+i*KU);
  if i<10 then begin
  setcolor(15);
    str(i,outstr);
    outtextxy(1,235-i*KU,outstr);
    str(-i,outstr);
    outtextxy(1,235+i*KU,outstr);
    end;
    i:=i+1;
  end;
 
  i:=1;
  while i*KT<640  do
  begin
  setcolor(8);
    line(i*KT+20,0,i*KT+20,480);
 
  if (i<5) or ((i mod 5)=0) then begin
  setcolor(15);
    str(i,outstr);
    outtextxy(i*KT+15,245,outstr);
   end;
    i:=i+1;
  end;
  setcolor(15);
 
  if Peredat=1 then
    begin
      line(300,420,639,420);
      line(320,300,320,435);
  for i:=1 to 5 do
    begin
      str(i,outstr);
      outtextxy(300,420-i*KOutU,outstr){вертикаль}
    end;
  for i:=1 to 6 do
    begin
      str(i,outstr);
      outtextxy(320+i*KInU,425,outstr){горизонталь}
    end;
  end;
 
  line(0,240,639,240);
  line(20,15,20,479);
  outtextxy(1,5,'U,B');
  outtextxy(590,230,'T,нc');
  outtextxy(280,0,'Файл');outtextxy(320,0,Paramstr(1));
  setcolor(1);
  moveto(0,240);
 end
else
 begin
 {оформление табличного файла}
  Assign(F, 'RESULT.TBL');
  Rewrite(F);
  clrscr;
  write('   T   |');
  write(F,'   T   |');
    for i:=1 to SUR_N do
     begin
      write(' UR[',UR_N[i],'] |');
      write(F,' UR[',UR_N[i],'] |');
     end;
    for i:=1 to SUH_N do
     begin
      write(' UH[',UH_N[i],'] |');
      write(F,' UH[',UH_N[i],'] |');
     end;
      writeln;
      writeln(F);
    for i:=1 to SUH_N+SUR_N+1 do
      begin
       write('--------');
       write(F,'--------');
      end;
      writeln;
      writeln(F);
 end;
 
  TT:=0;TP:=0;
  KSH:=0;KL:=0;
  T0:=TK/4;
  T1:=1.1*T0;
  T2:=T1*2;
  T3:=T2+T0/10;
  if (Peredat=1) or (Impulse=1) then UR[InputU]:=Level0;
  if IC=1 then UR[InputU]:=-UR[InputU];
 
 repeat
   for i:=1 to CH do
     begin
       UH[i]:=0;
       for j:=1 to CRB do UH[i]:=UH[i]-UR[j]*M[i,j];
    TH[i]:=UH[i]/R[i];
     end;
 for j:=1 to CRB-CE do
     begin
       TC[j]:=0;
       for i:=1 to CH do TC[j]:=TC[j]+TH[i]*M[i,j+CE];
     end;
 
     i:=1;
     while i<=CT*2 do
       begin
     j:=i;
     TD[i]:=TTE*(exp(UR[i+CE]/MFTE)-1); { UR[i+CE] ==> UC[i] }
     C[i]:=CBEO+TAU*(TD[i]+TTE)/MFTE;
     i:=i+1;
     TD[i]:=TTK*(exp(UR[i+CE]/MFTK)-1); { UR[i+CE] ==> UC[i] }
     C[i]:=CBKO+TAUU*(TD[i]+TTK)/MFTK;
     TC[j]:=TC[j]-((B+1)*TD[j]-Bu*TD[i]+UR[j+CE]/RUE);{ UR[j+CE] ==> UC[j] }
     TC[i]:=TC[i]-((Bu+1)*TD[i]-B*TD[j]+UR[i+CE]/RUK);{ UR[i+CE] ==> UC[i] }
     i:=i+1;
       end;
 
     while i<=CT+CD do
       begin
     TD[i]:=TTD*(exp(UR[i+CE]/MFTD)-1);{ UR[i+CE] ==> UC[i] }
     C[i]:=CBDO+TAUD*(TD[i]+TTD)/MFTD;
     TC[i]:=TC[i]-(TD[i]+UR[i+CE]/RUD);{ UR[i+CE] ==> UC[i] }
     i:=i+1;
       end;
 
   for i:=1 to CC do
     if C[i] <> 0 then DUC[i]:=TC[i]/C[i];

MDU:=0;
   for i:=1 to CC do
     if MDU<abs(DUC[i]) then MDU:=abs(DUC[i]);
   case Method=1 of
 
   true:  H:=M1/(M2+MDU); {старый метод с постоянными шагами}
 
   false:  {новый метод с шагами переменной величины}
   if KL<>0 then
     begin
       while i<=CC do
         begin
           if ((DUC[i]>=0) and (RDU[i]>=0)) or ((DUC[i]<0) and (RDU[i]<0)) then
          begin
            i:=i+1;
            if i>CC then
               begin
             KL:=1;
             H:=M1/(M2+MDU)
               end;
          end
         else
           begin
             H:=M1/(2*M2+MDU+RMDU);
             i:=1;while i<=CC do
               begin
             S:=(DUC[i]*RDU[i])/(RDU[i]+DUC[i]);
             i:=i+1;
               end;
             KL:=0;
           end;
         end;
     end
   else
      begin
    KL:=1;
    H:=M1/(M2+MDU)
      end;
   end;{of case to Method selection}
 
   for i:=1 to CC do
     UR[i+CE]:=UR[i+CE]+H*DUC[i];{ UR[i+CE] ==> UC[i] }
 
   RMDU:=MDU;
   TT:=TT+H;
   LUp:=Level1/KFrontF;    {проекция переднего фронта}
   LDown:=Level1/KBackF;   {проекция  заднего  фронта}
{   UR[inputU]:=sin(TT);}
   if Impulse=1 then
   begin
     {формирование импульса}
     if TT>TSAD then UR[InputU]:=( (TT-TSAD)*KFrontF+Level0);{передний фронт}
     if (TT>=TSAD+LUp) and (TT<TSad+LUp+TImp){верхний уровень}
     or (UR[InputU]>Level1) then UR[InputU]:=Level1;
 
     if (TT>=TSAD+TImp+LUp)
     then UR[InputU]:=KBackF*(-TT+TSAD+TIMP+Level0+LUp+LDown);
     {задний фронт}
 
     if (TT>(TImp+TSad+LUp+LDown)) or (abs(UR[InputU])<Level0)
     then UR[InputU]:=Level0;  {нулевой уровень}
 
     if TT>TSAD then if IC=1 then UR[InputU]:=-UR[InputU];
 
   end;
 
   KSH:=KSH+1;
 
   if TT>=TP then
     if GRPH then begin
           {writeln('T=',TT,'  H=',H,' U[C2]=',UR[5]);}
            j:=9;
 
if {(UR[InputU]<1.5*Level1) and} (Peredat=1) and (TT>TSAD-5) then
begin
putpixel(round(320+abs(UR[InputU]*KInU)),420-abs(round(abs(UR[OutputU])*KOutU)),13);
{30 - шаг по оси U, 30 - по оси Т}
end;
 
            for i:=1 to SUR_N do
             begin
              putpixel(round(20+TT*KT),240-round(UR[UR_N[i]]*KU),j);
              j:=j+1;
             end;
            for i:=1 to SUH_N do
             begin
              putpixel(round(20+TT*KT),240-round(UH[UH_N[i]]*KU),j);
              j:=j+1;
             end;
            TP:=TP+H;
          end
         else begin
           write(' ',TT:3:3,' | ');
           write(F,' ',TT:3:3,' | ');
            for i:=1 to SUR_N do
             begin
              write(UR[UR_N[i]]:1:3,' | ');
              write(F,UR[UR_N[i]]:1:3,' | ');
             end;
            for i:=1 to SUH_N do
             begin
              write(UH[UH_N[i]]:1:3,' | ');
              write(F,UH[UH_N[i]]:1:3,' | ');
             end;
           writeln;
           writeln(F);
            TP:=TP+HP;
         end;
 until (TT>=TK) or (TT*KT>=639) or keypressed;
  if not GRPH then
end;
{=========P R O G R AM=========}
BEGIN
 
 READDATA;
 CorrectTree;
 TR2Polusnik(U1,U2,CU,CV);{ changes CU }
 ChooseNormalTree({input}CU,CV,U1,U2,{output}CRB,CH,P);
 CreateM(CRB,CH);
 Solution;
 
END.