Kombinačné čísla

#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define BUFFER_SIZE 20
#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))

struct pair
{
    unsigned number1;
    unsigned number2;
};

struct shared_data
{
    unsigned a;
    unsigned b;
    unsigned n;

    volatile struct pair* pairs;
    volatile unsigned current;

    pthread_mutex_t* mutex;
    pthread_cond_t* condConsumer;
};

struct pair generate_pair(unsigned a, unsigned b)
{
    struct pair couple;

    unsigned modulo = b - a + 1;
    couple.number1 = rand() % modulo + 1;
    couple.number2 = rand() % modulo + 1;

    return couple;
}

void* gen_pair_numbers(void* tdata)
{
    struct shared_data* data = (struct shared_data*) tdata;
    printf("START OF GENERATING PAIRS THREAD\n");

    int i = 0;
    while (i < data->n)
    {
        struct pair couple = generate_pair(data->a, data->b);

        pthread_mutex_lock(data->mutex);
        if (data->current < BUFFER_SIZE)
        {
            data->pairs[data->current++] = couple;
            i++;
        }

        if (data->current >= BUFFER_SIZE || i >= data->n)
        {
            pthread_cond_signal(data->condConsumer);
        }
        pthread_mutex_unlock(data->mutex);
    }

    printf("END OF GENERATING PAIRS THREAD\n");
    return NULL;
}

unsigned factorial(unsigned number)
{
    return number < 2 ? 1 : number * factorial(number - 1);
}

unsigned calculate_combination(struct pair couple)
{
    unsigned min = MIN(couple.number1, couple.number2);
    unsigned max = MAX(couple.number1, couple.number2);

    return factorial(max)/(factorial(min) * factorial(max - min));
}

int main(int argc, char** argv)
{
    if (argc < 4)
    {
        printf("Wrong number of parameters.\n");
        printf("Neccessary parameters:\n");
        printf("  a - low bound of interval\n");
        printf("  b - high bound of interval\n");
        printf("  n - number of combinations\n");

        return EXIT_FAILURE;
    }

    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, NULL);

    pthread_cond_t condConsumer;
    pthread_cond_init(&condConsumer, NULL);

    unsigned a = atoi(argv[1]);
    unsigned b = atoi(argv[2]);
    unsigned n = atoi(argv[3]);

    struct shared_data data = {
        a,
        b,
        n,
        (struct pair*) malloc(BUFFER_SIZE * sizeof(struct pair)),
        0,
        &mutex,
        &condConsumer
    };

    pthread_t generate_thread;
    pthread_create(&generate_thread, NULL, &gen_pair_numbers, &data);

    // Implementation
    int i = 0;

    while (i < data.n)
    {
        pthread_mutex_lock(&mutex);
        while (data.current == 0)
        {
            pthread_cond_wait(&condConsumer, &mutex);
        }
        pthread_mutex_unlock(&mutex);

        pthread_mutex_lock(&mutex);
        struct pair couple = data.pairs[--(data.current)];
        //printf("current: %u\n", data.current);
        pthread_mutex_unlock(&mutex);

        i++;
        unsigned result = calculate_combination(couple);
        printf("%d: comb(%u, %u) = %u\n", i, couple.number1, couple.number2, result);
    }

    pthread_join(generate_thread, NULL);
    pthread_cond_destroy(&condConsumer);
    pthread_mutex_destroy(&mutex);
    free((void*) data.pairs);

    return EXIT_SUCCESS;
}