Decadimento particellare relativistico (corretto)

// Coded by Hashbang
/*
1
VALORI DI RIFERIMENTO:
Muoni:
    tempo decadimento:      2.2 (10^-6 s)
    spessore atmosfera:     70000 (metri)
    velocità:               0.999c
*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <math.h>
#include <time.h>

#define C 299792458

long double input(long double min, long double max);
long double motoUnifAcc(long double a, long double v, long double t);
long double motoUniforme(long double v, long double t);
long double randExp(long double tau);
long double dilatazioneTempo(long double tau, long double beta);
// thread
void *parallela(void *parametri);
void *status_thread;

long long int contaParticelle0 = 0;
long long int contaParticelle1 = 0;

// argomenti passati al thread
struct struttura{
    long long int N;
    long double tau;
    long double beta;
    long double D;
};

int main(){
    long long int N, i, contaParticelle = 0;
    long double tau0, beta, D, tau, t_vita, Dx;
    long double frazione;
    // ho un dualcore --> inizializzo solo un thread
    pthread_t thread_1;

    printf("\nQuesto programma simula il decadimento di N particelle che si muovono a velocita' relativistiche.\n\n");

    printf("Inserisci il numero di particelle: ");
    // N sempre pari --> meno cazzi per dividere il calcolo
    N = input(1,1E15);
    if(N%2 != 0){
        --N;
    }

    printf("Inserisci la vita media delle particelle (in microsecondi): ");
    tau0 = input(1,1E12) * 1E-6;

    printf("Inserisci la velocita' delle particelle (frazione di c): ");
    beta = input(0,1);

    printf("Inserisci la distanza che le particelle devono percorrere (in metri): ");
    D = input(0,1E12);

    printf("\nCalcolo...\n");

    tau = dilatazioneTempo(tau0,beta);

    // passo gli argomenti alla struttura degli argomenti del thread
    struct struttura argomenti_thread;
    argomenti_thread.N = N;
    argomenti_thread.tau = tau;
    argomenti_thread.beta = beta;
    argomenti_thread.D = D;

    // esecuzione parallela al main e controllo
    int errore = pthread_create(&thread_1,NULL,parallela,&argomenti_thread);
    if(errore){
        printf("\nNon posso creare il thread per l'errore %d\n\n",errore);
        exit(1);
    }

    srand48(time(0));

    // esecuzione del main
    for(i=0; i<N/2; i++){
        t_vita = randExp(tau);
        Dx = motoUniforme(beta*C,t_vita);
        if(Dx > D){
            contaParticelle0++;
        }
    }

    pthread_join(thread_1,status_thread);

    contaParticelle = contaParticelle0 + contaParticelle1;
    frazione = (long double)contaParticelle / (long double)N;

    printf("\nIl %.5llf%% delle particelle hanno superato %.2llf metri.\n\n",frazione*100,D);

    return 0;
}

void *parallela(void *parametri){
    long long int i;
    long double t_vita, Dx;

    srand48(time(0));

    struct struttura* dati = (struct struttura *) parametri;

    for(i=0; i<(dati->N)/2; i++){
        t_vita = randExp(dati->tau);
        Dx = motoUniforme(dati->beta*C,t_vita);
        if(Dx > dati->D){
            contaParticelle1++;
        }
    }

    pthread_exit((void *)&status_thread);
}

long double input(long double min, long double max){
    // prende un numero da tastiera che sia compreso in [min, max[
    long double x;

    do {
        scanf("%llf",&x);
        if(!(min <= x && x < max)){
            printf("Il numero deve essere compreso tra %.3llf e %.3llf.\nRiprova: ",min,max);
        }
    }while(!(min <= x && x < max));

    return x;
}

long double motoUnifAcc(long double a, long double v, long double t){
    return v*t+0.5*a*t*t;
}

long double motoUniforme(long double v, long double t){
    return motoUnifAcc(0,v,t);
}

long double randExp(long double tau){
    // genera un numero casuale secondo la distribuzione e^-(t/tau)
    long double G = ((long double)lrand48()+1)/((long double)RAND_MAX+1);
    return -tau*log(G);
}

long double dilatazioneTempo(long double tau, long double beta){
    return tau/sqrt(1-beta*beta);
}