procedure MethodOfSteepestGradientDescent(U:Uravnenia; var O:Otvet; KU:integer; NeedAccuracy:real);
type VectorNevazok=array[1..10] of real; //локальный тип данных для вектора невязок
    var i,j,k:integer;
        R:VectorNevazok;
        ResultMulVectorToMatrix:VectorNevazok;
        numerator:real;
        denominator:real;
        Alpha:real;
//локальная функция для подсчета невязок на k-ом шаге
function Discrepancies(Ur:Uravnenia; AnswerToStep:Otvet; NumberOfEquations:integer):VectorNevazok;
    var iL,jL:integer;
        NowDiscrepancies:real;
begin
for iL:=1 to NumberOfEquations do begin
     NowDiscrepancies:=0;
     for jL:=1 to NumberOfEquations do
         NowDiscrepancies:=NowDiscrepancies + Ur[iL,jL]*AnswerToStep[1, jL]; //r=a[i,1]*x1 + a[i,2]*x2 + ... + a[i,NumberOfEquations]
     NowDiscrepancies:=NowDiscrepancies - Ur[iL, NumberOfEquations + 1];//r=(левая часть уравнения) - (правая часть уравнения)
     Discrepancies[iL]:=NowDiscrepancies;
   end;
end;
//==============================================

//локальная процедура для сравнения вектора невязок с допустимой невязкой
  function CanProcedureStop(Nevaz:VectorNevazok; HowManyEquations:integer; NeedTochnost:real):boolean;
      var iC:integer;
          LocalBool:boolean;
  begin
  LocalBool:=true;
  iC:=1;
  while(iC<=HowManyEquations)and(LocalBool=true) do begin
      if(abs(Nevaz[iC])>NeedTochnost) then
         LocalBool:=false;
      inc(iC);
    end;
  CanProcedureStop:=LocalBool;
  end;
  //=============================================

//локальная функция для умножения вектора Vec на матрицу Mat1
function MulVectorToMatrix(Vec:VectorNevazok; Mat1:Uravnenia; m:integer):VectorNevazok;
    var iM,jN,kM:integer;
        rMul:real;
begin
for iM:=1 to m do
   for jN:=1 to m do begin
      rMul:=0;
      for kM:=1 to m do
        rMul:=rMul + Mat1[kM, iM]*Vec[kM];
      MulVectorToMatrix[iM]:=rMul;
    end;
end;
//==================================================

//----локальная функция для умножения вектора-строки на вектор-столбец с размерностями w
function MulVectorLineToVectorColumn(VectorLine:VectorNevazok; VectorColumn:VectorNevazok; w:integer):real;[/b]
    var kMV:integer;
        rMV:real;
begin
rMV:=0;
for kMV:=1 to w do
     rMV:=rMV + VectorLine[kMV]*VectorColumn[kMV];
MulVectorLineToVectorColumn:=rMV;
end;
// ================================================================================
============

//сама процедура для уточнения корней системы уравнений
procedure NewRoot(QuantityUrav:integer; alpha:real; Nevaz:VectorNevazok; var Roots:Otvet);
      var iNR, jNR:integer;
  begin
  for iNR:=1 to QuantityUrav do
      Roots[1, iNR]:=Roots[1, iNR] - alpha*Nevaz[iNR];
end;
//==========================================================

begin
//Основная формула метода наискорейшего градиентного спуска:
//x[k+1]=x[k] - Alpha[k]*gradF(x[k]) = x[k] - Alpha[k]*(b - A*x[k]) = x[k] + Alpha[k]*(A*x[k] - b)
//в которой Alpha[k] ищется как:
//Alpha[k]=(((A*x[k] - b)T) * (A*x[k] - b))/((A*x[k] - b)T) * A * (Ax[k] - b))
repeat
  R:=Discrepancies(U, O, KU);
  numerator:=MulVectorLineToVectorColumn(R, R, KU); //т.к. вектор R имеет KU строк и один столбец(он является одномерным массивом), то транспонировать его не надо
  ResultMulVectorToMatrix:=MulVectorToMatrix(R, U, KU);
    denominator:=MulVectorLineToVectorColumn(ResultMulVectorToMatrix, R, KU);
  Alpha:=numerator/denominator;
  NewRoot(KU, Alpha, R, O);
until CanProcedureStop(R, KU, NeedAccuracy)



end;