obrona projektu 1

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>


void pobierzwspolczynniki(double wspolczynniki[])
{
 printf("Podaj A: \n");
 scanf("%lf", &wspolczynniki[0]);
 do {
  printf("Podaj B (rozne od 0): \n");
  scanf("%lf", &wspolczynniki[1]);
  if (wspolczynniki[1] == 0) {
   printf("Blad! Wspolczynnik B jest w mianowniku, wiec nie moze wynosic 0.\n");
  }
 } while (wspolczynniki[1] == 0);
 printf("Podaj C: \n");
 scanf("%lf", &wspolczynniki[2]);
 printf("Podaj D: \n");
 scanf("%lf", &wspolczynniki[3]);
}
void generujsygnal(double x_min, double x_max, double wspolczynniki[], double sygnal[], int rozmiar)
{
 double delta = (x_max - x_min) / rozmiar;
 for (int i = 0; i < rozmiar; i++)
 {
  double x = x_min + i * delta;
  sygnal = wspolczynniki[0] * sin((x + wspolczynniki[2]) / wspolczynniki[1]) + wspolczynniki[3];
 }

}
void pobierzdziedzine(double* x_min, double* x_max)
{
 do {
  printf("Podaj poczatek dziedziny (x_min): ");
  scanf("%lf", x_min);
  printf("Podaj koniec dziedziny (x_max): ");
  scanf("%lf", x_max);

  if (*x_min >= *x_max) {
   printf("Blad! Poczatek dziedziny (x_min) musi byc mniejszy niz jej koniec (x_max).\n\n");
  }
 } while (*x_min >= *x_max);
}

void wyswietlsygnal(int rozmiar, double sygnal[])
{
 for (int j = 0; j < rozmiar; j++)
 {
  printf("sygnal nr .%d = %lf\n", j, sygnal[j]);
 }
}

void zapiszdoCSV(int rozmiar, double sygnal[], const char* sygnal1)
{
 FILE* plik = fopen(sygnal1, "w");
 if (plik == NULL)
 {
  printf("Blad otwarcia pliku do zapisu \n");
  return;
 }
 for (int i = 0; i < rozmiar; i++)
 {
  fprintf(plik, "%lf\n", sygnal);
 }
 fclose(plik);
 printf("Zapisano sygnal do pliku %s.\n", sygnal1);
}

int pobierzrozmiar()
{
 int rozmiar;
 do
 {
  printf("Podaj wielkość tablicy z sygnalem(liczbe probek >0):\n");
  scanf("%d", &rozmiar);
  if (rozmiar <= 0)
  {
   printf("Blad, rozmiar musi byc wiekszy od 0");

  }
 } while (rozmiar <= 0);
 return rozmiar;
}

