Facebook

coś2 safest cryptocurrency exchange

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

Reply to "coś2"