//eliminare accenti
//controllare indentazione

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

double *inserisci_insieme(int *);

double **inserisci_operazione(double *,
                              int,
                              char *);

int **inserisci_relazione(double *,
                          int);

int cerca_elemento(double,
                   double *,
                   int);

int valuta_chiusura(double **,
                    double *,
                    int,
                    char);

int valuta_equivalenza(int **,
                       int);

int valuta_riflessiva(int **,
                      int);

int valuta_simmetrica(int **,
                      int);

int valuta_transitiva(int **,
                      int);

void valuta_congruenza(int **,
                       double **,
                       int,
                       char);

int main(void)
{
    /*Variabili locali alla funzione main*/
    double  *insieme,       /*Array che conterra' gli elementi dell'insieme*/
            **operazione;   /*Array multi-dimensionale che servira' a definire
                            l'operazione - contiene i risultati ottenuti
                            applicando l'operazione ad ogni coppia ordinata
                            dell'insieme - mantiene un'associazione con l'insieme
                            tramite gli stessi indici*/

    int     cardinalita,    /*Cardinalita' dell'insieme, serve per definire il
                            numero di elementi degli array*/
            **relazione;    /*Array multi-dimensionale che servira' a definire
                            la relazione - ogni elemento assume valore 1 se gli
                            elementi associati sono in relazione, 0 altrimenti -
                            mantiene un'associazione con l'insieme tramite gli
                            stessi indici*/

    char    op,             /*Carattere che serve a memorizzare il simbolo
                            associato all'operazione*/
            non_letto;      /*Variabile di lavoro che serve a svuotare il
                            buffer di lettura*/

    /* Inizio Progetto */
    printf("\nProgetto di Programmazione Procedurale e Logica");
    printf("di Gianluca Bonifazi - Matricola 261989 - 2014/2015\n");

    /* Funzione che acquisisce l'insieme */
    insieme = inserisci_insieme(&cardinalita);

    /* Funzione che acquisisce l'operazione */
    operazione = inserisci_operazione(insieme,
                                      cardinalita,
                                      &op);

    /* Funzione che acquisisce la relazione */
    relazione = inserisci_relazione(insieme,
                                    cardinalita);

    /*Valutazione di chiusura e congruenza*/
    printf("\nValutazione in corso...\n");
    if(valuta_chiusura(operazione, insieme, cardinalita, op))
    {
        if(valuta_equivalenza(relazione, cardinalita))
            valuta_congruenza(relazione, operazione, cardinalita, op);
    }
    else
    {
        printf("\nATTENZIONE: la relazione inserita NON e' una congruenza");
        printf(" rispetto all'operazione %c\n",
                op);
    }

    /*Svuoto il buffer di lettura*/
    do
        non_letto = getchar();
    while (non_letto != '\n');

    printf("\n\nEsecuzione terminata.\n Premere un tasto per uscire: ");
    getchar();

    return (0);
}


/*La funzione prende in input una variabile passata per indirizzo all'interno
della quale verra' memorizzato il valore della cardinalita' dell'insieme*/
/*Restituisce un puntatore all'array che memorizza gli elementi dell'insieme*/
double *inserisci_insieme(int *n)
{
    double  *a;                 /*Array che conterra' gli elementi dell'insieme*/

    int     i,                  /*Variabile di lavoro - cicli*/
            esito_lettura,      /*Variabile di lavoro - validazione*/
            insieme_corretto;   /*Variabile di lavoro - cicli e validazione*/

    char    carattere_non_letto; /*Variabile di lavoro - validazione*/

    do
    {
        /* Si chiede all'utente di definire la cardinalita' dell'insieme */
        /* L'acquisizione del valore e' soggetta a validazione stretta */
        do
        {
            printf("\nDigitare la cardinalità dell'insieme: ");
            esito_lettura = scanf("%d",
                                  n);

            if (esito_lettura != 1 || *n < 0)
                do
                    carattere_non_letto = getchar();
                while (carattere_non_letto != '\n');
        }
        while (esito_lettura != 1 || *n < 0);

        /* Alloco dinamicamente un array della dimensione scelta */
        a = (double *) calloc(*n,
                              sizeof(double));

        /* Si chiede all'utente di digitare gli elementi dell'insieme */
        /* L'acquisizione del valore e' soggetta a validazione stretta */

        printf("Inserisci i %d elementi separati da \"enter\":\n",
               *n);

        /* Acquisizione degli elementi */
        for(i = 0;
            (i < *n);
            i++)
            do
            {
                esito_lettura = scanf("%lf",
                                      a + i);

                if (esito_lettura != 1)
                    do
                        carattere_non_letto = getchar();
                    while (carattere_non_letto != '\n');
            }
            while (esito_lettura != 1);

        /* Stampo a video l'insieme che si è creato */
        printf("L'insieme e' formato dai seguenti elementi: \n{ ");
        for (i = 0;
             i < *n;
             i++)
            printf("%.2f ",
                   a[i]);
        printf("}\n");

        /* Si chiede all'utente conferma dei valori digitati */
        /* se corretto, si prosegue altrimenti la funzione cicla */
        /* L'acquisizione di questo valore e' soggetta a validazione stretta */
        do
        {
            printf("\nDigitare 1 se l'insieme e' corretto, 0 altrimenti: ");
            esito_lettura = scanf("%d",
                                  &insieme_corretto);

            if (esito_lettura != 1
                || (insieme_corretto != 1 && insieme_corretto != 0))
                do
                    carattere_non_letto = getchar();
                while (carattere_non_letto != '\n');
        }
        while (esito_lettura != 1
                || (insieme_corretto != 1 && insieme_corretto != 0));

        if(!insieme_corretto)
            free(a);
    }
    while(!insieme_corretto);

    return(a);
}


