wskaźniki Gauss

Question

Co jest nie tak z tym programikiem że na wyjściu wychodzą błędne dane.

    vector<vector <double> > wiersz {{5,7,4,2},{4, 7, 8, 3},{2, 3, 6, 7} };
    vector <double *> wskk {nullptr};
    int rozmiar=0;
    rozmiar=wiersz[0].size()-1;

    for (int i=0; i<rozmiar; i++)
    {
        if ((wiersz[0].size()-2)>rozmiar)
        {
            cout <<"blad";
            return 0;
        }
   
        wskk[i]=&wiersz[i][rozmiar-1];
        wskk.push_back(nullptr);
 
    } //wskk.pop_back();

  for (int i=0; i<rozmiar-1; i++) // docelowo przydała by się funkcja która wyzeruje kolejne kolumny.
    {
    
        if (*wskk[i]<*wskk[i+1]) // największy wyraz na początek 
        {
            double* temp=wskk[i];
            wskk[i]=wskk[i+1];
            wskk[i+1]=temp;
        }
    }
    for (int i=0; i<rozmiar; i++)
    {
        for (int j=rozmiar; j>=0; j--)
        {
            cout<<*(wskk[i]-j+1)<<", ";

        }
        cout<<endl;
    }
    cout<<endl;
    for (int i=0; i<rozmiar; i++)
    {
        for (int j=rozmiar; j>=0; j--)
        {
            if(i<rozmiar-1)
            {
                double* temp=wskk[i+1]-j+1;
                double tempd=*wskk[i+1];
                if(tempd==0) break;
                *temp *= *wskk[0];
                *temp/=tempd; 
                // odejmuję 
                // usuwam element zerowy
            }
            cout<<//"("<<j<<")"<<
                *(wskk[i]-j+1)<<", ";
        // przestawiam wskaźnik na kolejną kolumnę zmieniam rozmiar zmieniam wiersz zerowy itd..;
        }
  
        cout<<endl;
    }

 

 

 

na wyjściu programu

4, 7, 8, 3,
2, 3, 6, 7,
5, 7, 4, 2,

4, 7, 8, 3,
2.66667, 4, 8, 7, (dlaczego 7?)
10, 14, 8, 2, (dlaczego 2?)

Wiem że to trochę dziwnie napisane ale zależy mi na wskaźnikach (chyba że suwanie wierszy jest szybsze);

Pierwszy pomysł był taki i chyba lepszy by kolejne wiersze po układać na stosie.

Comments

Dopisz jeszcze co chcesz policzyć, bo może być kwestia złej implementacji, a bez informacji o tym, co chcesz zaimplementować, nie sprawdzimy czy jest ok

---

na razie to utknąłem na początku bo udało mi się uzyskać trzeci wyraz taki sam i mogę odejmować ale wyraz wolny mi się nie podzielił. A chcę uzyskać macierz trójkątna tylko od tyłu. A nie chcę ruszać macierzy tylko wskaźnikami (chyba ze wykasować wyraz zerowy) chyba że jest jakiś gotowiec co sobie poradzi z macierzą np 100 x100

---

Wciąż nie wiadomo co chcesz zaimplementować

---

Generalnie to chciałem pobawić się wskaźnikami, ale nigdy mnie nie słuchały.

{  liczba  liczba  liczba liczba

   liczba  liczba     0    liczba

  liczba     0         0   liczba }

albo lepiej

{  liczba  liczba  liczba liczba

   liczba  liczba  liczba

  liczba liczba }

a wektor np:

{  liczba  liczba  liczba liczba     wsk[1]

  liczba liczba                          wsk[3]

liczba  liczba  liczba }              wsk [2]

Ale fakt skomplikowałem to bardzo już mam trochę inny pomysł.

---

Co tu się dzieje w tym kodzie :O Naprawdę nie możesz dokładnie opisać swojego programu i tego co chcesz zrobić? Czemu używasz wskaźników, które mogą utracić ważność zamiast np iteratorów?

---

C++ to dla mnie tylko zabawa. A chciałbym na przykład uzyskać przyzwoitą prędkość dla macierzy np 100k x 100k np do mesu.

ale chyba sobie poradziłem tylko jeszcze uprościć i spróbować wsk[nn]-- zamiast -nn. i zrobić jako klasę.

Jak wczytam getline od tyłu do wektora to będzie gites.

#include <iostream>
#include <vector>
#include <iomanip>

using namespace std;

