[Admiral]

Drongo, это было бы логично, как бы "строили-строили и наконец построили", а ведь здесь до сих пор...

[Drongo]

Admiral, Да я думаю, и здесь будет продолжение из той же оперы, вряд ли человек появится до следующего задания, а потом эту тему благополучно забудут... Тем более даже за раннии решения "Спасибо" нету и вряд ли будет вообще.

[Admiral]

Drongo, тема уже красно популярна (700 просмотров на текущий момент), а та всего лишь жёлто стандартная (пока 472 просмотра), так что я думаю что математическое название привлекает к себе внимание, чего не скажешь про не популярный Ассемблер.
Дело не столько в Спасибо, а сколько в авторитете самого раздела Программирование, поскольку такие темы без решения конечного результата от самого автора, после того как он сказал что всё ОК, не очень то смотрятся и бросают тень на раздел.

[D.Y.]

Код:

#include "conio.h"
#include <iostream>
#include "math.h"
#include "stdlib.h"
using namespace::std;



void main()
{
	int i,j;
	double С[3][3],В[3][1];
	
	double det,det1,det2,det3,x1,x2,x3;
	
	char z='y'; 
	
cout<<"Vvedite koefisienti pri neizvestnih x1,x2,x3 v 1-om,2-om,3-em yravneniax"<<endl;
	for(i=0;i<3;i++)//vvod matrici koeficientov pri neizvesnix
		for(j=0;j<3;j++)
			cin>>С[i][j]; 
	
	cout<<"\n"<<endl;  
	cout<<"Vvedite cvobodnii chleni v 1-om,2-om,3-em yravneniax"<<endl;
	for (i=0;i<3;i++)// Vvod stolbca svobodnix chlenov
	cin>>В[i][0];



	
	
	
	cout<<"Nahogdenie opredelitelei"<<endl;
    
	
	det=C[0][0]*C[1][1]*C[2][2]+C[1][0]*C[2][1]*C[0][2]+C[0][1]*C[1][2]*C[2][0]-C[0][2]*C[1][1]*C[2][0]-C[1][0]*C[0][1]*C[2][2]-C[0][0]*C[2][1]*C[1][2];
	cout<<"opredelitel="<<det<<endl;//vichislenie opredelitela 
	
	det1=D[0][0]*C[1][1]*C[2][2]+D[1][0]*C[2][1]*C[0][2]+C[0][1]*C[1][2]*D[2][0]-C[0][2]*C[1][1]*D[2][0]-D[1][0]*C[0][1]*C[2][2]-D[0][0]*C[2][1]*C[1][2];
	cout<<"opredelitel1="<<det1<<endl;//vichislenie opredelitela1
	
	det2=C[0][0]*D[1][0]*C[2][2]+C[1][0]*D[2][0]*C[0][2]+D[0][0]*C[1][2]*C[2][0]-C[0][2]*D[1][0]*C[2][0]-C[1][0]*D[0][0]*C[2][2]-C[0][0]*D[2][0]*C[1][2];
	cout<<"opredelitel2="<<det2<<endl;//vichislenie opredelitela2
	
	det3=C[0][0]*C[1][1]*D[2][0]+C[1][0]*C[2][1]*D[0][0]+C[0][1]*D[1][0]*C[2][0]-D[0][0]*C[1][1]*C[2][0]-C[1][0]*C[0][1]*D[2][0]-C[0][0]*C[2][1]*D[1][0];
	cout<<"opredelitel3="<<det3<<endl;//vichislenie opredelitela3
	cout<<"\n"<<endl;
	
	
	
			
	if(det!=0)	
    {x1=det1/det;//vichislenie  x1
	x2=det2/det;//vichislenie  x2
	x3=det3/det;//vichislenie  x3
	cout<<"x1="<<x1<<endl;
	cout<<"x2="<<x2<<endl;
	cout<<"x3="<<x3<<endl;} 

	
	 else
		 cout<<"Sistema ne imeet reshenii, tak kak opredelitel=0"<<endl;

	getch() ; 
}
это для матриц 3*3 и меньше по уравнениям крамера

[D.Y.]