/*La funzione prende in input l'array che contiene gli elementi dell'insieme,
la cardinalita' dell'insieme e una variabile passata per indirizzo nella quale
memorizzare il simbolo associato all'operazione da acquisire*/
/*Restituisce un puntatore all'array multi-dimensionale che memorizza i risultati
dell'operazione applicata ad ogni coppia ordinata dell'insieme*/
double **inserisci_operazione(double *a,
                              int n,
                              char *op)
{
    int             esito_lettura,          /*Variabile di lavoro - validazione*/
                    i,                      /*Variabile di lavoro - cicli*/
                    j;                      /*Variabile di lavoro - cicli*/

    double          **matrice;              /*Array multi-dimensionale che
                                            servira' a definire l'operazione -
                                            contiene i risultati ottenuti
                                            applicando l'operazione ad ogni
                                            coppia ordinata dell'insieme*/

    char            carattere_non_letto;    /*Variabile di lavoro - validazione*/

    /*Alloco una matrice di valori di dimensione n*n*/
    matrice = (double **) calloc(n,
                                 sizeof(double *));
    for(i = 0;
        (i < n);
        i++)
        matrice[i] = (double *) calloc(n,
                                       sizeof(double));

    /*Acquisisco il simbolo con il quale l'utente vuole identificare
    l'operazione - prima di acquisire il carattere svuoto il buffer*/
    do
        scanf("%c",
              &carattere_non_letto);
    while(carattere_non_letto != '\n');

    /* Validazione stretta dell'acquisizione. Impongo che il simbolo
    non sia un numero o un "a capo" */
    do
    {
        printf("\nDefinisci il simbolo con cui identificare l'operazione");
        printf(" binaria: ");

        scanf("%c",
                op);

        if (isdigit(*op) || *op == '\n')

            do
                carattere_non_letto = getchar();
            while (carattere_non_letto != '\n');
    }
    while (isdigit(*op) || *op == '\n');

    /* Svuoto di nuovo il buffer in caso l'utente inserisce più di un simbolo
    per l'operazione lasciando cosi solo il primo carattere */
    do
        scanf("%c",
              &carattere_non_letto);
    while(carattere_non_letto != '\n');


    /*Definizione dell'operazione sugli elementi dell'insieme*/
    printf("\nDigitare i risultati dell'operazione %c",
            *op);
    printf(" applicata ai seguenti operandi:");

    /*Richiedo all'utente il risultato dell'operazione binaria applicata ad ogni
    coppia ordinata di operatori*/
    for(i = 0;
        (i < n);
        i++)
        for(j = 0;
            (j < n);
            j++)
        {
            printf("\n%.2f %c %.2f = ",
                    a[i],
                    *op,
                    a[j]);

            scanf("%lf",
                    &matrice[i][j]);
        }

    return(matrice);
}


