Wybierz kod:

#include <windows.h>
#include <stdio.h>
#include <process.h>
#include <math.h>
#define _USE_MATH_DEFINES
#define DOKLADNOSC 0.000001
unsigned __stdcall pole_prostokata(void* dlugosci_bokow);

typedef struct _wymiary {
    char * nazwa;
    double pocz;
    double koc;
} WYMIARY;
CRITICAL_SECTION sekcja_krytyczna;

int main() {
    WYMIARY przedzial_A, przedzial_B, przedzial_C;
    unsigned int Identyfikator_watku[3];
    HANDLE hWatki[3];
    char tab1[] = "pa";
    char tab2[] = "pb";
    char tab3[] = "pc";
    printf("\nObliczanie pola prostokatow\n");
    przedzial_A.koc = -1;
    przedzial_A.pocz = -10000000;
    przedzial_A.nazwa = tab1;
    przedzial_B.koc = 0.5;
    przedzial_B.pocz = -0.5;
    przedzial_B.nazwa = tab2;
    przedzial_C.koc = 100;
    przedzial_C.pocz = 1;
    przedzial_C.nazwa = tab3;

    InitializeCriticalSection(&sekcja_krytyczna);

    hWatki[0] = (HANDLE)_beginthreadex(NULL, 0, pole_prostokata, (void*)&przedzial_A, 0, &Identyfikator_watku[0]);
    hWatki[1] = (HANDLE)_beginthreadex(NULL, 0, pole_prostokata, (void*)&przedzial_B, 0, &Identyfikator_watku[1]);
    hWatki[2] = (HANDLE)_beginthreadex(NULL, 0, pole_prostokata, (void*)&przedzial_C, 0, &Identyfikator_watku[2]);

    WaitForMultipleObjects(3, hWatki, TRUE, INFINITE);
    printf("\nObliczenia zostaly zakonczone\n");

    CloseHandle(hWatki[0]);
    CloseHandle(hWatki[1]);
    CloseHandle(hWatki[2]);

    DeleteCriticalSection(&sekcja_krytyczna);
    return 0;
}

double bisekcja(double x) {
    return x * x * x * x * x + 3 * x * x * x - 7 * x + 1;
}

