peterzig

[AISD] COO CRS CSS CS 1.6 CWKS LGBT HWDP JPG GMD

May 31st, 2016
242
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.03 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <malloc.h>
  4.  
  5. struct ElementMacierzyCOO
  6. {
  7.         unsigned int Wiersz;
  8.         unsigned int Kolumna;
  9.         double Wartosc;
  10. };
  11.  
  12. struct MacierzRzadkaCOO
  13. {
  14.         unsigned int Niezerowych;
  15.         unsigned int Wiersze;
  16.         unsigned int Kolumny;
  17.         struct ElementMacierzyCOO *Elementy;
  18. };
  19.  
  20. struct ElementMacierzyCCS
  21. {
  22.         unsigned int Wiersz;
  23.         double Wartosc;
  24. };
  25.  
  26. struct MacierzRzadkaCCS
  27. {
  28.         unsigned int Niezerowych;
  29.         unsigned int Wiersze;
  30.         unsigned int Kolumny;
  31.         unsigned int *col_ptr;
  32.         struct ElementMacierzyCCS *Elementy;
  33. };
  34.  
  35. struct ElementMacierzyCRS
  36. {
  37.         unsigned int Kolumna;
  38.         double Wartosc;
  39. };
  40.  
  41. struct MacierzRzadkaCRS
  42. {
  43.         unsigned int Niezerowych;
  44.         unsigned int Wiersze;
  45.         unsigned int Kolumny;
  46.         unsigned int *row_ptr;
  47.         struct ElementMacierzyCRS *Elementy;
  48. };
  49.  
  50. bool WczytajMacierz(MacierzRzadkaCOO *MacierzCOO);
  51. void ZwolnijMacierzCOO(MacierzRzadkaCOO *MacierzCOO);
  52. void WyswietlMacierzCOO(MacierzRzadkaCOO *MacierzCOO);
  53.  
  54. //CCS
  55. MacierzRzadkaCCS* KonwertujCOOnaCCS(MacierzRzadkaCOO *MacierzCOO);
  56. void WyswietlMacierzCCS(MacierzRzadkaCCS *MacierzCCS);
  57. void ZwolnijMacierzCCS(MacierzRzadkaCCS *MacierzCCS);
  58.  
  59. //CRS
  60. MacierzRzadkaCRS* KonwertujCOOnaCRS(MacierzRzadkaCOO *MacierzCOO);
  61. void WyswietlMacierzCRS(MacierzRzadkaCRS *MacierzCRS);
  62. void ZwolnijMacierzCRS(MacierzRzadkaCRS *MacierzCRS);
  63.  
  64. int main()
  65. {
  66.         MacierzRzadkaCOO *MacierzCOO = (MacierzRzadkaCOO*)malloc(sizeof(MacierzRzadkaCOO));
  67.         if(MacierzCOO != NULL)
  68.         {
  69.                 if(WczytajMacierz(MacierzCOO)) //Udalo sie wczytac macierz wiec dzialamy
  70.                 {
  71.                         WyswietlMacierzCOO(MacierzCOO);
  72.                        
  73.                         //Zabawa z macierzami CCS i CRS
  74.                         MacierzRzadkaCCS *MacierzCCS = NULL;
  75.                         MacierzRzadkaCRS *MacierzCRS = NULL;
  76.  
  77.                         MacierzCCS = KonwertujCOOnaCCS(MacierzCOO);
  78.                         MacierzCRS = KonwertujCOOnaCRS(MacierzCOO);
  79.  
  80.                         if(MacierzCCS != NULL) //Mamy przekonwertowana macierz, hura kurwo
  81.                         {
  82.                                 WyswietlMacierzCCS(MacierzCCS);
  83.                                 ZwolnijMacierzCCS(MacierzCCS); //Pamietac o zwolnieniu pamieci
  84.                         }
  85.  
  86.                         if(MacierzCRS != NULL) //I CRS jest heh
  87.                         {
  88.                                 WyswietlMacierzCRS(MacierzCRS);
  89.                                 ZwolnijMacierzCRS(MacierzCRS); //Pamietac o zwolnieniu pamieci
  90.                         }
  91.  
  92.                         //Zwalniamy pamiec po COO
  93.                         ZwolnijMacierzCOO(MacierzCOO);
  94.                 }
  95.                 else
  96.                 {
  97.                         free(MacierzCOO); //Pamietac o zwolnieniu pamieci
  98.                 }
  99.         }
  100.         _getch();
  101.         return 0;
  102. }
  103.  
  104.  
  105. void WyswietlMacierzCCS(MacierzRzadkaCCS *MacierzCCS)
  106. {
  107.         if(MacierzCCS != NULL)
  108.         {
  109.                 printf("val: ");
  110.                 for(unsigned int i = 0; i < MacierzCCS->Niezerowych; i++)
  111.                         printf("%5.2lf ", MacierzCCS->Elementy[i].Wartosc);
  112.                 printf("\n");
  113.  
  114.                 printf("row_ind: ");
  115.                 for(unsigned int i = 0; i < MacierzCCS->Niezerowych; i++)
  116.                         printf("%i ", MacierzCCS->Elementy[i].Wiersz);
  117.                 printf("\n");
  118.  
  119.                 printf("col_ptr: ");
  120.                 for(unsigned int i = 0; i < MacierzCCS->Kolumny; i++)
  121.                         printf("%i ", MacierzCCS->col_ptr[i]);
  122.                 printf("\n\n\n");
  123.         }
  124. }
  125.  
  126. void WyswietlMacierzCRS(MacierzRzadkaCRS *MacierzCRS)
  127. {
  128.         if(MacierzCRS != NULL)
  129.         {
  130.                 if(MacierzCRS->Elementy != NULL)
  131.                 {
  132.                         printf("val: ");
  133.                         for(unsigned int i = 0; i < MacierzCRS->Niezerowych; i++)
  134.                                 printf("%5.2lf ", MacierzCRS->Elementy[i].Wartosc);
  135.                         printf("\n");
  136.  
  137.                         printf("col_ind: ");
  138.                         for(unsigned int i = 0; i < MacierzCRS->Niezerowych; i++)
  139.                                 printf("%i ", MacierzCRS->Elementy[i].Kolumna);
  140.                         printf("\n");
  141.  
  142.                         printf("row_ptr: ");
  143.                         for(unsigned int i = 0; i < MacierzCRS->Wiersze; i++)
  144.                                 printf("%i ", MacierzCRS->row_ptr[i]);
  145.                         printf("\n");
  146.                 }
  147.         }
  148. }
  149.  
  150.  
  151. void ZwolnijMacierzCCS(MacierzRzadkaCCS *MacierzCCS)
  152. {
  153.         if(MacierzCCS != NULL)
  154.         {
  155.                 free(MacierzCCS->Elementy);
  156.                 free(MacierzCCS->col_ptr);
  157.                 free(MacierzCCS);
  158.         }
  159. }
  160.  
  161. void ZwolnijMacierzCRS(MacierzRzadkaCRS *MacierzCRS)
  162. {
  163.         if(MacierzCRS != NULL)
  164.         {
  165.                 free(MacierzCRS->Elementy);
  166.                 free(MacierzCRS->row_ptr);
  167.                 free(MacierzCRS);
  168.         }
  169. }
  170.  
  171. MacierzRzadkaCCS* KonwertujCOOnaCCS(MacierzRzadkaCOO *MacierzCOO)
  172. {
  173.         MacierzRzadkaCCS *MacierzCCS = (MacierzRzadkaCCS*)malloc(sizeof(MacierzRzadkaCCS)); //No to alokujemy to gowno
  174.         if(MacierzCCS != NULL)
  175.         {
  176.                 MacierzCCS->Elementy = (ElementMacierzyCCS*)malloc(sizeof(ElementMacierzyCCS)*(MacierzCOO->Niezerowych));
  177.                 if(MacierzCCS->Elementy != NULL)
  178.                 {
  179.                         //Najpierw uzupelnijmy sobie dane ;p
  180.                         MacierzCCS->Kolumny = MacierzCOO->Kolumny;
  181.                         MacierzCCS->Wiersze = MacierzCOO->Wiersze;
  182.                         MacierzCCS->Niezerowych = MacierzCOO->Niezerowych;
  183.                         MacierzCCS->col_ptr = (unsigned int*)malloc(sizeof(unsigned int) * MacierzCCS->Kolumny); //Juz alokujemy sobie pamiec na przeskoki, a ilosc przeskokow jest rowna po prostu iloscia kolumn
  184.  
  185.                         //UZUPELNIAMY col_ptr zerami
  186.                         for(unsigned int i = 0; i < MacierzCCS->Kolumny; i++) MacierzCCS->col_ptr[i] = 0;
  187.  
  188.                         for(unsigned int i = 0; i < MacierzCCS->Niezerowych; i++) //To przepisujemy
  189.                         {
  190.                                 //Najpierw pospisujemy to co niezmienne :)
  191.                                 MacierzCCS->Elementy[i].Wiersz = MacierzCOO->Elementy[i].Wiersz;
  192.                                 MacierzCCS->Elementy[i].Wartosc = MacierzCOO->Elementy[i].Wartosc;
  193.  
  194.                                 //A teraz akcja, bo trzeba pamiętac o uzupelnianiu tego col_ptr
  195.                                 if(MacierzCCS->col_ptr[(MacierzCOO->Elementy[i].Kolumna - 1)] < MacierzCOO->Elementy[i].Wiersz)
  196.                                 {
  197.                                         MacierzCCS->col_ptr[(MacierzCOO->Elementy[i].Kolumna - 1)] = MacierzCOO->Elementy[i].Wiersz;
  198.                                 }
  199.                         }
  200.  
  201.                         //I na koniec dodajemy col_ptr
  202.                         for(unsigned int i = 0; i < MacierzCCS->Kolumny - 1; i++)
  203.                         {
  204.                                 MacierzCCS->col_ptr[i + 1] += MacierzCCS->col_ptr[i];
  205.                         }
  206.                         return MacierzCCS;
  207.                 }
  208.                 free(MacierzCCS); //Nie udalo sie zaalokowac pamieci na elementy to chuj z taka macierza ;_;
  209.                 return NULL;
  210.         }
  211.         return NULL;
  212. }
  213.  
  214.  
  215. MacierzRzadkaCRS* KonwertujCOOnaCRS(MacierzRzadkaCOO *MacierzCOO)
  216. {
  217.         MacierzRzadkaCRS *MacierzCRS = (MacierzRzadkaCRS*)malloc(sizeof(MacierzRzadkaCRS)); //No to alokujemy to gowno
  218.         if(MacierzCRS != NULL)
  219.         {
  220.                 MacierzCRS->Elementy = (ElementMacierzyCRS*)malloc(sizeof(ElementMacierzyCRS)*(MacierzCOO->Niezerowych));
  221.                 if(MacierzCRS->Elementy != NULL)
  222.                 {
  223.                         //Najpierw uzupelnijmy sobie dane ;p
  224.                         MacierzCRS->Kolumny = MacierzCOO->Kolumny;
  225.                         MacierzCRS->Wiersze = MacierzCOO->Wiersze;
  226.                         MacierzCRS->Niezerowych = MacierzCOO->Niezerowych;
  227.                         MacierzCRS->row_ptr = (unsigned int*)malloc(sizeof(unsigned int) * MacierzCRS->Wiersze); //Juz alokujemy sobie pamiec na przeskoki, a ilosc przeskokow jest rowna po prostu ilosci wierszow
  228.  
  229.                         //UZUPELNIAMY row_ptr zerami
  230.                         for(unsigned int i = 0; i < MacierzCRS->Wiersze; i++) MacierzCRS->row_ptr[i] = 0;
  231.  
  232.                         for(unsigned int i = 0; i < MacierzCRS->Niezerowych; i++) //To przepisujemy
  233.                         {
  234.                                 //Najpierw pospisujemy to co niezmienne :)
  235.                                 MacierzCRS->Elementy[i].Kolumna = MacierzCOO->Elementy[i].Kolumna;
  236.                                 MacierzCRS->Elementy[i].Wartosc = MacierzCOO->Elementy[i].Wartosc;
  237.  
  238.                                 //A teraz akcja, bo trzeba pamiętac o uzupelnianiu tego row_ptr
  239.                                 if(MacierzCRS->row_ptr[(MacierzCOO->Elementy[i].Wiersz - 1)] < MacierzCOO->Elementy[i].Kolumna)
  240.                                 {
  241.                                         MacierzCRS->row_ptr[(MacierzCOO->Elementy[i].Wiersz - 1)] = MacierzCOO->Elementy[i].Kolumna;
  242.                                 }
  243.                         }
  244.                         //I na koniec dodajemy row_ptr
  245.                         for(unsigned int i = 0; i < MacierzCRS->Wiersze - 1; i++)
  246.                         {
  247.                                 MacierzCRS->row_ptr[i + 1] += MacierzCRS->row_ptr[i];
  248.                         }
  249.                         return MacierzCRS;
  250.                 }
  251.                 free(MacierzCRS); //Nie udalo sie zaalokowac pamieci na elementy to chuj z taka macierza ;_;
  252.                 return NULL;
  253.         }
  254.         return NULL;
  255. }
  256.  
  257.  
  258. void WyswietlMacierzCOO(MacierzRzadkaCOO *MacierzCOO)
  259. {
  260.         if(MacierzCOO != NULL)
  261.         {
  262.                 if(MacierzCOO->Elementy != NULL)
  263.                 {
  264.                         unsigned int wartownik = 0;
  265.                         printf("MacierzRzadkaCOO:\n------------\nWiersze [ Wartosci ]\n\n");
  266.                         for(unsigned int i = 0; i < MacierzCOO->Wiersze && wartownik != MacierzCOO->Niezerowych; i++)
  267.                         {
  268.                                 printf("%2i [ ", i + 1);
  269.                                 for(unsigned int x = 0; x < MacierzCOO->Kolumny && wartownik != MacierzCOO->Niezerowych; x++)
  270.                                 {
  271.                                         for(unsigned int y = 0; y < MacierzCOO->Niezerowych && wartownik != MacierzCOO->Niezerowych; y++) //Lecimy i sprawdzamy czy jest element w takiej kolumnie i wierszu
  272.                                         {
  273.                                                 if((i == (MacierzCOO->Elementy[y].Wiersz - 1)) && (x == (MacierzCOO->Elementy[y].Kolumna - 1))) //Udalo sie znalezc
  274.                                                 {
  275.                                                         printf("%5.3lf ", MacierzCOO->Elementy[y].Wartosc);
  276.                                                         wartownik++; //+1 znaleziony element
  277.                                                         break;
  278.                                                 }
  279.                                         }
  280.                                 }
  281.                                 printf("]\n");
  282.                         }
  283.                         printf("\n");
  284.                 }
  285.         }
  286. }
  287.  
  288. bool WczytajMacierz(MacierzRzadkaCOO *MacierzCOO)
  289. {
  290.         FILE *plik = fopen("Macierz.txt", "r");
  291.         if(plik != NULL)
  292.         {
  293.                 fscanf(plik, "%i %i %i", &MacierzCOO->Wiersze, &MacierzCOO->Kolumny, &MacierzCOO->Niezerowych); //Zczytujemy podstawowe dane macierzy
  294.                 MacierzCOO->Elementy = (ElementMacierzyCOO*)malloc(sizeof(ElementMacierzyCOO)*MacierzCOO->Niezerowych); //Alokujemy pamiec na ilosc elementow niezerowych
  295.                
  296.                 if(MacierzCOO->Elementy != NULL)
  297.                 {
  298.                         for(unsigned int i = 0; i < MacierzCOO->Niezerowych; i++)
  299.                         {
  300.                                 fscanf(plik, "%i %i %lf", &MacierzCOO->Elementy[i].Wiersz, &MacierzCOO->Elementy[i].Kolumna, &MacierzCOO->Elementy[i].Wartosc); //Pokolei lecimy ze zczytem do macierzy COO
  301.                         }
  302.                         fclose(plik); //Pamietajmy o zamknieciu pliku
  303.                         return true;
  304.                 }
  305.                 else
  306.                 {
  307.                         fclose(plik); //Pamietajmy o zamknieciu pliku
  308.                         return false;
  309.                 }
  310.         }
  311.         return false;
  312. }
  313.  
  314. void ZwolnijMacierzCOO(MacierzRzadkaCOO *MacierzCOO)
  315. {
  316.         if(MacierzCOO != NULL)
  317.         {
  318.                 free(MacierzCOO->Elementy);
  319.                 free(MacierzCOO);
  320.         }
  321. }
Advertisement
Add Comment
Please, Sign In to add comment