/*La funzione prende in input l'array che contiene gli elementi dell'insieme,
la cardinalita' dell'insieme*/
/*Restituisce un puntatore all'array multi-dimensionale che memorizza un valore
0 o 1 tale da definire la relazione applicata ad ogni coppia ordinata
dell'insieme*/
int **inserisci_relazione(double *a,
                          int n)
{
    int     **matrice,  /*Array multi-dimensionale che servira' a definire
                        la relazione - ogni elemento assume valore 1 se gli
                        elementi associati sono in relazione, 0 altrimenti -
                        mantiene un'associazione con l'insieme tramite gli
                        stessi indici*/

            i,          /*Variabile di lavoro - cicli*/
            j,          /*Variabile di lavoro - cicli*/
            num;        /*Variabile di lavoro - iterazioni*/

    double  elemento;   /*Variabile di lavoro - memorizza temporaneamente il
                        valore per verificarne la presenza*/

    /*Alloco una matrice di dimensione n*n*/
    matrice = (int **) calloc(n,
                              sizeof(int *));

    for(i = 0;
        (i < n);
        i++)
        matrice[i] = (int *) calloc(n,
                                    sizeof(int));

    /*Definizione della relazione*/
    printf("\nDefinire di seguito la relazione.\n");

    /*Per ogni elemento dell'insieme chiedo all'utente di specificare quali
    elementi sono in relazione con esso*/
    for(i = 0;
        (i < n);
        i++)
    {
        printf("Digitare il numero di elementi in relazione con %.2f: ",
                a[i]);

        scanf("%d",
              &num);

        for(j = 0;
            (j < num);
            j++)
        {
            do
            {
                printf("Digitare il %d° elemento t.c. %.2f R ",
                        j + 1,
                        a[i]);
                scanf("%lf",
                      &elemento);
                /*Verifico che l'elemento digitato sia presente -
                se si' inserisco l'1 che definisce la relazione*/
                if(cerca_elemento(elemento, a, n) != -1)
                    matrice[i][cerca_elemento(elemento, a, n)] = 1;
                else
                    printf("\nERRORE: Elemento non presente nell'insieme.\n");
            }
            while(cerca_elemento(elemento, a, n) == -1);
        }
    }
    return(matrice);
}

/*Funzione che valuta se l'elemento "e" e' presente nell'insieme*/
/*Prende in ingresso l'elemento, l'array che contiene gli elementi dell'insieme
e la dimensione dell'array, restituisce l'indice dell'elemento all'interno di a
se l'elemento e' presente, -1 altrimenti */
int cerca_elemento(double e,
                   double *a,
                   int n)
{
    int i,              /*Varibile di lavoro - cicli*/
        posizione;      /*Variabile di lavoro - assume l'indice
                        dell'elemento all'interno di a se l'elemento e'
                        presente, -1 altrimenti*/

    /*Scorro ogni elemento dell'array fino a trovare l'elemento cercato
    o fino all'ultimo se non presente*/
    /*Se l'elemento e' presente esco dal ciclo e restituisco la sua posizione*/
    for(posizione = -1, i = 0;
        ((i < n) && (posizione == -1));
        i++)
        if(a[i] == e)
            posizione = i;

    return(posizione);
}

/*Funzione che valuta se l'operazione e' chiusa rispetto all'insieme*/
/*Prende in input la matrice che definisce l'operazione, l'array degli elementi
e la dimensione dell'array, restituisce 1 se l'insieme e' chiuso rispetto
all'operazione, 0 altrimenti*/
int valuta_chiusura(double **matrice,
                    double *a,
                    int n,
                    char op)
{
    int i,          /*Variabile di lavoro - input*/
        j,          /*Variabile di lavoro - input*/
        chiuso;     /*Variabile che segnala se l'insieme e' chiuso*/

    /*Verifico se il risultato dell'operazione applicata ad ogni coppia ordinata
    di elementi appartiene all'insieme
    i.e. l'insieme e' chiuso rispetto all'operatore*/
    for(chiuso = 1, i = 0;
        ((i < n) && chiuso);
        i++)
        for(j = 0;
            ((j < n) && chiuso);
            j++)
            if(cerca_elemento(matrice[i][j], a, n) == -1)
                chiuso = 0;

    /*Al termine del ciclo notifico all'utente se l'insieme e' chiuso*/
    if(chiuso)
        printf("\nATTENZIONE: L'insieme e' chiuso");
    else
        printf("\nATTENZIONE: L'insieme NON e' chiuso");
    printf(" rispetto all'operazione %c \n",
           op);

    return (chiuso);
}

/*Funzione che valuta se la relazione binaria e' una relazione di equivalenza*/
/*Prende in input la matrice che definisce la relazione e il numero di elementi,
restituisce 1 se la relazione e' una relazione di equivalenza, 0 altrimenti*/
int valuta_equivalenza(int **relazione,
                       int n)
{
    int equivalenza = 0;    /*Variabile che segnala se la relazione
                            e' una relazione di equivalenza*/

    /*La relazione e' una relazione di equivalenza se soddisfa le proprieta' di
    riflessivita', simmetria e transitivita'*/
    if(valuta_riflessiva(relazione, n)
       && valuta_simmetrica(relazione, n)
       && valuta_transitiva(relazione, n))
        equivalenza = 1;

    if(!equivalenza)
        printf("\nATTENZIONE: La relazione non e' una relazione d'equivalenza\n");

    return(equivalenza);
}

