Метод Гаусса

[TMTGamer]

Помогите!!! "Type name expected"

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit11.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm11 *Form11;
//---------------------------------------------------------------------------
__fastcall TForm11::TForm11(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm11::Button1Click(TObject *Sender)
{ int n,col,row,i;
n=StrToInt(Edit1->Text);
tab1->ColCount=n+2;
tab1->RowCount=n+1;
row=0;
for (col=1; col < n+1; col++)
{
 tab1->Cells[col][row]="K(x"+IntToStr(col)+")";
 }
 tab1->Cells[n+1][0]="В.член";
 col=0;
 for (row=1; row < n+1; row++)
 {
  tab1->Cells[col][row]=Char(row+64);
 }
 tab2->ColCount=2;
 tab2->RowCount=n+1;
  for (row=0; row < n; row++)
  {
   tab2->Cells[col][row+1]="X("+IntToStr(row+1)+")";
  }
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

 void Perest(int k,n,a,b)//; a:Tmatrix; b:Tmass)
 {  a:Tatrix;
	b:Tmass;
	int j,i; double z;

	 z:=a[k,k];i:=k;
   //for j:=k+1 to n-1 do
   for (j = k+1; i < n-1; j++)
   {
	 if (abs(a[j][k])>z)
	 {
	 z=a[j][k];
	 i==j;
   }
   }
	 if (i>k)
	 //for j:=k to n-1 do
	 for (j = k; j < n-1; j++)
	 {
	   z=a[i][j]; a[i][j]=a[k][j]; a[k][j]=z;
	 }
	 z=b[i];b[i]=b[k];b[k]=z;
 }

 void PrHod(int n,a,b)//; a:Tmatrix; b:Tmass)
 {
 a:Tatrix;
 b:Tmass;
int k,j,i; double r;
for (k = 0; k < n-1; k++)
{
  if (a[k][k]=0) {Perest(k,n,a,b);}//перестановка строк
  for (j = k+1; j < n-1; j++)
  {
	r=a[j][k]/a[k][k];
	  for (i = k; i < n-1; i++)
	  {
		a[j,i]:=a[j,i]-r*a[k,i];
	  }
	b[j]=b[j]-r*b[k];
  }
}
}

void ObrChod(int n,a,b,x)//; a:Tmatrix; b:Tmass; x:Tmass);
{ a:Tatrix;
  b:Tmass;
  int k,j; double r,g;
  for (k = n-1; k < 0; k--)
  {
	r=0;
	for j:=k+1 to n-1 do
	for (j = k+1; j < n-1; j++)
	{
		g=a[k][j]*x[j];
		r=r+g;
	}
	x[k]=(b[k]-r)/a[k][k];
  }
}
void __fastcall TForm11::Button2Click(TObject *Sender)
{
	a:Tmatrix;
	x,b:Tmass;
	int n,k,j,row;
  n=StrToInt(Edit1->Text);
  SetLength(a,n,n);
  SetLength(b,n);
  SetLength(x,n);
  for (k=0; k < n-1; k++)
  for (j = 0; j < n-1; j++)
  {
	a[k][j]=StrToFloat(Tab1.Cells[j+1][k+1]);
	b[k]=StrToFloat(Tab1.Cells[n+1][k+1]);
  }

PrHod(n,a,b);
if ((a[n-1,n-1]==0)&&(b[n-1]==0))
{
ShowMessage("Система невизначена"); return;
}
if ((a[n-1,n-1]==0)&&(b[n-1]!=0))
{
ShowMessage("Система немає розв'язків"); return;
}

ObrChod(n,a,b,x);
  for row:=0 to n-1 do
  for (row = 0; row < n-1; row++)
  {
	 tab2.Cells[1][row]=FloatToStr(F(x[row],ffFixed,5,3));
  }

}


//---------------------------------------------------------------------------

[p51x]

не хватает закрывающей скобки

[TMTGamer]

Сообщение от p51x

не хватает закрывающей скобки

?? Где?

[TMTGamer]

Сделал, вот код - если нужно...

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <Math.h>;
#include <Math.hpp>;
#include "Unit11.h"
#define N 50
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm11 *Form11;
//---------------------------------------------------------------------------
__fastcall TForm11::TForm11(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm11::Button1Click(TObject *Sender)
{ int n,col,row,i;
n=StrToInt(Edit1->Text);
tab1->ColCount=n+2;
tab1->RowCount=n+1;
row=0;
for (col=1; col < n+1; col++)
{
 tab1->Cells[col][row]="K(x"+IntToStr(col)+")";
 }
 tab1->Cells[n+1][0]="В.член";
 col=0;
 for (row=1; row < n+1; row++)
 {
  tab1->Cells[col][row]=Char(row+64);
 }
 tab2->ColCount=2;
 tab2->RowCount=n+1;
  for (row=0; row < n; row++)
  {
   tab2->Cells[col][row+1]="X("+IntToStr(row+1)+")";
  }

}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------


 void glavelem( int k,int n, double mas[] [N + 1], int otv[]);
void __fastcall TForm11::Button2Click(TObject *Sender)
{
double mas[N][N + 1];
double x[N];
int otv[N];
int i, j, k,n,row;
  n=StrToInt(Edit1->Text);
  for (i = 1; i <= n; i++)
  for (j = 1; j <= n+1; j++)
  mas[i-1][j-1]=StrToFloat(tab1->Cells[j][i]);
for ( i = 0; i < n + 1; i++ )
otv[i] = i;
for ( k = 0; k < n; k++ )
{
glavelem( k,n, mas, otv );
if ( fabs( mas[k] [k] ) < 0.0001 )
{
ShowMessage("det=0");
return;
}
for ( j = n; j >= k; j-- )
mas[k] [j] /= mas[k] [k];
for ( i = k + 1; i < n; i++ )
for ( j = n; j >= k; j-- )
mas[i] [j] -= mas[k] [j] * mas[i] [k];
}
for ( i = 0; i < n; i++ )
x[i] = mas[i] [n];
for ( i = n - 2; i >= 0; i-- )
for ( j = i + 1; j < n; j++ )
x[i] -= x[j] * mas[i] [j];
for (i=0;i<=N-1;i++)
{
tab2->Cells[1][i+1]=FloatToStr(RoundTo(x[i],-4));
}
}
 void glavelem( int k,int n, double mas[] [N + 1], int otv[] )
{
int i, j, i_max = k, j_max = k;
double temp;
for ( i = k; i < n; i++ )
for ( j = k; j < n; j++ )
if ( fabs( mas[i_max] [j_max] ) < fabs( mas[i] [j] ) )
{
i_max = i;
j_max = j;
}
for ( j = k; j < n + 1; j++ )
{
temp = mas[k] [j];
mas[k] [j] = mas[i_max] [j];
mas[i_max] [j] = temp;
}
for ( i = 0; i < n; i++ )
{
temp = mas[i] [k];
mas[i] [k] = mas[i] [j_max];
mas[i] [j_max] = temp;
}
i = otv[k];
otv[k] = otv[j_max];
otv[j_max] = i;
}
//---------------------------------------------------------------------------

[8Observer8]

Попался код метода Гаусса на си. Взял отсюда: ссылка

#include <stdio.h>  // Описания функций ввода-вывода
#include <math.h>   // Описания математических функций
#include <stdlib.h> // Описания функций malloc и free
#include <locale.h>

// Прототип функции приведения матрицы
// к ступенчатому виду.
// Функция возвращает ранг матрицы
int gaussMethod(
    int m,          // Число строк матрицы
    int n,          // Число столбцов матрицы
    double *a,      // Адрес массива элементов матрицы
    double eps      // Точность вычислений
);

int main() {
    int m, n, i, j, rank;
    double *a;
    double eps, det;

    setlocale(LC_ALL, "Russian");

    printf("Введите размеры матрицы m, n: ");
    scanf("%d%d", &m, &n);

    // Захватываем память под элементы матрицы
    a = (double *) malloc(m * n * sizeof(double));

    printf("Введите элементы матрицы:\n");
    for (i = 0; i < m; ++i) {
        for (j = 0; j < n; ++j) {
            // Вводим элемент с индексами i, j
            scanf("%lf", &(a[i*n + j]));
        }
    }

    printf("Введите точность вычислений eps: ");
    scanf("%lf", &eps);

    // Вызываем метод Гаусса
    rank = gaussMethod(m, n, a, eps);

    // Печатаем ступенчатую матрицу
    printf("Ступенчатый вид матрицы:\n");
    for (i = 0; i < m; ++i) {
        // Печатаем i-ю строку матрицы
        for (j = 0; j < n; ++j) {
            printf(         // Формат %10.3lf означает 10
                "%10.3lf ", // позиций на печать числа,
                a[i*n + j]  // 3 знака после точки
            );
        }
        printf("\n");   // Перевести строку
    }

    // Печатаем ранг матрицы
    printf("Ранг матрицы = %d\n", rank);

    if (m == n) {
        // Для квадратной матрицы вычисляем и печатаем
        //     ее определитель
        det = 1.0;
        for (i = 0; i < m; ++i) {
            det *= a[i*n + i];
        }
        printf("Определитель матрицы = %.3lf\n", det);
    }

    free(a);    // Освобождаем память
    return 0;   // Успешное завершение программы
}

// Приведение вещественной матрицы
// к ступенчатому виду методом Гаусса с выбором
// максимального разрешающего элемента в столбце.
// Функция возвращает ранг матрицы
int gaussMethod(
    int m,          // Число строк матрицы
    int n,          // Число столбцов матрицы
    double *a,      // Адрес массива элементов матрицы
    double eps      // Точность вычислений
) {
    int i, j, k, l;
    double r;

    i = 0; j = 0;
    while (i < m && j < n) {
        // Инвариант: минор матрицы в столбцах 0..j-1
        //   уже приведен к ступенчатому виду, и строка
        //   с индексом i-1 содержит ненулевой эл-т
        //   в столбце с номером, меньшим чем j

        // Ищем максимальный элемент в j-м столбце,
        // начиная с i-й строки
        r = 0.0;
        for (k = i; k < m; ++k) {
            if (fabs(a[k*n + j]) > r) {
                l = k;      // Запомним номер строки
                r = fabs(a[k*n + j]); // и макс. эл-т
            }
        }
        if (r <= eps) {
            // Все элементы j-го столбца по абсолютной
            // величине не превосходят eps.
            // Обнулим столбец, начиная с i-й строки
            for (k = i; k < m; ++k) {
                a[k*n + j] = 0.0;
            }
            ++j;      // Увеличим индекс столбца
            continue; // Переходим к следующей итерации
        }

        if (l != i) {
            // Меняем местами i-ю и l-ю строки
            for (k = j; k < n; ++k) {
                r = a[i*n + k];
                a[i*n + k] = a[l*n + k];
                a[l*n + k] = (-r); // Меняем знак строки
            }
        }

        // Утверждение: fabs(a[i*n + k]) > eps

        // Обнуляем j-й столбец, начиная со строки i+1,
        // применяя элем. преобразования второго рода
        for (k = i+1; k < m; ++k) {
            r = (-a[k*n + j] / a[i*n + j]);

            // К k-й строке прибавляем i-ю, умноженную на r
            a[k*n + j] = 0.0;
            for (l = j+1; l < n; ++l) {
                a[k*n + l] += r * a[i*n + l];
            }
        }

        ++i; ++j;   // Переходим к следующему минору
    }

    return i; // Возвращаем число ненулевых строк
}