void zaszumsygnal(double sygnal_podst[], double sygnal_zaszumiony[], int rozmiar, double max_amp_szumu, int prawdopodobienstwo)
{
 for (int i = 0; i < rozmiar; i++)
 {
  if ((rand() % 100) < prawdopodobienstwo)
  {
   double szum = ((double)rand() / RAND_MAX) * (2.0 * max_amp_szumu) - max_amp_szumu;
   sygnal_zaszumiony = sygnal_podst + szum;
  }
  else
  {
   sygnal_zaszumiony = sygnal_podst;
  }
 }
}
int main()
{
 setlocale(LC_ALL, "polish_poland");
 double wspolczynniki[4];
 double x_min;
 double x_max;
 int rozmiar = 0;
 srand(time(NULL));
 double* sygnal = NULL;
 double* sygnal_zaszumiony = NULL;
 int czy_podstawowy = 0;
 int czy_zaszumiony = 0;
 int menu = -1;
 while (menu != 0)
 {
  printf("==========MENU==========\n");
  printf("1. Generowanie sygnału podstawowego\n");
  printf("2. Wprowadzenie szumu do sygnalu\n");
  printf("3. Wyswietl sygnal na ekranie\n");
  printf("4. Zapisz do CSV\n");
  printf("0. Zakończenie programu \n");
  scanf("%d", &menu);
  switch (menu)
  {
  case 0:
   printf("Zakończenie programu. \n");
   break;
  case 1:
   if (sygnal != NULL)  free(sygnal);
   if (sygnal_zaszumiony != NULL) free(sygnal_zaszumiony);
   rozmiar = pobierzrozmiar();
   sygnal = (double*)malloc(rozmiar * sizeof(double));
   sygnal_zaszumiony = (double*)malloc(rozmiar * sizeof(double));
   pobierzwspolczynniki(wspolczynniki);
   pobierzdziedzine(&x_min, &x_max);
   generujsygnal(x_min, x_max, wspolczynniki, sygnal, rozmiar);
   czy_podstawowy = 1;
   czy_zaszumiony = 0;
   printf("Wygenerowano sygnal podstawowy.\n");
   break;
  case 2:
   if (!czy_podstawowy)
   {
    printf("Blad. Najpierw wygeneruj sygnal");
   }
   else
   {
    double max_amp = 0.5 * fabs(wspolczynniki[0]);
    int prawd = 30;
    printf("ustalono maksymalna amplitude szumu na 0,5 * |A| = %lf\n", max_amp);
    zaszumsygnal(sygnal, sygnal_zaszumiony, rozmiar, max_amp, prawd);
    czy_zaszumiony = 1;
    printf("Wprowadzono szum do sygnalu\n");
   }
   break;
  case 3:
   if (!czy_podstawowy)
   {
    printf("Brak sygnalu do wyswietlania! Najpierw wygeneruj sygnal");
   }
   else
   {
    int wybor_wysw;
    printf("ktory sygnal wyswietlic? 1 - podstawowy, 2 - zaszumiony");
    scanf("%d", &wybor_wysw);
    if (wybor_wysw == 1)
    {
     wyswietlsygnal(rozmiar, sygnal);
    }
    else
    {
     if (wybor_wysw == 2 && czy_zaszumiony)
     {
      wyswietlsygnal(rozmiar, sygnal_zaszumiony);
     }
     else
     {
      printf("Wybrany sygnal nie jest jeszcze dostepny\n");
     }
    }
    break;
   }

  case 4:
   if (!czy_podstawowy)
   {
    printf("Brak danych do zapisu. Najpierw wygeneruj sygnal");
   }
   else
   {
    int wybor_zapisu;
    printf("ktory sygnal zapisac?\n");
    printf("1. sygnal podstawowy\n");
    printf("2. sygnal zaszumiony\n");
    printf("twój wybor: ");
    scanf("%d", &wybor_zapisu);
    if (wybor_zapisu == 1)
    {
     zapiszdoCSV(rozmiar, sygnal, "sygnal_podstawowy.csv");
    }
    else if (wybor_zapisu == 2)
    {
     if (czy_zaszumiony)
      zapiszdoCSV(rozmiar, sygnal_zaszumiony, "sygnal_zaszumiony.csv");
     else
      printf("Blad. Sygnal nie zostal jeszcze zaszumiony");
    }
    else
    {
     printf("Nieprawidlowy wybor zapisu.\n");
    }
   }
   break;
   if (sygnal != NULL) free(sygnal);
   if (sygnal_zaszumiony != NULL) free(sygnal_zaszumiony);
  }

 }
 return 0;
}

Jskakzbs

wprowadz do programu możliwość obcięcia początkowej części sygnalu odfiltrowanego i poostawienie probek od N do ostatniej, gdzie N podac ma użytkownik. Tablica dynamiczna skróconego sygnału powinna być dopasowana do niego rozmiarem. Zrealizuj zadanie w osobnej funkcji i wprowadz ozliwosc wywolania jej z menu. dla uproszczenia możesz przyjąć ze alokacja pamięci odbędzie się w main().

noea funkcja przed main

