[c++] Metoda Gauss'a - rozwiązanie równania trójkątnego

[Soulburner 2]

Witam!

 

Jest sobie taki kodzik:

 

#include <cstdlib>
#include <iostream>
#include <math.h>
#include <iomanip>
#include <fstream>
#include <cmath>

using namespace std;


int gauss(int r, double t[100][101], double x[100])
{			  
  for(int i=1;i<r;i++)		 //eliminacja zmiennych
  {
 for(int k=i;k<r;k++)
 {							   
   for(int j=i;j<r+1;j++)		   
	  {	
		t[k][j]=t[k][j]-(t[i-1][j]*(t[k][i-1]/t[i-1][i-1]));
	  }
   t[k][i-1]=0;
 }						
  }

//wypisanie ukladu po eliminacji			   
  for(int i=0;i<r;i++)
  {
 for(int j=0;j<r;j++)
 {
	cout << t[i][j] << " ";		
 }		
 cout << t[i][r] << endl;
  }
  cout << "--------------------------" << endl;

  //rozwiązanie równ. trójkątnego tu winno się znaleźć...
  return 1;
}

//------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
int n;
double x[100];
double tab[100][101];

//wyzerowanie tablicy na wszelki wypadek, bo podczas eksperymentow pokazywaly sie wyniki z kosmosu, dajac nadzieje na to, ze cos sie liczy;)
for (int i=0; i<=100; i++)
	x[i]=0;

ifstream wejscie("gauss_in.txt");
wejscie >> n;
for(int i = 0; i < n; i++)
{
  for(int j = 0; j <= n; j++) 
  {	  
	wejscie >> tab[i][j];
  }
}

cout << "Wczytana macierz:" << endl;
for(int i=0;i<n;i++)
{
  for(int j=0;j<n;j++)
  {
		  cout << tab[i][j] << "  ";
  }
  cout << " = " << tab[i][n] <<"  ";
  cout << endl;
}
cout << "--------------------------------" << endl;


gauss(n,tab,x)
  cout <<"Rozwiazanie trojkatnego rownania:\n";
//tu sie powinno znalezc, ino trzeba pierw iksy skads wziac :/	 
system("PAUSE");
return EXIT_SUCCESS;
}

 

Wszystko pięknie, tylko jak napisać funkcję rozwiązującą równanie trójkątne? Głowa mi już pęka (z bólem zatok nie ma żartów ) i proszę o pomoc Was. W jaki sposób zapisać wzór? Jak wygląda w ogóle ten wzór?

 

Z góry dzięki za wszelkie porady.

[EF 0]

Zakladam, ze chodzi o eliminacje gaussa.

Ogolnie chodzi o przeksztalcenie macierzy [A] w macierz trojkatna, czyli:

 

| x1 y1 z1 t1 |

| x2 y2 z2 t2 | =>

| x3 y3 z3 t3 |

| x4 y4 z4 t4 |

 

| 1 y1 z1 t1 |

| 0 1 z2 t2 |

| 0 0 1 t3 |

| 0 0 0 1 |

 

I pozniej podstawiasz sobie kolejno wiadome pod niewiadome.

Macierz w takiej postaci uzyskuje sie wlasnie dzieki metodzie eliminacji gaussa.

Na angielskiej wiki dot. metody gaussa mozesz znalesc tez przykladowa implementacje tego algorytmu w pseudokodzie.

[209458 867]

I pozniej podstawiasz sobie kolejno wiadome pod niewiadome.

 

A numerycznie wygląda to w ten sposób, że odejmujesz od wszystkich wierszy najpierw ostatni (oczywiście przeskalowany) - wtedy na ostatniej kolumnie wskoczą zera. Potem przedostatni itd aż do osiągnięcia macierzy diagonalnej

 

A BTW - wydaje mi się (nie czytałem kodu dokładnie), że nie przekształcasz sobie ostatniej kolumny ("prawej strony") ani nie zapisujesz nigdzie współczynników. Bez tego nie odtworzysz rozwiązania

[OrseY 0]

Kiedys pisałem na zajeciach. kod jest w php. moze sie przyda

 

$wsp[0][0] = 2;
$wsp[0][1] = 3;
$wsp[0][2] = (-1);
$wsp[1][0] = 1;
$wsp[1][1] = 1;
$wsp[1][2] = 1;
$wsp[2][0] = 1;
$wsp[2][1] = 0;
$wsp[2][2] = (-2);

$wyn[0] = 15;
$wyn[1] = 3;
$wyn[2] = 6;

$n = 3;

//zadeklarowane wspołczynniki

for ($a = 0; $a < $n; $a++)
{
$lambda = 1 / $wsp[$a][$a];
for($b = 0; $b < $n; $b++) { $wsp[$a][$b] = $wsp[$a][$b] * $lambda; }
$wyn[$a] = $wyn[$a] * $lambda;
for ($b = $a+1; $b < $n; $b++)
{
$alfa = (-1) * $wsp[$b][$a];
for($c = 0; $c < $n; $c++) { $wsp[$b][$c] = $wsp[$b][$c] + ($wsp[$a][$c] * $alfa); }
$wyn[$b] = $wyn[$b] + ($wyn[$a] * $alfa);
}
}

//zakoncznie tworzenia macierzy

$x[$n-1] = $wyn[$n-1];


for ($a = $n-2; $a >= 0; $a--)
{
$wyr = 0;
for ($b = $a+1; $b < $n; $b++) { $wyr = $wyr - ($wsp[$a][$b] * $x[$b]); }
$x[$a] = $wyn[$a] + $wyr;
}


//wyswietlanie wynikow
for ($a = 0; $a < $n; $a++)
{
echo $x[$a] . " ";
}

 

pozdrawiam

[Bula i spula 0]

Ogólnie chodzi o to, że jak jest układ równań, to jak któreś z równań pomnożymy,podzielimy,(tutaj nie mam pewności: dodamy lub odejmiemy) od innego, to wartości zmiennych się nie zmienią. W ten sposób dąży się do tzw. trójkątku Gaussa poprzez np.

I. 2x+5y+1z=0

II. x-3y-3z=0

III. 4x+1y-z=0

 

III->III+I //Równanie III podmnieniamy sumą równań III+I

4x+1y-z=0

+

2x+5y+z=0

=

6x+6y=0

I tak się pozbyłem z i potem robisz tak dalej, aż osiągniesz np. taki trójkąt:

 

x=5

x+y=10

x+y+z=15

 

czyli

x=5

y=10-5=5

z=15-5-5=5

Czyli jak widać, jak już będziemy mieli ten trójkąt, wszystkie niewiadome mamy jak na dłoni.

Opisałem mniej więcej jak to się liczy, a tobie pozostawiać implementację w c++.