unsigned __stdcall pole_prostokata(void* dlugosci_bokow) {
    WYMIARY* wsk = (WYMIARY*)dlugosci_bokow;
    double a = wsk->pocz;
    double c = a;
    double b = wsk->koc;
    double d = b;
    char* tekst = wsk->nazwa;
    double srod = (a + b) / 2;
    while (fabs(bisekcja(srod)) >= DOKLADNOSC) {
        srod = (a + b) / 2;
        if (bisekcja(a) * bisekcja(srod) < 0) {
            b = srod;
        } else {
            a = srod;
        }
    }

    EnterCriticalSection(&sekcja_krytyczna);
    printf("\n %s Dla przedzialu a= %f b= %f miejsce zerowe wynosi %f\n",tekst,c,d, srod);
    LeaveCriticalSection(&sekcja_krytyczna);
    _endthreadex(0);
    return 0;
};
            

            #include <windows.h>
            #include <stdio.h>
            #include <math.h>
            
            #define DOKLADNOSC 0.000001
            
            typedef struct _wymiary {
                char* nazwa;
                double pocz;
                double koc;
            } WYMIARY;
            
            CRITICAL_SECTION sekcja_krytyczna;
            
            double bisekcja(double x) {
                return x * x * x * x * x + 3 * x * x * x - 7 * x + 1;
            }
            
            DWORD WINAPI pole_prostokata(LPVOID lpParam) {
                WYMIARY* wsk = (WYMIARY*)lpParam;
                double a = wsk->pocz;
                double b = wsk->koc;
                double srod = (a + b) / 2;
            
                while (fabs(bisekcja(srod)) >= DOKLADNOSC) {
                    srod = (a + b) / 2;
                    if (bisekcja(a) * bisekcja(srod) < 0) {
                        b = srod;
                    }
                    else {
                        a = srod;
                    }
                }
            
                EnterCriticalSection(&sekcja_krytyczna);
                printf("\n %s Dla przedziału a= %f b= %f miejsce zerowe wynosi %f\n", wsk->nazwa, wsk->pocz, wsk->koc, srod);
                LeaveCriticalSection(&sekcja_krytyczna);
            
                return 0;
            }
            
            int main() {
                HANDLE hWatki[3];
                WYMIARY przedzial_A, przedzial_B, przedzial_C;
            
                char tab1[] = "pa";
                char tab2[] = "pb";
                char tab3[] = "pc";
            
                przedzial_A.koc = -1;
                przedzial_A.pocz = -10000000;
                przedzial_A.nazwa = tab1;
            
                przedzial_B.koc = 0.5;
                przedzial_B.pocz = -0.5;
                przedzial_B.nazwa = tab2;
            
                przedzial_C.koc = 100;
                przedzial_C.pocz = 1;
                przedzial_C.nazwa = tab3;
            
                InitializeCriticalSection(&sekcja_krytyczna);
            
                hWatki[0] = CreateThread(NULL, 0, pole_prostokata, (LPVOID)&przedzial_A, 0, NULL);
                hWatki[1] = CreateThread(NULL, 0, pole_prostokata, (LPVOID)&przedzial_B, 0, NULL);
                hWatki[2] = CreateThread(NULL, 0, pole_prostokata, (LPVOID)&przedzial_C, 0, NULL);
            
                WaitForMultipleObjects(3, hWatki, TRUE, INFINITE);
                printf("\nObliczenia zostały zakończone\n");
            
                CloseHandle(hWatki[0]);
                CloseHandle(hWatki[1]);
                CloseHandle(hWatki[2]);
            
                DeleteCriticalSection(&sekcja_krytyczna);
            
                return 0;
            }
    

            #include <windows.h>
            #include <stdio.h>
            #include <process.h>
            #include <math.h>
            #define _USE_MATH_DEFINES
            #define DOKLADNOSC 0.000001
            
            struct granice
            {
                double a;
                double b;
            };
            
            unsigned __stdcall znajdz_miejsce_zerowe(void *granice);
            
            CRITICAL_SECTION sekcja_krytyczna;
            
            int main()
            {
                struct granice przedzial_A, przedzial_B, przedzial_C;
                unsigned int Identyfikator_watku[3];
                HANDLE hWatki[3];
            
                printf("Wyznaczanie miejsc zerowych funkcji\n\n");
            
                przedzial_A.a = -2;
                przedzial_A.b = -1;
            
                przedzial_B.a = -1;
                przedzial_B.b = 1;
            
                przedzial_C.a = 1;
                przedzial_C.b = 2;
            
                InitializeCriticalSection(&sekcja_krytyczna);
            
                hWatki[0] = (HANDLE)_beginthreadex(NULL, 0, znajdz_miejsce_zerowe, (void *)&przedzial_A, 0, &Identyfikator_watku[0]);
                hWatki[1] = (HANDLE)_beginthreadex(NULL, 0, znajdz_miejsce_zerowe, (void *)&przedzial_B, 0, &Identyfikator_watku[1]);
                hWatki[2] = (HANDLE)_beginthreadex(NULL, 0, znajdz_miejsce_zerowe, (void *)&przedzial_C, 0, &Identyfikator_watku[2]);
            
                WaitForMultipleObjects(3, hWatki, TRUE, INFINITE);
            
                CloseHandle(hWatki[0]);
                CloseHandle(hWatki[1]);
                CloseHandle(hWatki[2]);
            
                DeleteCriticalSection(&sekcja_krytyczna);
            
                printf("\nObliczenia zostaly zakonczone\n");
                return 0;
            }
            
            double funkcja(double x)
            {
                return x * x * x * x * x + 3 * x * x * x - 7 * x + 1;
            }
            
            unsigned __stdcall znajdz_miejsce_zerowe(void *granice)
            {
                struct granice *granice_ptr = (struct granice *)granice;
                double a = granice_ptr->a;
                double b = granice_ptr->b;
            
                double mid = (a + b) / 2;
            
                while (fabs(funkcja(mid)) > DOKLADNOSC)
                {
                    mid = (a + b) / 2;
                    if (funkcja(a) * funkcja(mid) < 0)
                    {
                        b = mid;
                    }
                    else
                    {
                        a = mid;
                    }
                }
            
                EnterCriticalSection(&sekcja_krytyczna);
                printf("Miejsce zerowe w przedziale [%f, %f] wynosi %f \n", granice_ptr->a, granice_ptr->b, mid);
                LeaveCriticalSection(&sekcja_krytyczna);
            
                _endthreadex(0);
                return 0;
            }