presi nella regione Viola [23%]
Nodi ordinati con PageRank
senza flessibilità = Il risultato complessivo dell'algoritmo è stato del 29,3291901061653%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.0692252
con flessibilità = Il risultato complessivo dell'algoritmo è stato del 51,3358286059511%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.2107623
Nodi ordinati con Weight degree
senza flessibilità = Il risultato complessivo dell'algoritmo è stato del 28,249449661556%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.8769137
con flessibilità = Il risultato complessivo dell'algoritmo è stato del 48,6465076991349%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.2574541
Presi nella regione Azzurra [17 %]
Nodi ordinati con PageRank
senza flessibilità = Il risultato complessivo dell'algoritmo è stato del 27,0015344340491%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.2249946
con flessibilità = Il risultato complessivo dell'algoritmo è stato del 46,5986730788978%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:02.9865795
Nodi ordinati con Weight degree
senza flessibilità = Il risultato complessivo dell'algoritmo è stato del 22,5088452705491%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.7124582
con flessibilità = Il risultato complessivo dell'algoritmo è stato del 38,9459685277154%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.6538326
Presi nella regione Arancione [17 %] IDBM
Nodi ordinati con PageRank
senza flessibilità = Il risultato complessivo dell'algoritmo è stato del 30,1587620440248%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.3353151
con flessibilità = Il risultato complessivo dell'algoritmo è stato del 50,1901815600369%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:02.9397031
Nodi ordinati con Weight degree
senza flessibilità = Il risultato complessivo dell'algoritmo è stato del 31,6294395477267%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:03.1169375
con flessibilità =  Il risultato complessivo dell'algoritmo è stato del 51,7273886554361%. Gli utente non analizzati sono stati 6 Time elapsed: 00:00:02.9670979




