Facebook

coś safest cryptocurrency exchange

From Michał, 5 Years ago, written in Plain Text.
URL https://pastebin.pl/view/aec43977
Embed
Download Paste or View Raw
Hits: 225
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <string.h>
  4. #include <time.h>
  5. #include <locale.h>
  6. #include <stdlib.h>
  7. #include "Header.h"
  8. #define _CRT_SECURE_NO_WARNINGS
  9.  
  10. enum { poczatek = 0, koniec, amplituda, przes_OX, przes_OY, ilosc, okres, skok };
  11. #define M_PI 3.14159265358979323846
  12.  
  13.  
  14.  
  15. double Fn_Sinus(double *tab_Wspol, double d_czas);
  16. double Fn_Trojkat(double *tab_Wspol, double d_czas);
  17. double Fn_Pila(double *tab_Wspol, double d_czas);
  18. void Fn_Przypisz(const char *tekst, const char *format, void *zmienna);
  19. void Fn_Pobierz_Dane(double *tab_Wspol, double **tab_Szum);
  20. void Fn_Zmienna_Przypisz(const char *format, void *zmienna);
  21. int Fn_Wypelnij(double *tab_Wspol, double **tab_Sygnal, double **tab_Argumenty, int *syg);
  22. void Fn_Menu(void);
  23. int Fn_Szum(double **tab_Szum, double *tab_Wspol, double *tab_Sygnal);
  24. int Fn_Wyswietl(double *tab_Szum, double *tab_Sygnal, double *tab_Argumenty, double *tab_Wspol);
  25. int Fn_Filtr(double *tab_Szum, double **tab_Filtrowana, double *tab_Argumenty, double *tab_Wspol);
  26. double Fn_Babelkowe(double *tab_Pomocnicza, int okno);
  27. double Fn_Mediana(double *tab_Szum, int okno, int poczatek, int koniec);
  28. double Fn_Srednia(double *tab_Szum, int okno, int poczatek, int koniec);
  29. double Fn_Wczytaj(double **tab_Sygnal, double **tab_Szum, double **tab_Filtrowana, double **tab_Argumenty, double *tab_Wspol);
  30. char* Fn_Pobierz_Nazwe_Pliku(void);
  31.  
  32. int main()
  33. {
  34.         double tab_Wspol[8]; //wspolczynniki: poczatek, koniec, amplituda, przesuniecie wzg osi X, przesuniecie wzg osi Y, ilosc probek, okres, skok
  35.         char tab_Nazwa[32] = "";
  36.         int opcja = 0;//zmienna decyzji opcji z menu
  37.         int syg = 0; //flaga do filtru medianowego, ktora funkcja sygnalu zostala uzyta
  38.         double *tab_Sygnal = NULL;
  39.         double *tab_Argumenty = NULL;
  40.         double *tab_Szum = NULL;
  41.         double *tab_Filtrowana = NULL;
  42.         setlocale(LC_ALL, "polish_poland");
  43.        
  44.         while (1)
  45.         {
  46.                 Fn_Menu();
  47.                 while (!scanf("%d", &opcja))
  48.                 {
  49.                         while (getchar() != '\n');
  50.                         Fn_Menu();
  51.                 }
  52.                 system("cls");
  53.                 switch (opcja)
  54.                 {
  55.                 case 0:
  56.                         return 0;
  57.                 case 1:
  58.                         Fn_Pobierz_Dane(tab_Wspol, &tab_Szum);
  59.                         Fn_Wypelnij(tab_Wspol, &tab_Sygnal, &tab_Argumenty, &syg);
  60.                         break;
  61.                 case 2:
  62.                         Fn_Szum(&tab_Szum, tab_Wspol, tab_Sygnal);
  63.                         break;
  64.                 case 3:
  65.                         Fn_Wyswietl(tab_Szum, tab_Sygnal, tab_Argumenty, tab_Wspol);
  66.                         break;
  67.                 case 4:
  68.                         break;
  69.                 case 5:
  70.                         Fn_Wczytaj(&tab_Sygnal, &tab_Szum, &tab_Filtrowana, &tab_Argumenty, tab_Wspol);
  71.                         break;
  72.                 case 6:
  73.                         Fn_Filtr(tab_Szum, &tab_Filtrowana, tab_Argumenty, tab_Wspol);
  74.                         break;
  75.                 case 7:
  76.                         break;
  77.                 default:
  78.                         printf("Nie ma takiej opcji w menu. Sprobuj ponownie.\n");
  79.                         getchar();
  80.                         while (getchar() != '\n');
  81.                 }
  82.  
  83.         };
  84. }
  85.  
  86.  
  87. double Fn_Sinus(double *tab_Wspol, double d_czas) //czas jako zmienna, ktora jest ustalana przez petle
  88. {
  89.         double wynik; //wartosc sygnalu sinusoidalnego dla danego czasu
  90.         double A = tab_Wspol[amplituda];
  91.         double C = tab_Wspol[przes_OX];
  92.         double D = tab_Wspol[przes_OY];
  93.         double T = tab_Wspol[okres];
  94.  
  95.         wynik = A * sin((2 * M_PI / T)*d_czas - 2 * M_PI *(C / 100)) + D;
  96.        
  97.         return wynik;
  98. }
  99.  
  100.  
  101. double Fn_Trojkat(double *tab_Wspol, double d_czas)
  102. {
  103.         double wynik; //wartosc sygnalu trojkatnego dla danego czasu
  104.         double A = tab_Wspol[amplituda];
  105.         double C = tab_Wspol[przes_OX];
  106.         double D = tab_Wspol[przes_OY];
  107.         double T = tab_Wspol[okres];
  108.  
  109.         d_czas -= C / 100 * T; //czas z uwzglednieniem przesuniecia wzg OX
  110.         wynik = (2 * A / T)*(d_czas - floor(d_czas / T)*T); //obliczenie punktu odniesienia do wyliczenia sygnalu trojkatnego
  111.  
  112.         if (wynik < A)
  113.         {
  114.                 return wynik + D;
  115.         }
  116.         else
  117.         {
  118.                 return 2*A - wynik + D;
  119.         }
  120. }
  121.  
  122.  
  123. double Fn_Pila(double *tab_Wspol, double d_czas)
  124. {
  125.         double wynik; //wartosc sygnalu trojkatnego dla danego czasu
  126.         double A = tab_Wspol[amplituda];
  127.         double C = tab_Wspol[przes_OX];
  128.         double D = tab_Wspol[przes_OY];
  129.         double T = tab_Wspol[okres];
  130.  
  131.         d_czas -= C/100 * T; //czas z uwzglednieniem przesuniecia wzg OX
  132.         wynik = (d_czas - floor(d_czas / T)*T); //obliczenie punktu odniesienia do wyliczenia sygnalu trojkatnego
  133.  
  134.         if (wynik < 0.95*T)
  135.         {
  136.                 return A/(0.95*T) * wynik + D;
  137.         }
  138.         else
  139.         {
  140.                 return A - A/(0.05*T) * (wynik - 0.95*T)+ D;
  141.         }
  142. }
  143.  
  144.  
  145. void Fn_Przypisz(const char *tekst, const char *format, void *zmienna)
  146. {
  147.         printf("%s", tekst);
  148.        
  149.         while (!scanf(format, zmienna))
  150.         {
  151.                 system("cls");
  152.                 printf("Podales cos niejasnego. Powtorz.\n");
  153.                 while (getchar() != '\n');
  154.                 printf("%s", tekst);
  155.         }
  156.         while (getchar() != '\n');
  157. }
  158.  
  159.  
  160. void Fn_Zmienna_Przypisz(const char *format, void *zmienna)
  161. {
  162.         while (!scanf(format, zmienna))
  163.         {
  164.                 printf("Podales cos niejasnego. Powtorz: ");
  165.                 while (getchar() != '\n');
  166.         }
  167.         while (getchar() != '\n');
  168. }
  169.  
  170.  
  171. void Fn_Pobierz_Dane(double *tab_Wspol, double **tab_Szum) //wspolczynniki: poczatek, koniec, amplituda, przesuniecie wzg osi X, przesuniecie wzg osi Y, ilosc probek, okres, skok
  172. {
  173.         int wybor = 0;
  174.         double ptr = 0;
  175.         free(*tab_Szum);
  176.         *tab_Szum = NULL;
  177.         Fn_Przypisz("1) Podaj poczatek dziedziny sygnalu: ", "%lf", (tab_Wspol + poczatek));
  178.         system("cls");
  179.         Fn_Przypisz("2) Podaj koniec dziedziny sygnalu: ", "%lf", (tab_Wspol + koniec));
  180.         system("cls");
  181.         do
  182.         {
  183.                
  184.                 if (tab_Wspol[poczatek] > tab_Wspol[koniec])
  185.                 {
  186.                         do
  187.                         {
  188.                                 printf("Podales poczatek dziedziny o wiekszej wartosci, niz koniec. Wybierz co chcesz zrobic: \n");
  189.                                 printf("1) Zamienic liczby miejscami.\n");
  190.                                 printf("2) Zmienic wartosci poczatku i konca przedzialu.\n");
  191.                                 printf("Twoj wybor: ");
  192.                                 Fn_Zmienna_Przypisz("%d", &wybor);
  193.                                 system("cls");
  194.                                 switch (wybor)
  195.                                 {
  196.                                 case 1:
  197.                                         ptr = tab_Wspol[koniec];
  198.                                         tab_Wspol[koniec] = tab_Wspol[poczatek];
  199.                                         tab_Wspol[poczatek] = ptr;
  200.                                         break;
  201.                                 case 2:
  202.                                         Fn_Przypisz("Podaj poczatek dziedziny sygnalu: ", "%lf", (tab_Wspol + poczatek));
  203.                                         system("cls");
  204.                                         Fn_Przypisz("Podaj koniec dziedziny sygnalu: ", "%lf", (tab_Wspol + koniec));
  205.                                         system("cls");
  206.                                 }
  207.                         } while (tab_Wspol[poczatek] > tab_Wspol[koniec]);
  208.                 }
  209.                 if (tab_Wspol[poczatek] == tab_Wspol[koniec])
  210.                 {
  211.                         do
  212.                         {
  213.                                 printf("Twoj przedzial jest jednym punktem i wynosi %0.2f. \n", tab_Wspol[poczatek]);
  214.                                 printf("1) To bylo zamierzone. Wiec zdaje sobie sprawe ze ilosc probek automatycznie wynosi 1.\n");
  215.                                 printf("2) Chce zmienic przedzialy.\n");
  216.                                 printf("Wpisz odpowiedz: ");
  217.                                 Fn_Zmienna_Przypisz("%d", &wybor);
  218.                                 system("cls");
  219.                                 switch (wybor)
  220.                                 {
  221.                                 case 1:
  222.                                         tab_Wspol[skok] = 0;
  223.                                         tab_Wspol[ilosc] = 1;
  224.                                         break;
  225.                                 case 2:
  226.                                         Fn_Przypisz("Podaj poczatek dziedziny sygnalu: ", "%lf", (tab_Wspol + poczatek));
  227.                                         system("cls");
  228.                                         Fn_Przypisz("Podaj koniec dziedziny sygnalu: ", "%lf", (tab_Wspol + koniec));
  229.                                         system("cls");
  230.                                         break;
  231.                                 default:
  232.                                         printf("Nie ma takiej opcji. Kliknij enter aby wrocic do menu wpisanie przedzialu.\n");
  233.                                         while (getchar() != '\n');
  234.                                         system("cls");
  235.                                 }
  236.                         } while ((wybor>2 || wybor<0) || (tab_Wspol[poczatek] == tab_Wspol[koniec] && wybor == 2));
  237.                 }
  238.         } while(tab_Wspol[poczatek] > tab_Wspol[koniec]);
  239.         Fn_Przypisz("3) Podaj amplitude sygnalu: ", "%lf", (tab_Wspol + amplituda));
  240.         system("cls");
  241.         if (tab_Wspol[amplituda] == 0)
  242.         {
  243.                 printf("Podales zerowa amplitude spowoduje to, ze twoj sygnal niezaszumiony bedzie staly. Co chcesz zrobic?: \n");
  244.                 printf("1) Zamienic wartosc amplitudy.\n");
  245.                 printf("2) Otrzymac stala wartosc sygnalu o amplitudzie A = 0.\n");
  246.                 printf("Twoj wybor: ");
  247.                 Fn_Zmienna_Przypisz("%d", &wybor);
  248.                 system("cls");
  249.                 if (wybor == 1)
  250.                 {
  251.                         do
  252.                         {
  253.                                 Fn_Przypisz("Podaj amplitude sygnalu: ", "%lf", (tab_Wspol + amplituda));
  254.                                 system("cls");
  255.                                 if (tab_Wspol[amplituda] == 0)
  256.                                 {
  257.                                         printf("Podales zerowa amplitude spowoduje to, ze twoj sygnal niezaszumiony bedzie staly. Co chcesz zrobic?: \n");
  258.                                         printf("1) Zamienic wartosc amplitudy.\n");
  259.                                         printf("2) Otrzymac stala wartosc sygnalu o amplitudzie A = 0.\n");
  260.                                         printf("Twoj wybor: ");
  261.                                         Fn_Zmienna_Przypisz("%d", &wybor);
  262.                                         system("cls");
  263.                                         switch (wybor)
  264.                                         {
  265.                                         case 1:
  266.                                                 Fn_Przypisz("Podaj amplitude sygnalu: ", "%lf", (tab_Wspol + amplituda));
  267.                                                 system("cls");
  268.                                                 break;
  269.                                         case 2:
  270.                                                 break;
  271.                                        
  272.                                         }
  273.                                 }
  274.                         } while ((tab_Wspol[amplituda] == 0 && wybor == 1)|| (wybor>2 || wybor <0));
  275.                 }
  276.  
  277.         }
  278.         Fn_Przypisz("4) Podaj przesuniecie sygnalu wzgledem osi OX w %% okresu: ", "%lf", (tab_Wspol + przes_OX));
  279.         system("cls");
  280.         do
  281.         {
  282.                 if (tab_Wspol[przes_OX] < 0)
  283.                 {
  284.                         printf("Wartosc %% jest wartoscia dodatnia!\n");
  285.                         Fn_Przypisz("Podaj przesuniecie sygnalu wzgledem osi OX w %% okresu: ", "%lf", (tab_Wspol + przes_OX));
  286.                         system("cls");
  287.                 }
  288.                 if (tab_Wspol[przes_OX] > 100)
  289.                 {
  290.                         printf("Wartosc %% moze maksymalnie osiagac 100!\n");
  291.                         Fn_Przypisz("Podaj przesuniecie sygnalu wzgledem osi OX w %% okresu: ", "%lf", (tab_Wspol + przes_OX));
  292.                         system("cls");
  293.                 }
  294.                        
  295.         } while (tab_Wspol[przes_OX] < 0 || tab_Wspol[przes_OX] > 100);
  296.  
  297.         Fn_Przypisz("5) Podaj przesuniecie sygnalu wzgledem osi OY: ", "%lf", (tab_Wspol + przes_OY));
  298.         system("cls");
  299.         if(tab_Wspol[ilosc]!=1)
  300.         {
  301.                 Fn_Przypisz("6) Podaj ilosc probek: ", "%lf", (tab_Wspol + ilosc));
  302.                 system("cls");
  303.                 if (tab_Wspol[ilosc] == 0 || tab_Wspol[ilosc] < 0)
  304.                 {
  305.                         do
  306.                         {
  307.                                 printf("Podales ilosc probek rowna 0 lub ujemna wartosc. Dam Ci szanse to zmienic.\n");
  308.                                 Fn_Przypisz("Podaj ilosc probek: ", "%lf", (tab_Wspol + ilosc));
  309.                                 system("cls");
  310.                         } while (tab_Wspol[ilosc] == 0 || tab_Wspol[ilosc] < 0);
  311.                 }
  312.         }
  313.         Fn_Przypisz("7) Podaj okres sygnalu: ", "%lf", (tab_Wspol + okres));
  314.         system("cls");
  315.         do
  316.         {
  317.                 if (tab_Wspol[okres] == 0 || tab_Wspol[okres] < 0)
  318.                 {
  319.                         printf("Okres musi byc dodatni! \n");
  320.                         Fn_Przypisz("7) Podaj okres sygnalu: ", "%lf", (tab_Wspol + okres));
  321.                         system("cls");
  322.                         continue;
  323.                 }
  324.                 if (tab_Wspol[okres] < 0.000001)
  325.                 {
  326.  
  327.                         printf("Okres jest typu double, podaj liczbe wieksza lub rowna 0.000001.\n");
  328.                         Fn_Przypisz("7) Podaj okres sygnalu: ", "%lf", (tab_Wspol + okres));
  329.                         system("cls");
  330.                         continue;
  331.                 }
  332.         } while (tab_Wspol[okres] < 0.000001);
  333.        
  334.         if((tab_Wspol[koniec] - tab_Wspol[poczatek]) <= tab_Wspol[ilosc])
  335.         {
  336.                 tab_Wspol[skok] = (tab_Wspol[koniec] - tab_Wspol[poczatek]) / (tab_Wspol[ilosc] - 1);
  337.         }
  338.  
  339.         if ((tab_Wspol[koniec] - tab_Wspol[poczatek]) > tab_Wspol[ilosc])
  340.         {
  341.                 tab_Wspol[skok] = (tab_Wspol[koniec] - tab_Wspol[poczatek]) / (tab_Wspol[ilosc] + 1);
  342.                 tab_Wspol[poczatek] = tab_Wspol[poczatek] + tab_Wspol[skok];
  343.         }
  344. }
  345.  
  346.  
  347. int Fn_Wypelnij(double *tab_Wspol, double **tab_Sygnal, double **tab_Argumenty, int *syg)
  348. {
  349.         int wybor = 0;
  350.         double x = 0; //zmienna sluzaca jako odliczanie (czas)
  351.         int i = 0; //zmienna pomocnicza do odliczania elementow tablicy
  352.         free(*tab_Sygnal);
  353.         free(*tab_Argumenty);
  354.         *tab_Sygnal = (double*)malloc((size_t)tab_Wspol[ilosc] * sizeof(**tab_Sygnal));
  355.         *tab_Argumenty = (double*)malloc((size_t)tab_Wspol[ilosc] * sizeof(**tab_Argumenty));
  356.         if (*tab_Sygnal == NULL || *tab_Argumenty == NULL)
  357.         {
  358.                 printf("Niestety nie udalo sie przydzielic pamieci.\n");
  359.                 if (*tab_Sygnal != NULL)
  360.                 {
  361.                         free(*tab_Sygnal);
  362.                 }
  363.                 if (*tab_Argumenty == NULL)
  364.                 {
  365.                         free(*tab_Argumenty);
  366.                 }
  367.                 getchar();
  368.                 getchar();
  369.                 exit(0);
  370.         }
  371.         else
  372.         {
  373.                 do
  374.                 {
  375.                         printf("Wybierz sygnal, ktory chcesz wygenerowac: \n");
  376.                         printf("1) Sinusoidalny\n");
  377.                         printf("2) Trojkatny\n");
  378.                         printf("3) Piloksztaltny\n");
  379.                         printf("0) Powrot do Menu\n");
  380.                         printf("Twoj wybor: ");
  381.                         Fn_Zmienna_Przypisz("%d", &wybor);
  382.                         system("cls");
  383.                         switch (wybor)
  384.                         {
  385.                         case 0:
  386.                                 return 0;
  387.                         case 1:
  388.                                 *syg = 1;
  389.                                 for (i = 0, x = tab_Wspol[poczatek]; i < (int)tab_Wspol[ilosc]; i++, x += tab_Wspol[skok])
  390.                                 {
  391.                                         (*tab_Sygnal)[i] = Fn_Sinus(tab_Wspol, x);
  392.                                         (*tab_Argumenty)[i] = x;
  393.                                 }
  394.                                 break;
  395.                         case 2:
  396.                                 *syg = 2;
  397.                                 for (i = 0, x = tab_Wspol[poczatek]; i < (int)tab_Wspol[ilosc]; i++, x += tab_Wspol[skok])
  398.                                 {
  399.                                         (*tab_Sygnal)[i] = Fn_Trojkat(tab_Wspol, x);
  400.                                         (*tab_Argumenty)[i] = x;
  401.                                 }
  402.                                 break;
  403.                         case 3:
  404.                                 *syg = 3;
  405.                                 for (i = 0, x = tab_Wspol[poczatek]; i < (int)tab_Wspol[ilosc]; i++, x += tab_Wspol[skok])
  406.                                 {
  407.                                         (*tab_Sygnal)[i] = Fn_Pila(tab_Wspol, x);
  408.                                         (*tab_Argumenty)[i] = x;
  409.                                 }
  410.                                 break;
  411.                         default:
  412.                                 printf("Nie ma takiej opcji. Kliknij enter aby wrocic do menu generowania sygnalu.\n");
  413.                                 while(getchar()!='\n');
  414.                                 system("cls");
  415.                                 *syg = 0;
  416.                         }
  417.                 } while (*syg == 0);
  418.                
  419.         }
  420. }
  421.  
  422.  
  423. void Fn_Menu(void)
  424. {
  425.         system("cls");
  426.         printf("Prosze wybrac co chcialbys zrobic ... \n");
  427.         printf("(1) Wprowadzic wspolczynniki i wygenerowac sygnal.\n");
  428.         printf("(2) Wygenerowac szum.\n");
  429.         printf("(3) Wyswietlic sygnal lub sygnal zaszumiony.\n");
  430.         printf("(4) Zapisac dane do pliku.\n");
  431.         printf("(5) Odczytac dane z pliku.\n");
  432.         printf("(6) Uzyc filtru sygnalu.\n");
  433.         printf("(0) Wyjsc z programu\n");
  434.         printf("Twoj wybor: ");
  435. }
  436.  
  437.  
  438. int Fn_Szum(double **tab_Szum, double *tab_Wspol, double *tab_Sygnal)
  439. {
  440.         int wybor = 0;
  441.         int x = 0; //pomocnicza liczba do odliczania
  442.         double ptr = 0; //pomocnicza liczba do podmiany danych
  443.         double tab_Warunki[2]; // tablica przechowaujaca warunki zaszumienia
  444.         free(*tab_Szum);
  445.         *tab_Szum = (double*)malloc((size_t)tab_Wspol[ilosc] * sizeof(**tab_Szum));
  446.         system("cls");
  447.         if (*tab_Szum == NULL)
  448.         {
  449.                 printf("Niestety nie udalo sie przydzielic pamieci.\n");
  450.                 getchar();
  451.                 getchar();
  452.                 exit(0);
  453.         }
  454.         do
  455.         {
  456.                 if (tab_Sygnal == NULL)
  457.                 {
  458.                         printf("Zanim zaszumisz sygnal, musisz go najpierw wygenerowac.\n");
  459.                         getchar();
  460.                         while (getchar() != '\n');
  461.                         return 0;
  462.                 }
  463.                 printf("Jaki typ zaszumienia chcialbys wygenerowac?\n");
  464.                 printf("(1) Szum z okreslonego zakresu.\n");
  465.                 printf("(2) Szum ze stala wartoscia, generowany na podstawie prawdopodobienstwa.\n");
  466.                 printf("(0) Wrocic do menu.\n");
  467.                 printf("Twoj wybor: ");
  468.                 Fn_Zmienna_Przypisz("%d", &wybor);
  469.                 system("cls");
  470.                 switch (wybor)
  471.                 {
  472.                 case 0:
  473.                         return 0;
  474.                 case 1:
  475.                         Fn_Przypisz("Wpisz minimalna wartosc zaszumienia: ", "%lf", &tab_Warunki[0]);
  476.                         Fn_Przypisz("Wpisz maksymalna wartosc zaszumienia: ", "%lf", &tab_Warunki[1]);
  477.                         system("cls");
  478.                         if (tab_Warunki[0] > tab_Warunki[1])
  479.                         {
  480.                                 do
  481.                                 {
  482.                                         printf("Podales poczatek przedzialu o wiekszej wartosci, niz koniec. Wybierz co chcesz zrobic: \n");
  483.                                         printf("1) Zamienic liczby miejscami.\n");
  484.                                         printf("2) Zmienic wartosci poczatku i konca przedzialu.\n");
  485.                                         Fn_Zmienna_Przypisz("%d", &wybor);
  486.                                         system("cls");
  487.                                         switch (wybor)
  488.                                         {
  489.                                         case 1:
  490.                                                 ptr = tab_Wspol[koniec];
  491.                                                 tab_Wspol[koniec] = tab_Wspol[poczatek];
  492.                                                 tab_Wspol[poczatek] = ptr;
  493.                                                 break;
  494.                                         case 2:
  495.                                                 Fn_Przypisz("Wpisz minimalna wartosc zaszumienia: ", "%lf", &tab_Warunki[0]);
  496.                                                 Fn_Przypisz("Wpisz maksymalna wartosc zaszumienia: ", "%lf", &tab_Warunki[1]);
  497.                                                 system("cls");
  498.                                                 break;
  499.                                         default:
  500.                                                 printf("Nie ma takiej opcji. Kliknij klawisz enter.\n");
  501.                                                 getchar();
  502.                                                 while (getchar() != '\n');
  503.                                                 system("cls");
  504.                                         }
  505.                                 } while (tab_Warunki[0] > tab_Warunki[1]);
  506.                         }
  507.                         for (x = 0; x < tab_Wspol[ilosc]; x++)
  508.                         {
  509.                                 (*tab_Szum)[x] = tab_Sygnal[x] + tab_Warunki[0] + ((double)rand() / (double)RAND_MAX)*(tab_Warunki[1] - tab_Warunki[0]);
  510.                         }
  511.                         break;
  512.                 case 2:
  513.                         do
  514.                         {
  515.                                
  516.                                 Fn_Przypisz("Wpisz prawdopodobienstwo wystapienia zaszumienia w %%: ", "%lf", &tab_Warunki[0]);
  517.                                 system("cls");
  518.                                 if (tab_Warunki[0] < 0 || tab_Warunki[0] > 100)
  519.                                 {
  520.                                         printf("Prawdopodobienstwo w procentach moze przyjmowac wartosci z zakresu <0;100>. \n");
  521.                                         while (getchar() != '\n');
  522.                                         system("cls");
  523.                                 }
  524.                         } while (tab_Warunki[0] < 0 || tab_Warunki[0] > 100);
  525.                         system("cls");
  526.                         Fn_Przypisz("Wpisz stala wartosc zaszumienia: ", "%lf", &tab_Warunki[1]);
  527.                         for (x = 0; x < tab_Wspol[ilosc]; x++)
  528.                         {
  529.                                 if ((double)rand() / (double)RAND_MAX <= tab_Warunki[0] / 100)
  530.                                 {
  531.                                         (*tab_Szum)[x] = tab_Sygnal[x] + tab_Warunki[1];
  532.                                 }
  533.                                 else
  534.                                 {
  535.                                         (*tab_Szum)[x] = tab_Sygnal[x];
  536.                                 }
  537.                         }
  538.                         system("cls");
  539.                         break;
  540.                 default:
  541.                         printf("Nie ma takiej opcji. Kliknij dowolny przycisk aby wrocic do wyboru.\n");
  542.                         while (getchar() != '\n');
  543.                         system("cls");
  544.                 }
  545.         } while (wybor > 2 || wybor < 0);
  546.  
  547. }
  548.  
  549.  
  550. int Fn_Wyswietl(double *tab_Szum, double *tab_Sygnal, double *tab_Argumenty, double *tab_Wspol)
  551. {
  552.         int wybor = 0;
  553.         int x = 0;
  554.         do
  555.         {
  556.                 if (tab_Sygnal == NULL)
  557.                 {
  558.                         printf("Zanim wyswietlisz sygnal musisz go najpierw wygenerowac.\n");
  559.                         getchar();
  560.                         while (getchar() != '\n');
  561.                         break;
  562.                 }
  563.                 system("cls");
  564.                 printf("Wybierz co chcesz wyswietlic...\n");
  565.                 printf("(1) Sygnal niezaszumiony.\n");
  566.                 printf("(2) Sygnal zaszumiony.\n");
  567.                 printf("(0) Wroc do menu. \n");
  568.                 printf("Twoj wybor: ");
  569.                 Fn_Zmienna_Przypisz("%d", &wybor);
  570.                 system("cls");
  571.                 switch (wybor)
  572.                 {
  573.                 case 0:
  574.                         return 0;
  575.                 case 1:
  576.                         for (x = 0; x < tab_Wspol[ilosc]; x++)
  577.                         {
  578.                                 printf("Sygnal(%0.3lf) = %0.3lf\n", tab_Argumenty[x], tab_Sygnal[x]);
  579.                         }
  580.                         system("pause");
  581.                         break;
  582.                 case 2:
  583.                         if (tab_Szum == NULL)
  584.                         {
  585.                                 printf("Muisz najpierw zaszumic sygnal aby go wyswietlic.\n");
  586.                                 while (getchar() != '\n');
  587.                                 break;
  588.                         }
  589.                         for (x = 0; x < tab_Wspol[ilosc]; x++)
  590.                         {
  591.                                 printf("Szum(%0.3lf) = %0.3lf\n", tab_Argumenty[x], tab_Szum[x]);
  592.                         }
  593.                         system("pause");
  594.                         break;
  595.                 default:
  596.                         printf("Nie ma takiej opcji. Sprobuj ponownie.\n");
  597.                         while (getchar() != '\n');
  598.                 }
  599.         } while ((wybor > 2 || wybor < 0)|| tab_Szum == NULL);
  600. }
  601.        
  602.  
  603. int Fn_Filtr(double *tab_Szum, double **tab_Filtrowana, double *tab_Argumenty, double *tab_Wspol)
  604. {
  605.         int okno = 0;
  606.         int wybor = 0;
  607.         int i = 0;
  608.         do
  609.         {
  610.                 if (tab_Szum == NULL)
  611.                 {
  612.                         printf("Zanim przefiltrujesz sygnal musisz go najpierw zaszumic.\n");
  613.                         getchar();
  614.                         while (getchar() != '\n');
  615.                         break;
  616.                 }
  617.                 free(*tab_Filtrowana);
  618.                 *tab_Filtrowana = (double*)malloc((size_t)tab_Wspol[ilosc] * sizeof(**tab_Filtrowana));
  619.                 system("cls");
  620.                 printf("Z jakiego filtru chcesz skorzystac...\n");
  621.                 printf("(1) Filtr medianowy.\n");
  622.                 printf("(2) Filtr sredniej ruchomej.\n");
  623.                 printf("(0) Wroc do menu. \n");
  624.                 printf("Twoj wybor: ");
  625.                 Fn_Zmienna_Przypisz("%d", &wybor);
  626.                 system("cls");
  627.                 if (wybor == 1 || wybor == 2)
  628.                 {
  629.                         printf("Okno filtra ma szerokosc 2n + 1\nPodaj n: ");
  630.                         do
  631.                         {
  632.                                 if (okno > (tab_Wspol[ilosc] - 1) / 2 || okno < 0)
  633.                                 {
  634.                                         printf("Zle podana wartosc okna!\n");
  635.                                 }
  636.                                 Fn_Zmienna_Przypisz("%d", &okno);
  637.                                
  638.                                
  639.                         } while (okno > (tab_Wspol[ilosc]- 1) / 2 || okno < 0 );
  640.                 }
  641.                
  642.                 switch (wybor)
  643.                 {
  644.                 case 0:
  645.                         return 0;
  646.                 case 1:
  647.                         for (i = 0; i < okno; i++) (*tab_Filtrowana)[i] = tab_Szum[i];
  648.                         for (i = okno; i < tab_Wspol[ilosc] - okno; i++) (*tab_Filtrowana)[i] = Fn_Mediana(tab_Szum,okno, i-okno, i+okno);
  649.                         for (i = tab_Wspol[ilosc] - okno; i < tab_Wspol[ilosc]; i++) (*tab_Filtrowana)[i] = tab_Szum[i];
  650.                         break;
  651.                 case 2:
  652.                         for (i = 0; i < okno; i++) *(tab_Filtrowana)[i] = tab_Szum[i];
  653.                         for (i = okno; i < tab_Wspol[ilosc] - okno; i++) *(tab_Filtrowana)[i] = Fn_Srednia(tab_Szum, okno,i - okno , i + okno);
  654.                         for (i = tab_Wspol[ilosc] - okno; i < tab_Wspol[ilosc]; i++) *(tab_Filtrowana)[i] = tab_Szum[i];
  655.                         break;
  656.                 default:
  657.                         printf("Nie ma takiej opcji. Sprobuj ponownie.\n");
  658.                         while (getchar() != '\n');
  659.                 }
  660.         } while (wybor > 2 || wybor < 0);
  661. }
  662.  
  663.  
  664. double Fn_Babelkowe(double *tab_Pomocnicza, int okno)
  665. {
  666.                 int i, j, temp;
  667.                 for (i = 0; i < okno - 1; i++)
  668.                 {
  669.                         for (j = 0; j < okno - 1 - i; j++)
  670.                         {
  671.                                 if (tab_Pomocnicza[j] > tab_Pomocnicza[j + 1])
  672.                                 {
  673.                                         temp = tab_Pomocnicza[j + 1];
  674.                                         tab_Pomocnicza[j + 1] = tab_Pomocnicza[j];
  675.                                         tab_Pomocnicza[j] = temp;
  676.                                 }
  677.                         }
  678.                 }
  679. }
  680.  
  681.  
  682. double Fn_Mediana(double *tab_Szum, int okno, int poczatek, int koniec)
  683. {
  684.         int i;
  685.         int ile = koniec - poczatek + 1;
  686.         double wartosc = 0;
  687.         double *tab_Pomocnicza = NULL;
  688.         free(tab_Pomocnicza);
  689.         tab_Pomocnicza = (double*)malloc((size_t)okno * sizeof(*tab_Pomocnicza));
  690.         if (tab_Pomocnicza == NULL)
  691.         {
  692.                 printf("Nie udalo sie przydzielic pamieci.\n");
  693.                 while (getchar() != '\n');
  694.                 return 0;
  695.         }
  696.         for (i = 0; i < ile; i++)
  697.         {
  698.                 tab_Pomocnicza[i] = tab_Szum[poczatek + i];
  699.         }
  700.         Fn_Babelkowe(tab_Pomocnicza, okno);
  701.         wartosc = tab_Pomocnicza[ile];
  702.         free(tab_Pomocnicza);
  703.         return wartosc;
  704. }
  705.  
  706.  
  707. double Fn_Srednia(double *tab_Szum, int okno, int poczatek, int koniec)
  708. {
  709.         int i, ile = koniec - poczatek + 1;
  710.         double wynik = 0;
  711.         for (i = 0; i < ile; i++)
  712.         {
  713.                 wynik += tab_Szum[poczatek + i];
  714.         }
  715.         return wynik / ile;
  716. }
  717.  
  718.  
  719. double Fn_Wczytaj(double **tab_Sygnal, double **tab_Szum, double **tab_Filtrowana, double **tab_Argumenty, double *tab_Wspol)
  720. {
  721.         double  *glupia;
  722.         int i = 0;
  723.         int n = 100;
  724.         char *nazwa;
  725.         FILE *plik;
  726.  
  727.         system("cls");
  728.         nazwa = Fn_Pobierz_Nazwe_Pliku();
  729.         if (!nazwa)
  730.         {
  731.                 printf("Nie ma takiego pliku.\n");
  732.                 getchar();
  733.                 getchar();
  734.                 return tab_Wspol[ilosc];
  735.         }
  736.  
  737.         plik = fopen(nazwa, "r");
  738.  
  739.         if (!plik)
  740.         {
  741.                 printf("Nie udalo sie otworzyc pliku.\n");
  742.                 free(nazwa);
  743.                 getchar();
  744.                 getchar();
  745.                 return tab_Wspol[ilosc];
  746.         }
  747.  
  748.         free(*tab_Sygnal);
  749.        
  750.         if (*tab_Szum)
  751.         {
  752.                 free(*tab_Szum);
  753.                 *tab_Szum = NULL;
  754.         }
  755.  
  756.         if (*tab_Filtrowana)
  757.         {
  758.                 free(*tab_Filtrowana);
  759.                 *tab_Filtrowana = NULL;
  760.         }
  761.  
  762.         if (*tab_Argumenty)
  763.         {
  764.                 free(*tab_Argumenty);
  765.                 *tab_Argumenty = NULL;
  766.         }
  767.  
  768.  
  769.         *tab_Sygnal = (double*)malloc(n * sizeof(double));
  770.         *tab_Argumenty = (double*)malloc(n * sizeof(double));
  771.  
  772.         if (!(*tab_Sygnal) || !(*tab_Argumenty))
  773.         {
  774.                 free(*tab_Sygnal);
  775.                 free(*tab_Argumenty);
  776.                 free(nazwa);
  777.                 printf("Jestesmy tutaj\n");
  778.                 printf("Nie udalo sie przydzielic pamieci.\n");
  779.                 getchar();
  780.                 getchar();
  781.                 return 0;
  782.         }
  783.  
  784.         while (1)
  785.         {
  786.                 if (fscanf(plik, "%lf;%lf \n", &(*tab_Argumenty)[i], &(*tab_Sygnal)[i]) == EOF)
  787.                 {
  788.                         glupia = *tab_Sygnal;
  789.                         *tab_Sygnal = (double*)realloc(*tab_Sygnal, n * sizeof(double));
  790.                         if (!(*tab_Sygnal))
  791.                         {
  792.                                 free(glupia);
  793.                                 free(nazwa);
  794.                                 free(*tab_Argumenty);
  795.                                 printf("Jestesmy tutaj 2\n");
  796.                                 printf("Nie udalo sie przydzielic pamieci.\n");
  797.  
  798.                                 getchar();
  799.                                 getchar();
  800.                                 return 0;
  801.                         }
  802.                         glupia = *tab_Argumenty;
  803.                         *tab_Argumenty = (double*)realloc(*tab_Argumenty, n * sizeof(double));
  804.                         if (!(*tab_Argumenty))
  805.                         {
  806.                                 free(glupia);
  807.                                 free(nazwa);
  808.                                 free(*tab_Sygnal);
  809.                                 printf("Jestesmy tutaj 3\n");
  810.                                 printf("Nie udalo sie przydzielic pamieci.\n");
  811.                                 getchar();
  812.                                 getchar();
  813.                                 return 0;
  814.                         }
  815.                         free(nazwa);
  816.                         return 0;
  817.                 }
  818.  
  819.                 i++;
  820.  
  821.                 if (i >= n)
  822.                 {
  823.                         glupia = *tab_Sygnal;
  824.                         *tab_Sygnal = (double*)realloc(*tab_Sygnal, n * sizeof(double));
  825.                         if (!(*tab_Sygnal))
  826.                         {
  827.                                 free(glupia);
  828.                                 free(nazwa);
  829.                                 free(*tab_Argumenty);
  830.                                 printf("Jestesmy tutaj 4\n");
  831.                                 printf("Nie udalo sie przydzielic pamieci.\n");
  832.                                 getchar();
  833.                                 getchar();
  834.                                 return 0;
  835.                         }
  836.                         glupia = *tab_Argumenty;
  837.                         *tab_Argumenty = (double*)realloc(*tab_Argumenty, n * sizeof(double));
  838.                         if (!(*tab_Argumenty))
  839.                         {
  840.                                 free(glupia);
  841.                                 free(nazwa);
  842.                                 free(*tab_Sygnal);
  843.                                 printf("Jestesmy tutaj 5\n");
  844.                                 printf("Nie udalo sie przydzielic pamieci.\n");
  845.                                 getchar();
  846.                                 getchar();
  847.                                 return 0;
  848.                         }
  849.                         n += n;
  850.                 }
  851.         }
  852. }
  853.  
  854.  
  855. char* Fn_Pobierz_Nazwe_Pliku(void)
  856. {
  857.         char *tab;
  858.         char *tab2;
  859.         int wybor;
  860.         int i = 4;
  861.         int n = 30;
  862.  
  863.         tab = (char*)malloc(n * sizeof(char));
  864.  
  865.         if (!tab)
  866.         {
  867.                 printf("Nie udalo sie przydzielic pamieci.\n");
  868.                 getchar();
  869.                 getchar();
  870.                 return NULL;
  871.         }
  872.         printf("Podaj nazwe pliku (bez rozszerzenia): ");
  873.         getchar();
  874.  
  875.         do
  876.         {
  877.                 if (i + 1 >= n)
  878.                 {
  879.                         tab2 = tab;
  880.                         tab = (char*)realloc(tab, n * sizeof(char));
  881.                         n += n;
  882.                         if (!tab)
  883.                         {
  884.                                 printf("Nie udalo sie przydzielic pamieci dla nazwy.\n");
  885.                                 getchar();
  886.                                 getchar();
  887.                                 free(tab2);
  888.                                 return NULL;
  889.                         }
  890.                 }
  891.                 tab[i - 4] = getchar();
  892.                 if (tab[i -4] == ' ')
  893.                 {
  894.                         tab[i - 4] = '_';
  895.                 }
  896.                
  897.                 i++;
  898.         } while (tab[i - 5] != '\n');
  899.  
  900.         tab[i - 5] = 0;
  901.         do
  902.         {
  903.                 system("cls");
  904.                 printf("Wybierz rozszerzenie takiego pliku. \n");
  905.                 printf("(1) .txt (plik tekstowy)\n");
  906.                 printf("(2) .csv (arkusz kalkulacyjny)\n");
  907.                 printf("Twoj wybor: ");
  908.                 Fn_Zmienna_Przypisz("%d", &wybor);
  909.                 switch (wybor)
  910.                 {
  911.                 case 1:
  912.                         strcat(tab, ".txt");
  913.                         break;
  914.                 case 2:
  915.                         strcat(tab, ".csv");
  916.                         break;
  917.                 default:
  918.                         system("cls");
  919.                         printf("Nie ma takiej opcji.\n");
  920.                         getchar();
  921.                 }
  922.         } while (wybor > 2 || wybor < 1);
  923.  
  924.         return tab;
  925. }
  926.  

Reply to "coś"