/*Funzione che valuta se la relazione soddisfa la proprieta' di rifflessivita'*/
int valuta_riflessiva(int **relazione,
                      int n)
{
    int i,          /*Variabile di lavoro - cicli*/
        riflessiva; /*Variabile che segnala se la relazione
                    soddisfa la riflessibilita'*/

    printf("\nProprieta' riflessiva...");
    /*Riflessiva se: a R a, per ogni a*/
    for(riflessiva = 1, i = 0;
        ((i < n) && (riflessiva));
        i++)
        if(!relazione[i][i])
            riflessiva = 0;

    if(riflessiva)
        printf("OK\n");
    else
        printf("NO\n");
    return(riflessiva);
}

/*Funzione che valuta se la relazione soddisfa la proprieta' di simmetria*/
int valuta_simmetrica(int **relazione,
                      int n)
{
    int i,          /*Variabile di lavoro - cicli*/
        j,          /*Variabile di lavoro - cicli*/
        simmetrica; /*Variabile che segnala se la relazione
                    soddisfa la simmetria*/

    printf("\nProprieta' simmetrica...");
    /*Simmetrica se: per ogni i j, i R j -> j R i*/
    for(simmetrica = 1, i = 0;
        ((i < n) && (simmetrica));
        i++)
        for(j = 0;
            ((j < n) && (simmetrica));
            j++)
            if(relazione[i][j])
                if(!relazione[j][i])
                    simmetrica = 0;

    if(simmetrica)
        printf("OK\n");
    else
        printf("NO\n");

    return(simmetrica);
}

/*Funzione che valuta se la relazione soddisfa la proprieta' di transitivita'*/
int valuta_transitiva(int **relazione,
                      int n)
{
    int i,          /*Variabile di lavoro - cicli*/
        j,          /*Variabile di lavoro - cicli*/
        k,          /*Variabile di lavoro - cicli*/
        transitiva; /*Variabile che segnala se la relazione
                    soddisfa la transitivita'*/

    printf("\nProprieta' transitiva...");
    /*Scorro ogni coppia ordinata dell'insieme,
    per ogni i,j t.c. i R j controllo che per ogni elemento "k" j R k -> i R k*/
    for(transitiva = 1, i = 0;
        ((i < n) && (transitiva));
        i++)
        for(j = 0;
            ((j < n) && (transitiva));
            j++)
            if(relazione[i][j])
                for(k = 0;
                    ((k < n) && (transitiva));
                    k++)
                    if(relazione[j][k])
                        if(!relazione[i][k])
                            transitiva = 0;

    if(transitiva)
        printf("OK\n");
    else
        printf("NO\n");

    return(transitiva);
}

/*Funzione che valuta se la relazione e' anche una congruenza
rispetto all'operatore*/
/*Prende in ingresso la matrice che definisce la relazione,
la matrice che definisce l'operazione, e la loro dimensione.
Restituisce 1 se la relazione e' una congruenza, 0 altrimenti*/
void valuta_congruenza(int **relazione,
                       double **operazione,
                       int n,
                       char op)
{
    int i,          /*Variabile di lavoro - cicli*/
        j,          /*Variabile di lavoro - cicli*/
        k,          /*Variabile di lavoro - cicli*/
        congruenza; /*Variabile che segnala se la relazione
                    e' una relazione di equivalenza*/

    /*Scorro ogni coppia ordinata dell'insieme,
    per ogni i,j t.c. i R j (dove R e' gia' provata essere una relazione di
    equivalenza) controllo che per ogni elemento "k" dell'insieme valga
    ((i OP k) = (j OP k)) AND ((k OP i) = (k OP j))
    (dove OP indica l'operazione binaria)*/
    for(congruenza = 1, i = 0;
        ((i < n) && congruenza);
        i++)
        for(j = 0;
            ((j < n) && congruenza);
            j++)
            if(relazione[i][j] && (i != j))
                for(k = 0;
                    ((k < n) && congruenza);
                    k++)
                    if((operazione[i][k] != operazione[j][k])
                        || operazione[k][i] != operazione[k][j])
                        congruenza = 0;
    if(congruenza)
        printf("\nATTENZIONE: la relazione inserita e' una congruenza");
    else
        printf("\nATTENZIONE: la relazione inserita NON e' una congruenza");
        printf(" rispetto all'operazione %c\n",
                op);
}