Код:

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <math.h>
#include "matr_in_gause.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
//Нахождение обратной матрицы методом Гаусса
//Входные данные: double *a - исходная матрица;
//                int n     - размерность матрицы[n*n];
//    Sring name_file_save  - имя файла для записи результатов счета.
//Выходные данные: double *a - обратная матрица, вычисленная по методу Гаусса, [n*n].
int matr_inv_gause(double *a, int n)
{
  double e1, d, *b, *c, y, w, p; ;
  int i, j, k, *z;

  e1=1.e-6;
  d=1;

  z= new int[n];
  c= new double[n];
  b= new double[n];


  for(i=0; i<n; i++)
     *(z+i)=i;

  for(i=0; i<n; i++)
   {
    k=i;
    y=*(a+i*n+i);
    if(i+1 <= n )
      for(j=1+i; j<n; j++)
       {
        w=*(a+n*i+j);
        if(fabs(w)>fabs(y))
         {
           k=j;
           y=w;
         }
       }
    d=d*y;
//проверка на близость к вырождению матрицы  
   if(fabs(y)<e1) return 2;
   y=1./y;
   for(j=0; j<n; j++)
    {
      *(c+j)=*(a+n*j+k);
      *(a+n*j+k)=*(a+n*j+i);
      *(a+j*n+i)=-(*(c+j))*y;
      *(b+j)=*(a+i*n+j)*y;
      *(a+i*n+j)=*(b+j);
    }
   j=*(z+i);
   *(z+i)=*(z+k);
   *(z+k)=j;
   *(a+i*n+i)=y;

   for(k=0; k<n; k++)
    if(k != i)
      for(j=0; j<n; j++)
        if(j != i)
         *(a+k*n+j)=*(a+k*n+j)-(*(b+j))*(*(c+k));
   }
  for(i=0; i<n; i++)
    while(1)
    {
      k=*(z+i);
      if(k == i) break;
       for(j=0; j<n; j++)
        {
         w=*(a+i*n+j);
         *(a+i*n+j)=*(a+k*n+j);
         *(a+k*n+j)=w;
        }
      p=*(z+i);
      *(z+i)=*(z+k);
      *(z+k)=p;
      d=-d;
    }

 delete[] z;
 delete[] b;

 delete[] c;

 return 0;
}
 а вот по гауссу но здесь я еще использовал собственные директивы и прога писалась не консольная если немного переделать то можно сделать консольную кому нужна полностью пишите могу прислать ехешник а самому переделывать не охота каникулы ведь

[Admiral]

D.Y., другое дело

[Drongo]

D.Y.,

[Drongo]

D.Y., Ещё один маленький нюанс, а где содержимое заголовочного файла matr_in_gause.h его тоже нужно, бо непонятно много.

[D.Y.]

Код:

#ifndef matr_in_gauseH
#define matr_in_gauseH
//---------------------------------------------------------------------------
#endif

Вот но врядли он поможет
Вот как выглядит главная программа
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <string.h>
#include <Sysutils.hpp>
#include "main_matr_gause.h"
#include "matr_in_gause.h"
#include <stdio.h>
#include "form_help.h"
#include "form_rez.h"
#include "form_save_rez.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CSPIN"
#pragma resource "*.dfm"