int main()
{
    vector<vector <double> > wiersz {
                                    {5, 7, 4, 2, 5, 4},
                                    {4, 7, 0, 0, 3, 8},
                                    {2, 3, 6, 7, 11, 2},
                                    {2, 2, 7, 6, 4, 9},
                                    {2, 5, 7, 6, 8, 9}
    };

    vector <double *> wskk {nullptr};
    int rozmiar=0;

    rozmiar=wiersz[0].size()-1;
    for (int i=0; i<rozmiar; i++) // tworzenie tablicy wskaŸników
    {
        if ((wiersz[0].size()-2)>rozmiar)
        {
            cout <<"blad";
            return 0;
        }
        wskk[i]=&wiersz[i][rozmiar]; ///
        wskk.push_back(nullptr);
       cout<<wskk[i]<<"="<<*wskk[i]<<endl;
    } wskk.pop_back();
    
    for (int i=0; i<rozmiar-1; i++)
    {
        if (*wskk[i]<*wskk[i+1])
        {
            swap(wskk[i],wskk[i+1]);
        }
    }
  //-------wipisz-------------------------------

    for (int i=0; i<rozmiar; i++)
    {
        for (int j=rozmiar; j>=0; j--)
        {
            cout<<*(wskk[i]-j)<<", ";
        }
       cout<<endl;
    }
   /// cout<<endl;
//------- z redukuj rownanie-----------------
    for (int nn=0;nn<rozmiar;nn++)
    {
    cout<<"["<< *(wskk[nn]-nn) << "] "<<endl;
    for (int i=nn; i<rozmiar; i++)
    {
        for (int j=rozmiar-nn; j>=0; j--)
        {
            if(i<rozmiar-1)
            {
                double *temp=(wskk[i+1]-j-nn);
                double tempd=*(wskk[i+1]-nn);
                *temp *= *(wskk[nn]-nn);
                *temp/=tempd;
                *temp-=*((wskk[nn])-j-nn);
            }
           cout<<setw(8)<<
                *(wskk[i]-j-nn)<<", ";
}
      cout<<"-------------i="<< i <<"---------------"<<endl;
    }
    int mm=nn;
    while ((*(wskk[nn])-nn==0) && (mm<rozmiar))
        {
          swap(wskk[nn],wskk[mm+1]);
          continue;
          mm++;
      }
 cout<<"****************n="<< nn <<"*****************************"<<endl;
  }

    for (int i=0; i<rozmiar; i++)
    {
        for (int j=0; j<rozmiar+1; j++)
        {
            cout<<setw(8)<<wiersz [i][j]<<", \t";
        }
        cout<<endl;
    }
    cout<<endl;

    return 0;
}

A na wyjściu mam

4, 7, 0, 0, 3, 8,
5, 7, 4, 2, 5, 4,
2, 2, 7, 6, 4, 9,
2, 5, 7, 6, 8, 9,
2, 3, 6, 7, 11, 2,
[8]
       4,        7,        0,        0,        3,        8, -------------i=0---------------
       6,        7,        8,        4,        7,        0, -------------i=1---------------
-2.22222, -5.22222,  6.22222,  5.33333, 0.555556,        0, -------------i=2---------------
-2.22222, -2.55556,  6.22222,  5.33333,  4.11111,        0, -------------i=3---------------
       4,        5,       24,       28,       41,        0, -------------i=4---------------
****************n=0*****************************
[7]
       6,        7,        8,        4,        7, -------------i=1---------------
     -34,    -72.8,     70.4,     63.2,        0, -------------i=2---------------
-9.78378, -11.3514,  2.59459,  5.08108,        0, -------------i=3---------------
-5.31707, -6.14634, -3.90244, 0.780488,        0, -------------i=4---------------
****************n=1*****************************
[63.2]
     -34,    -72.8,     70.4,     63.2, -------------i=2---------------
-87.6936, -68.3915, -38.1277,        0, -------------i=3---------------
 -396.55,   -424.9,   -386.4,        0, -------------i=4---------------
****************n=2*****************************
[-38.1277]
-87.6936, -68.3915, -38.1277, -------------i=3---------------
 48.5644,  26.4649,        0, -------------i=4---------------
****************n=3*****************************
[26.4649]
 48.5644,  26.4649, -------------i=4---------------
****************n=4*****************************
       6,              7,              8,              4,              7,              0,
       4,              7,              0,              0,              3,              8,
 48.5644,        26.4649,              0,              0,              0,              0,
     -34,          -72.8,           70.4,           63.2,              0,              0,
-87.6936,       -68.3915,       -38.1277,              0,              0,              0,

---

prędkość CZEGO? ciągle nie mówisz co implementujesz i czego prędkość chcesz poprawić

---

rozwiązania A x=B gdzie interesuje mnie wektor x jak wyniki są ok to dobrze jak nie to buduję nową macierz.

Powtarzam ja nie jestem programistą tylko hobbystą.

A tak dla całkowitej zaspokojenia ciekawości to mam książkę podstawy MESu, oni mają matlaba a ja tylko podstawową znajomość C++. Książka tak do poduszki.

---

Macierz 32x32+1. Czas chyba całkiem przyzwoity? (ale 3 uruchomienie na tych samych danych). A jak to  wygląda w metodach iteracyjnych?

wyniki rozwiązania dokładność to około 8 cyfr znaczących<<<<<<<<<<<<<<<<<<<<<<,
1.1548201207690809156,3.9251975218337760154,2.7128592221563243569,2.0946103981247632397,-1.3313871587932020191,-1.1417624339921785825,1.6284401446795790935,-5.619921899247642294,-0.78904724956914196188,-2.2691803379563415533,-0.52825299607518239053,-4.7037952193418872682,0.66004842683603137665,-3.0154061998394694477,3.7827254707683346524,-1.6593088764116916689,-2.405556997152645593,-5.2625328259004300335,-0.82685772048977623783,5.415200239836739371,2.5035027145853487873,3.0655795647060966047,0.061058849387186503455,-0.27782227230967593279,0.21105960527400835502,2.7438520135312178816,2.5273732049819908063,0.054580278552498869005,-3.4506106568534122836,-0.054326479866488537607,-6.6436687834922905083,-3.2856473088332349697,

Process returned 0 (0x0)   execution time : 0.141 s