void obetnij_sygnal(double sygnal_we[], double sygnal_wy[], int rozmiar, int N)
{
 for (int i = N; i < rozmiar; i++)
 {
  sygnal_wy = sygnal_we;
 }
}

na poczatku main nowa zmienne

 double* sygnal_skrocony = NULL;
 int rozmiar_skrocony = 0;
 int czy_skrocony = 0;
 int N = 0;


modyfikacja menu w while

  printf("==========MENU==========\n");
  printf("1. Generowanie sygnału podstawowego\n");
  printf("2. Wprowadzenie szumu do sygnalu\n");
  printf("3. Wyswietl sygnal na ekranie\n");
  printf("4. Zapisz do CSV\n");
  printf("5. Obciecie sygnalu\n"); // DODANO
  printf("0. Zakończenie programu \n");


w case 1

  case 1:
   if (sygnal != NULL)  free(sygnal);
   if (sygnal_zaszumiony != NULL) free(sygnal_zaszumiony);
   if (sygnal_skrocony != NULL) { free(sygnal_skrocony); sygnal_skrocony = NULL; czy_skrocony = 0; } // DODANO


nowy case


  case 5:
   // Uwaga: w kodzie bazowym brak sygnału odfiltrowanego,
   // funkcja obcina sygnał zaszumiony (jeśli istnieje) lub podstawowy.
   if (!czy_podstawowy)
   {
    printf("Blad. Najpierw wygeneruj sygnal\n");
   }
   else
   {
    do {
     printf("Podaj probke N (od 0 do %d), od ktorej chcesz zostawic sygnal: ", rozmiar - 1);
     scanf("%d", &N);
     if (N < 0 || N >= rozmiar) {
      printf("Blad! N musi byc z przedzialu <0, %d>.\n", rozmiar - 1);
     }
    } while (N < 0 || N >= rozmiar);

    rozmiar_skrocony = rozmiar - N;
   
    if (sygnal_skrocony != NULL) free(sygnal_skrocony);
    sygnal_skrocony = (double*)malloc(rozmiar_skrocony * sizeof(double));

    if (czy_zaszumiony) {
     obetnij_sygnal(sygnal_zaszumiony, sygnal_skrocony, rozmiar, N);
    } else {
     obetnij_sygnal(sygnal, sygnal_skrocony, rozmiar, N);
    }
   
    czy_skrocony = 1;
    printf("Zrealizowano obciecie. Nowy rozmiar sygnalu: %d\n", rozmiar_skrocony);
   }
   break;

na joncu main przed return 0 i usunac wczesniejsze bledne free

 } // Koniec pętli while(menu != 0)

 if (sygnal != NULL) free(sygnal);
 if (sygnal_zaszumiony != NULL) free(sygnal_zaszumiony);
 if (sygnal_skrocony != NULL) free(sygnal_skrocony);

 return 0;

poprawiony case

  case 5:
   if (!czy_podstawowy)
   {
    printf("Blad. Najpierw wygeneruj sygnal\n");
   }
   else
   {
    do {
     printf("Podaj probke N (od 0 do %d), od ktorej chcesz zostawic sygnal: ", rozmiar - 1);
     scanf("%d", &N);
     if (N < 0 || N >= rozmiar) {
      printf("Blad! N musi byc z przedzialu <0, %d>.\n", rozmiar - 1);
     }
    } while (N < 0 || N >= rozmiar);

    rozmiar_skrocony = rozmiar - N;
   
    if (sygnal_skrocony != NULL) free(sygnal_skrocony);
    sygnal_skrocony = (double*)malloc(rozmiar_skrocony * sizeof(double));

    // Obcinanie wyłącznie sygnału podstawowego:
    obetnij_sygnal(sygnal, sygnal_skrocony, rozmiar, N);
   
    czy_skrocony = 1;
    printf("Zrealizowano obciecie sygnalu podstawowego. Nowy rozmiar: %d\n", rozmiar_skrocony);
   }
   break;