#define N 5
double mas3[N][N];
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{

}
//---------------------------------------------------------------------------
void __fastcall TForm1::N1Click(TObject *Sender)
{
 //Проверка на наличие элементов в матрице
 //Если элементов нет , ф-я завершает работу
  int i, j, w, v;
  double mas1[N][N],mas2[N][N];
  TForm3* ID3 = new TForm3(this);
//задание положения Form3 на экране
  ID3->Left=179;
  ID3->Top=113;
  ID3->Height=180;
  ID3->Width=356;

//формирование входной матрицы a[n*n]
 a=new double[StringGrid1->ColCount*StringGrid1->ColCount];
 for(i=0; i < StringGrid1->ColCount; i++)
   for(j=0; j< StringGrid1->RowCount; j++)
     {
      if(StringGrid1->Cells[j][i]!="")
                *(a+i*StringGrid1->RowCount+j)=StrToFloat(StringGrid1->Cells[j][i]);
            else *(a+i*StringGrid1->RowCount+j)=0;
            //Если не ввести элемент, то ему присваивается 0

      mas1[i][j]=*(a+i*StringGrid1->RowCount+j);
     }

//вычисление обратнй матрицы методом Гаусса
 pr= matr_inv_gause(a,StringGrid1->RowCount);

//отображение результатов вычисления обратной матрицы
if(pr==0)
 {
   for(i=0; i < StringGrid2->ColCount; i++)
     for(j=0; j< StringGrid2->RowCount; j++)
       {
         StringGrid2->Cells[i][j]=FloatToStrF(*(a+j*StringGrid2->RowCount+i),ffFixed,10,4);
         mas2[i][j]=*(a+i*StringGrid2->RowCount+j);
       }
//нахождение матрицы умножения исходной на обратную.
        for(v=0; v < StringGrid3->ColCount; v++)
           {
        for(w=0; w< StringGrid3->RowCount; w++)
           {
            mas3[v][w]=0;
         for(i=0; i < StringGrid1->ColCount; i++)
          {
            mas3[v][w]=mas3[v][w]+mas1[v][i]*mas2[i][w];
          }
            StringGrid3->Cells[v][w]=FloatToStrF(mas3[v][w],ffFixed,10,4);
              StringGrid3->Cells[i][j]="";
             }

             }

  }
//анализ корректности вычисления обратной матрицы
 if(pr==2)
     {
       for(i=0; i < StringGrid2->ColCount; i++)
         for(j=0; j< StringGrid2->RowCount; j++)
           {
             StringGrid2->Cells[i][j]="";
             StringGrid3->Cells[i][j]="";
           }
       ID3->ShowModal();
     }
 ID3->Free();



//

//



}
//---------------------------------------------------------------------------
void __fastcall TForm1::CSpinEdit1Change(TObject *Sender)
{
int i;

 if (CSpinEdit1->Value > 5 ) return;

//pедактированиe таблицы
 StringGrid1->EditorMode=true;

//задание размерности входной матрицы
 StringGrid1->ColCount=CSpinEdit1->Value;
 StringGrid1->RowCount=CSpinEdit1->Value;

//редактированиe таблицы
 StringGrid2->EditorMode=false;

//задание размерности выходной матрицы
 StringGrid2->ColCount=CSpinEdit1->Value;
 StringGrid2->RowCount=CSpinEdit1->Value;




 StringGrid3->EditorMode=false;
 
//задача выходной матрицы умножения обратной на исходную
 StringGrid3->ColCount=CSpinEdit1->Value;
 StringGrid3->RowCount=CSpinEdit1->Value;



//очистка ячеек таблицы
 for(int i = 0; i < StringGrid1->ColCount; i++)
   for(int j = 0; j < StringGrid1->ColCount; j++)
     StringGrid2->Cells[i][j] ="";





 for(int i = 0; i < StringGrid1->ColCount; i++)
   for(int j = 0; j < StringGrid1->ColCount; j++)
     StringGrid3->Cells[i][j] ="";



     for(int v = 0; v < StringGrid3->ColCount; v++)
   for(int w= 0; w < StringGrid3->ColCount; w++)
     StringGrid3->Cells[v][w] ="";



//очистка ячеек таблицы
 for(int i = 0; i < StringGrid2->ColCount; i++)
   for(int j = 0; j < StringGrid2->ColCount; j++)
     StringGrid2->Cells[i][j] ="";
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
{
  delete[] a;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{ float
 x=450,y=750;

//задание положения MainForm (Form1) на экране
Form1->Left=23;
Form1->Top=83;
Form1->Height=x;
Form1->Width=y;

}

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


void __fastcall TForm1::N6Click(TObject *Sender)
{
   TForm2* ID2 = new TForm2(this);
//задание положения Form2 на экране
  ID2->Left=56;
  ID2->Top=118;
  ID2->Height=264;
  ID2->Width=290;
//отображение Form2 на экране
  ID2->ShowModal();

  ID2->Free();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::N2Click(TObject *Sender)
{
  FILE *h;

 String name_file_save;
 int i, j;

 TForm4* ID4 = new TForm4(this);
//задание положения Form4 на экране
  ID4->Left=189;
  ID4->Top=112;
  ID4->Height=159;
  ID4->Width=364;

//выбор имени файла для записи результатов счета
 SaveDialog1->Title="Введите или выберите имя файла для записи результатов счета";
 SaveDialog1->Filter= "Text. files (*.txt)|*.txt";

 if(SaveDialog1->Execute())
   {
     name_file_save = SaveDialog1->FileName;
   }

//открытие файла для записи результатов счета
  if ((h = fopen(name_file_save.c_str(),"w"))
       == NULL)
   {
      fprintf(stderr, "Cannot open input file.\n");
      return ;
   }

 if(pr == 0)
  {
   fprintf(h,"Обратная матрица, вычисленная методом Гаусса\n");
//запись в файл обратной матрицы
   for(i=0; i<StringGrid1->RowCount; i++)
    {
      for(j=0; j<StringGrid1->RowCount; j++)
       fprintf(h,"%20.12g",*(a+i*StringGrid1->RowCount+j));
       fprintf(h,"\n");
    }
  }
  if(pr==2)
    fprintf(h,"Матрица близка к вырождению.\n");

//закрытие файла для записи результатов счета
 fclose(h);

 ID4->ShowModal();

 ID4->Free();

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

void __fastcall TForm1::N4Click(TObject *Sender)
{
Application->Terminate();
}
//---------------------------------------------------------------------------

[Drongo]

D.Y., Не, дружище, не то, у этого файла расширение .ccp, a надо .h

Код:

#include "main_matr_gause.h   // Вот этот"
#include "matr_in_gause.h"   // И вот этот