// CREATE TABLE `reti_confronti` (
        //  `idA` int(11) NOT NULL,
        //  `idB` int(11) NOT NULL,
        //  `score` int(11) DEFAULT NULL,
        //  `disgiunti` int(11) DEFAULT NULL,
        //  `uguali` int(11) DEFAULT NULL,
        //  `simili` int(11) DEFAULT NULL,
        //  `lista` varchar(150) DEFAULT NULL,
        //  PRIMARY KEY(`idA`,`idB`)
        //) ENGINE=InnoDB DEFAULT CHARSET=utf8;


                        //// Salva i risultati con un nuovo thread
                        //Worker workerObject = new Worker(User1ID, User2ID, _temp);
                        //Thread workerThread = new Thread(workerObject.DoWork);
                        //workerThread.Start(); // Start the worker thread.  

        public SimilarityResoult UserSimilaryty(Dictionary<int, int>
    user1_vote, Dictionary<int, int>
        user2_vote) {

        int total = 0;
        double score = 0;

        // Ogni volta che i voti sono mooolto contrastanti aggiungo 1
        int votoDisguinto = 0;
        int votoComune = 0;
        int votoSimile = 0;

        List<int>
            listSuggestAtoB = new List<int>
                ();
                List<int>
                    listSuggestBtoA = new List<int>
                        ();

                        foreach (KeyValuePair<int, int>
    us1 in user1_vote) {

    if (user2_vote.ContainsKey(us1.Key)) {

    int filmID = us1.Key;
    int votoUser1 = us1.Value;
    int votoUser2 = user2_vote[us1.Key];
    double tempscoreToschow = 0;

    printConsoleDebug("film " + filmID + ": " + " utenteA voto = " + votoUser1 + "  Vs utenteB = " + votoUser2, true, total);

    // Aggiungo il confronto sempre, lo tolgo nel caso l'utente 1 nn abbia votato...
    // da vedere meglio ....
    total++;

    // Stesso voto (Diverso da 0 >> maggior similarità)
    if ((votoUser1 == votoUser2) && (votoUser1 != 0)) {
    score = score + 1;
    tempscoreToschow = 1;
    votoComune++;
    printConsoleDebug(" > stesso voto > score +" + tempscoreToschow, false, total);
    }
    else {
    switch (votoUser1) {

    // Non ho visto il film, se utente 2 l'ha visto ed è bello lo aggiungo alla mia lista di film da vedere ...
    case 0:
    printConsoleDebug(" > film non visto > score=0", false, total);
    if ((votoUser2 == 5) || (votoUser2 == 4)) {
    listSuggestAtoB.Add(filmID);
    printConsoleDebug(" film aggiunto alla lista ... ", false, total);
    }
    total = total - 1;
    break;

    // Film brutto (1 o 2 stelline)
    case 1:
    case 2:
    switch (votoUser2) {
    case 1:
    case 2:
    score = score + 0.8;
    tempscoreToschow = +0.8;
    votoSimile++;
    break;
    case 3:
    score = score - 0.3;
    tempscoreToschow = -0.3;
    break;
    case 4:
    case 5:
    score = score - 0.8;
    tempscoreToschow = -0.8;
    votoDisguinto++;
    break;
    }
    printConsoleDebug(" > film brutto > score = " + tempscoreToschow, false, total);
    break;

    // Film sufficiente (3 stelline)
    case 3:
    switch (votoUser2) {
    case 1:
    score = score - 0.5;
    tempscoreToschow = 0.5;
    votoDisguinto++;
    break;
    case 2:
    score = score - 0.3;
    tempscoreToschow = -0.3;
    break;
    case 4:
    score = score + 0.5;
    tempscoreToschow = 0.5;
    votoSimile++;
    break;
    case 5:
    score = score + 0.2;
    tempscoreToschow = 0.2;
    break;
    }
    printConsoleDebug(" > film sufficiente > score = " + tempscoreToschow, false, total);
    break;

    // bel Film (4 stelline)
    case 4:
    switch (votoUser2) {
    case 1:
    case 2:
    score = score - 0.8;
    tempscoreToschow = -0.8;
    votoDisguinto++;
    break;
    case 3:
    score = score + 0.5;
    tempscoreToschow = 0.5;
    votoSimile++;
    break;
    case 5:
    score = score + 0.8;
    tempscoreToschow = 0.8;
    votoSimile++;
    break;
    }
    printConsoleDebug(" > film bello > score = " + tempscoreToschow, false, total);
    break;

    // bellissimo Film (4 stelline)
    case 5:
    switch (votoUser2) {
    case 1:
    case 2:
    score = score - 1;
    tempscoreToschow = -1;
    votoDisguinto++;
    break;
    case 3:
    score = score + 0.3;
    tempscoreToschow = 0.3;
    break;
    case 4:
    score = score + 0.8;
    tempscoreToschow = 0.8;
    votoSimile++;
    break;
    }
    printConsoleDebug(" > film bellissimo > score = " + tempscoreToschow, false, total);
    break;
    }
    }

    //Se B non ha visto un film che però ad A è piaciuto...
    if (votoUser2 == 0 && ((votoUser1 == 5) || (votoUser1 == 4))) {
    listSuggestBtoA.Add(filmID);
    }
    }
    }

    console.AppendText(Environment.NewLine);

    int similarity = Convert.ToInt32((score / total) * 100);

    printConsoleDebug("score =" + score + " total=" + total + " similarity=" + similarity + " votoDisguinto=" + votoDisguinto +
    " votoComune=" + votoComune + " votoSimile=" + votoSimile + " filmSuggeriti da A a B= " +
    listSuggestAtoB.Count + " filmSuggeriti da B a A= ", false, listSuggestBtoA.Count);

    return new SimilarityResoult(similarity, listSuggestBtoA, listSuggestAtoB, votoDisguinto, votoComune, votoSimile);

    }








    public SimilarityResoult UserSimilaryty(Dictionary<int, SimilarityFilmsData>
        _similarityDictionary) {

        int total = 0; // film visti in comune
        double score = 0; // Grado di "amicizia"

        int countvote_opposite = 0; // Ogni volta che i voti sono mooolto contrastanti aggiungo 1
        double VotePoints_opposite = 0;

        int countvote_disagree = 0; // Molto in disaccordo ma nn l'opposto un pò in disaccordo es io 2 tu 3


        int countvote_discord = 0; // Voto un pò in disaccordo es io 2 tu 3


        int countvote_similar = 0; // Voto simile es io 4 tu 5, io 2 e tu 1
        int countvote_same = 0;  // Voto uguale tutti e 2 votiamo 3

        double VotePoints_disagree = 0.3;
        double VotePoints_discord = 0.5;
        double VotePoints_similar = 0.8;
        double VotePoints_same = 1;



        List<int>
            listSuggestAtoB = new List<int>
                (); // Film che A suggerisce ad B
                List<int>
                    listSuggestBtoA = new List<int>
                        (); // Film che B suggerisce ad A

                        foreach (KeyValuePair<int, SimilarityFilmsData>
                            row in _similarityDictionary) {

                            int filmID = row.Value.filmID;
                            int votoUserA = row.Value.UserAVote;
                            int votoUserB = row.Value.UserBVote;

                            // Film che A e B non hanno visto e che consiglia all'altro
                            if ((votoUserA == 0) && ((votoUserB == 5) || (votoUserB == 4))) {
                            listSuggestBtoA.Add(filmID);
                            continue;
                            }
                            if ((votoUserB == 0) && ((votoUserA == 5) || (votoUserA == 4))) {
                            listSuggestBtoA.Add(filmID);
                            continue;
                            }

                            // il film  A o B non lo hanno visto, quindi inutile continuare il cofronto, esco dal ciclo
                            if ((votoUserA == 0) || (votoUserB == 0)) {
                            continue;
                            }

                            // il Film è stato visto da entrambi ed entrambi, ha senso fare il confronto

                            total++; // Incremento il contatore

                            // Stesso voto = maggior "legame"
                            if ((votoUserA == votoUserB) && (votoUserA != 0)) {
                            score += VotePoints_same;
                            countvote_same++;
                            continue;
                            }

                            // Voto congiunto che mi permette di dare un Grado di "amicizia" in base hai 2 voti
                            // Es A vota 3 e B vota 2
                            // _choose = (3*10)+2 = 32;
                            int _choose = (votoUserA * 10) + votoUserB;

                            switch (_choose) {
                            // Molto simili 1 e 2 oppure 4 o 5
                            case 12:
                            case 21:
                            case 45:
                            case 54:
                            score += VotePoints_similar;
                            countvote_similar++;
                            break;
                            // Non uguali ma qualcosa in comune ...
                            case 34:
                            case 43:
                            score += VotePoints_disagree;
                            countvote_disagree++;
                            break;
                            // In contrasto ma non agli antipodi ...
                            case 13:
                            case 23:
                            case 32:
                            case 53:
                            score += VotePoints_discord;
                            countvote_discord++;
                            break;
                            // Pareri piu' discordanti possibile ...
                            case 14:
                            case 15:
                            case 24:
                            case 25:
                            case 31:
                            case 35:
                            case 41:
                            case 42:
                            case 51:
                            case 52:
                            score += VotePoints_opposite;
                            countvote_opposite++;
                            break;
                            default:
                            string x = "errore";
                            break;
                            }
                            }

                            int similarity = Convert.ToInt32((score / total) * 100);

                            return new SimilarityResoult(similarity, listSuggestBtoA, listSuggestAtoB, countvote_opposite, countvote_disagree, countvote_disagree, countvote_similar, countvote_same);

                            }



                                                 public class CreateCSV {


                                                 private void CreateFirstRowArchCSV() {
                                                 var file = @"C:\Users\franc\OneDrive\Documenti\Universita\RetiSocialiAlgoritmo\RetiSocialiAlgoritmo\RetiSocialiAlgoritmo\archi.csv";
                                                 using (StreamWriter sw = File.AppendText(file)) {
                                                 sw.WriteLine("Source", "Target", "Weight");
                                                 }
                                                 }


                                                 private void AddArchCSV(int userAID, int userBID, double weight) {

                                                 var file = @"C:\Users\franc\OneDrive\Documenti\Universita\RetiSocialiAlgoritmo\RetiSocialiAlgoritmo\RetiSocialiAlgoritmo\archi.csv";

                                                 // This text is always added, making the file longer over time
                                                 // if it is not deleted.
                                                 using (StreamWriter sw = File.AppendText(file)) {
                                                 string csvRow = string.Format("{0},{1},{2}", userAID, userBID, weight);
                                                 sw.WriteLine(csvRow);
                                                 }

                                                 }

                                                 private void start() {

                                                 var file = @"C:\Users\franc\OneDrive\Documenti\Universita\RetiSocialiAlgoritmo\RetiSocialiAlgoritmo\RetiSocialiAlgoritmo\nodi.csv";

                                                 using (var stream = File.CreateText(file)) {
                                                 string csvFirstRow = string.Format("{0},{1},{2},{3},{4}", "id", "label", "Gender", "Year", "nvote");
                                                 stream.WriteLine(csvFirstRow);
                                                 for (int i = 0; i < users.Count; i++) {
                                                 string id = users[i].userid.ToString();
                                                 string nome = users[i].username.ToString();
                                                 string genere = users[i].genere.ToString();
                                                 string anno = users[i].anno.ToString();
                                                 string nvoti = users[i].nvoti.ToString();
                                                 string csvRow = string.Format("{0},{1},{2},{3},{4}", id, nome, genere, anno, nvoti);
                                                 stream.WriteLine(csvRow);
                                                 }
                                                 }

                                                 console.AppendText(Environment.NewLine);
                                                 console.AppendText("Csv dei nodi creato in " + stopwatch.Elapsed + " secondi." + Environment.NewLine);

                                                 CreateFirstRowArchCSV();

                                                 }


                                                 }