#This program analyzes two corpus that contains: *two of Hilary Clinton's speeches named "Remarks in Miami on the Cuba embargo" and 
"Remarks at the Brookings Institution on the Iran deal", both dated Jan 31, 2016; *ten of Donald Trump's speeches, from October 21, 2016 to October 31, 2016. 

# -*- coding: utf-8 -*-

import sys
import codecs
import nltk
import math
import collections
from nltk import word_tokenize, sent_tokenize
from nltk.probability import *

#questa funzione restituisce il testo tokenizzato
def TokenizzaTesto(frasi):
    tokensTOT=[]
    for frase in frasi:
        #divido la frase in token
        tokens = nltk.word_tokenize(frase) #prende in input una stringa e restituisce una lista di stringhe
        #concateno la frase appena tokenizzata con le tokenizzazioni precedenti
        tokensTOT = tokensTOT+tokens #questa variabile contiene tutto il file tokenizzato
    return tokensTOT

#questa funzione calcola il numero di token di un testo
def CalcolaLunghezza(frasi):
    lunghezzaTOT=0.0
    for frase in frasi:
        #divido la frase in token
        tokens=nltk.word_tokenize(frase)
        #calcolo la lunghezza totale 
        lunghezzaTOT=lunghezzaTOT+len(tokens)
    #restituisco il risultato
    return lunghezzaTOT

#questa funzione calcola la lunghezza media delle frasi si un testo
def LunghezzaMediaFrasi(frasi):
    lunghezzaFrasi=0.0
    numFrasi=0.0
    for frase in frasi:
        #divido la frase in token
        tokens=nltk.word_tokenize(frase)
        #calcolo la lunghezza di ciascuna frase e la sommo con la lunghezza delle altre ottenendo la lunghezza del testo
        lunghezzaFrasi=lunghezzaFrasi+len(tokens)
        #il contatore registra il numero delle frasi osservate con lo scorrimento del ciclo for
        numFrasi=numFrasi+1
    #restituisco la media matematica della lunghezza di ciascuna frase
    return lunghezzaFrasi/numFrasi

#lista delle porzioni incrementali dei corpora
listaPorzioni=[1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000]

#questa funzione calcola la grandezza del vocabolario per porzioni incrementali di 1000 token
def GrandezzaVocabolario(testoTokenizzato):  
    listaLunghezze=[] 
    for porzione in listaPorzioni:
        #estraggo il vocabolario della porzione di corpus corrispondente
        Vocab=set(testoTokenizzato[:int(porzione)]) #rendo intero il valore perche' e' l'estremo di un intervallo
        #calcolo la lunghezza del vocabolario
        lunghezzaVocab=len(Vocab) 
        #aggiungo ogni valore ottenuto ad una lista
        listaLunghezze.append(lunghezzaVocab) 
    #restituisco la lista contenente tutte le lunghezze corrispondenti a ciascuna porzione di corpus
    return listaLunghezze 

#questa funzione calcola la ricchezza lessicale per porzioni incrementali di 1000 token
def CalcolaTTR(testoTokenizzato):
    listaTTR=[]
    for porzione in listaPorzioni:
        #estraggo il vocabolario della porzione di corpus corrispondente
        Vocab=set(testoTokenizzato[:int(porzione)]) #rendo intero il valore perche' e' l'estremo di un intervallo
        #calcolo la lunghezza del vocabolario
        lunghezzaVocab=len(Vocab)
        #calcolo la Type-Token-Ratio come rapporto tra la cardinalita' del vocabolario (num. di tipi) per la cardinalita' del corpus (num. di token)
        TTR=lunghezzaVocab*1.0/porzione*1.0
        #aggiungo ogni valore ottenuto ad una lista
        listaTTR.append(TTR)
    #restituisco la lista contenente tutte le TTR corrispondenti a ciascuna porzione di corpus
    return listaTTR

#questa funzione calcola il rapporto tra sostantivi e verbi osservati nel corpus
def RapportoSostantiviVerbi(POStag):
    #lista dei tag usati nel PoS tagging (Penn Treebank), da http://www.ling.upenn.edu/courses/Fall_2003/ling001/penn_treebank_pos.html
    tagSostantivi = ["NN", "NNS", "NNP", "NNPS"]
    tagVerbi = ["VB", "VBD", "VBG", "VBN", "VBP", "VBZ"]
    #per ogni coppia (token, PoS) memorizzo in due liste tutte le pos rispettivamente di sostantivi e di verbi osservate nel corpus
    listaTagSostantivi=[]
    listaTagVerbi=[]
    for (tok, pos) in POStag: 
        if pos in tagSostantivi: 
           listaTagSostantivi.append(pos)
        if pos in tagVerbi: 
           listaTagVerbi.append(pos)
    #conto quante volte occorre ciascuna pos osservata nel corpus
    occorrenzeSostantivi=collections.Counter(listaTagSostantivi) 
    occorrenzeVerbi=collections.Counter(listaTagVerbi)
    #faccio la somma totale di tutti i conteggi
    sostantivi=sum(occorrenzeSostantivi.values())
    verbi=sum(occorrenzeVerbi.values())
    #calcolo e restituisco il rapporto
    return sostantivi*1.0/verbi*1.0

#questa funzione calcola la densita' lessicale
def DensitaLessicale(testoTokenizzato):
    POStag=nltk.pos_tag(testoTokenizzato)
    lunghezzaTesto=CalcolaLunghezza(testoTokenizzato)
    #lista dei tag usati nel PoS tagging (Penn Treebank), da http://www.ling.upenn.edu/courses/Fall_2003/ling001/penn_treebank_pos.html
    tagSostantivi = ["NN", "NNS", "NNP", "NNPS"]
    tagVerbi = ["VB", "VBD", "VBG", "VBN", "VBP", "VBZ"]
    tagAvverbiEAggettivi=["JJ", "JJR", "JJS", "RB", "RBR", "RBS", "WRB"]  
    tagPunteggiatura=[".", ","]
    #memorizzo nelle liste tutte le pos osservate nel corpus
    listaTagSostantivi=[]
    listaTagVerbi=[]
    listaTagAvverbiEAggettivi=[]
    listaTagPunteggiatura=[]
    for (tok, pos) in POStag: 
        if pos in tagSostantivi: 
           listaTagSostantivi.append(pos)
        if pos in tagVerbi: 
           listaTagVerbi.append(pos)
        if pos in tagAvverbiEAggettivi:
           listaTagAvverbiEAggettivi.append(pos)
        if pos in tagPunteggiatura:
           listaTagPunteggiatura.append(pos)
    #conto quante volte occorre ciascuna pos osservata nel corpus
    occorrenzeSostantivi=collections.Counter(listaTagSostantivi) 
    occorrenzeVerbi=collections.Counter(listaTagVerbi)
    occorrenzeAvverbiEAggettivi=collections.Counter(listaTagAvverbiEAggettivi)
    occorrenzePunteggiatura=collections.Counter(listaTagPunteggiatura)
    #faccio la somma totale di tutti i conteggi
    sostantivi=sum(occorrenzeSostantivi.values())
    verbi=sum(occorrenzeVerbi.values())
    avverbiEAggettivi=sum(occorrenzeAvverbiEAggettivi.values())
    punteggiatura=sum(occorrenzePunteggiatura.values())
    #restituisco il risultato del calcolo
    return (sostantivi + verbi + avverbiEAggettivi) / (lunghezzaTesto - punteggiatura)


#questa funzione restituisce due liste contenenti i token dei due corpora e li confronta in base alla lunghezza
def main(file1, file2):
  fileInput1 = codecs.open(file1, "r", "utf-8")
  fileInput2 = codecs.open(file2, "r", "utf-8")
  var1 = fileInput1.read()
  var2 = fileInput2.read()
  #carico il modello statistico utilizzato dalla funzione tokenize
  sent_tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
  #divido i testi dei due file in frasi 
  frasi1 = sent_tokenizer.tokenize(var1) 
  frasi2 = sent_tokenizer.tokenize(var2)

  #tokenizzo il file1 
  testoTokenizzato1=TokenizzaTesto(frasi1)
  #tokenizzo il file2
  testoTokenizzato2=TokenizzaTesto(frasi2)
  
  #calcolo la lunghezza dei due testi 
  lunghezzaFile1 = CalcolaLunghezza(frasi1)
  lunghezzaFile2 = CalcolaLunghezza(frasi2)
 
  print "\n\nPROGRAMMA #1\n"

  #confronto i testi sulla base del numero di token e stampo i risultati
  print "\nIl file", file1, "e' lungo", lunghezzaFile1, "token"
  print "Il file", file2, "e' lungo", lunghezzaFile2, "token"
  if (lunghezzaFile1>lunghezzaFile2):
      print file1, "e' piu' lungo di", file2
  elif (lunghezzaFile1<lunghezzaFile2):
      print file2, "e' piu' lungo di", file1
  else:
      print "i due file hanno la stessa lunghezza"

  #calcolo la lunghezza media delle frasi nei due testi 
  lunghezzaMedia1 = LunghezzaMediaFrasi(frasi1)
  lunghezzaMedia2 = LunghezzaMediaFrasi(frasi2)

  #confronto i testi sulla base della lunghezza media delle frasi e stampo i risultati
  print "\nLe frasi del file", file1, "hanno lunghezza media pari a", lunghezzaMedia1, "token"
  print "Le frasi del file", file2, "hanno lunghezza media pari a", lunghezzaMedia2, "token"

  #calcolo le cardinalita' dei vocabolari dei due file
  lunghezzaVocabolario1=len(set(testoTokenizzato1))
  lunghezzaVocabolario2=len(set(testoTokenizzato2))
  #confronto i testi sulla base del vocabolario
  print "\nIl vocabolario del file", file1, "ha", lunghezzaVocabolario1, "tipi"
  print "Il vocabolario del file", file2, "ha", lunghezzaVocabolario2, "tipi"
  if (lunghezzaVocabolario1>lunghezzaVocabolario2):
      print file1, "ha un vocabolario piu' ricco di", file2
  elif (lunghezzaVocabolario2>lunghezzaVocabolario2):
      print file2, "ha un vocabiolario piu' ricco di", file1
  else:
      print "i vocabolari dei due file hanno la stessa lunghezza"

  #restituisco la lunghezza dei vocabolari dei due file per porzioni incrementali dei due corpora
  vocabolario1 = GrandezzaVocabolario(testoTokenizzato1)
  vocabolario2 = GrandezzaVocabolario(testoTokenizzato2)
  print "\nGrandezza del vocabolario del file", file1, "all'aumento del corpus per porzioni incrementali di 1000 token:"
  for voc1 in vocabolario1:
          print voc1
  print "\nGrandezza del vocabolario del file", file2, "all'aumento del corpus per porzioni incrementali di 1000 token:"
  for voc2 in vocabolario2:
          print voc2
  print "\nNotiamo dal risultato che il vocabolario tende a crescere sempre piu' lentamente."

  #restituisco la ricchezza lessicale dei due file per porzioni incrementali dei due corpora
  TTR1= CalcolaTTR(testoTokenizzato1)
  TTR2= CalcolaTTR(testoTokenizzato2)
  print "\nRicchezza lessicale del file", file1, "all'aumento del corpus per porzioni incrementali di 1000 token:"
  for t1 in TTR1:
      print t1
  print "\nRicchezza lessicale del file", file2, "all'aumento del corpus per porzioni incrementali di 1000 token:"
  for t2 in TTR2:
      print t2
  print "Piu' e' alto il valore della Type-Token-Ratio, maggiore e' la ricchezza del vocabolario"

  #memorizzo su due variabili i due testi annotati sulla base delle Part-Of-Speech
  POStag1=nltk.pos_tag(testoTokenizzato1)
  POStag2=nltk.pos_tag(testoTokenizzato2)

  #calcolo il rapporto sostantivi/verbi nei due testi
  rapportoSV1=RapportoSostantiviVerbi(POStag1)
  rapportoSV2=RapportoSostantiviVerbi(POStag2)
  print "\nIl rapporto sostantivi/verbi nel file", file1, "e': ", rapportoSV1
  print "Il rapporto sostantivi/verbi nel file", file2, "e': ", rapportoSV2
  
  #calcolo la densita' lessicale dei due testi
  densita1=DensitaLessicale(testoTokenizzato1)
  densita2=DensitaLessicale(testoTokenizzato2)
  print "\nLa densita' lessicale del file", file1, "e': ", densita1
  print "La densita' lessicale del file", file2, "e': ", densita2

main(sys.argv[1], sys.argv[2])

#This program analyzes two corpus that contains: *two of Hilary Clinton's speeches named "Remarks in Miami on the Cuba embargo" 
and "Remarks at the Brookings Institution on the Iran deal", both dated Jan 31, 2016; *ten of Donald Trump's speeches, 
from October 21, 2016 to October 31, 2016. 

# -*- coding: utf-8 -*-

import re
import sys
import codecs
import nltk
import math
import collections
from nltk import word_tokenize, sent_tokenize
from nltk.probability import *


#questa funzione restituisce il testo tokenizzato
def TokenizzaTesto(frasi):
    tokensTOT=[]
    for frase in frasi:
        #divido la frase in token
        tokens = nltk.word_tokenize(frase) #prende in input una stringa e restituisce una lista di stringhe
        #concateno la frase appena tokenizzata con le tokenizzazioni precedenti
        tokensTOT = tokensTOT+tokens #questa variabile contiene tutto il file tokenizzato
    return tokensTOT

#questa funzione estrae le POS piu' frequenti nel corpus
def POSFrequenti(testoTokenizzato):
    POStag=nltk.pos_tag(testoTokenizzato)
    #creo una lista con tutte le POS osservate nel corpus
    listaTag=[]
    for (tok, pos) in POStag: 
           listaTag.append(pos)
    #conto quante volte occorre ciascuna pos osservata nel corpus
    frequenze=collections.Counter(listaTag)
    #restituisco le prime 10 piu' frequenti
    POSPiuFrequenti=frequenze.most_common(10)
    return POSPiuFrequenti

#questa funzione estrae i token piu' frequenti nel corpus
def TokenFrequenti(testoTokenizzato):
    SegniPunteggiatura=[".", ",", ":", ";", "!", "?", "...", "-"] #token da escludere
    #estraggo il testo senza punteggiatura
    testoSenzaPunteggiatura=[]
    for token in testoTokenizzato:
        if token not in SegniPunteggiatura:
            testoSenzaPunteggiatura.append(token)
    #calcolo la frequenza di ogni token del testo ottenuto
    freqToken=collections.Counter(testoSenzaPunteggiatura)
    #restituisco i primi 20 in ordine di frequenza decrescente
    tokenPiuFrequenti=freqToken.most_common(20)
    return tokenPiuFrequenti
    
#questa funzione estrae i bigrammi piu' frequenti nel corpus
def BigrammiFrequenti(testoTokenizzato):
    POStag=nltk.pos_tag(testoTokenizzato)
    bigrammi=nltk.bigrams(POStag)
    #lista dei tag per la classificazione di articoli, congiunzioni e  segni di punteggiatura usati nel PoS tagging (Penn Treebank)
    #da http://www.clips.ua.ac.be/pages/mbsp-tags
    tagArticoliCongiunzioniEPunteggiatura=["CC", "DT", "IN", "SYM", ".", ",", ":", "(", ")", "'", "''"] #POS da escludere
    #creo una lista di tutti i bigrammi le cui POS corrispondenti NON sono tra quelle da escludere
    listaBigrammi=[]
    for ((tok1, pos1), (tok2, pos2)) in bigrammi:
        if pos1 not in tagArticoliCongiunzioniEPunteggiatura:
            if pos2 not in tagArticoliCongiunzioniEPunteggiatura:
                bigramma= (tok1, tok2) 
                listaBigrammi.append(bigramma) 
    #calcolo la frequenza di ciascun bigramma
    freqBigrammi=collections.Counter(listaBigrammi)
    #restituisco i primi 20 in ordine di frequenza decrescente
    bigrammiPiuFrequenti=freqBigrammi.most_common(20)
    return bigrammiPiuFrequenti

#questa funzione estrae i trigrammi piu' frequenti nel corpus
def TrigrammiFrequenti(testoTokenizzato):
    POStag=nltk.pos_tag(testoTokenizzato)  
    trigrammi=nltk.trigrams(POStag)      
    #lista dei tag per la classificazione di articoli, congiunzioni e  segni di punteggiatura usati nel PoS tagging (Penn Treebank)
    #da http://www.clips.ua.ac.be/pages/mbsp-tags
    tagArticoliCongiunzioniEPunteggiatura=["CC", "DT", "IN", "SYM", ".", ",", ":", "(", ")", "'", "''"] #POS da escludere
    #creo una lista di tutti i trigrammi le cui POS corrispondenti NON sono tra quelle da escludere
    listaTrigrammi=[]
    for ((tok1, pos1), (tok2, pos2), (tok3, pos3)) in trigrammi:
        if pos1 not in tagArticoliCongiunzioniEPunteggiatura:
            if pos2 not in tagArticoliCongiunzioniEPunteggiatura:
                if pos3 not in tagArticoliCongiunzioniEPunteggiatura:
                    trigramma= (tok1, tok2, tok3) 
                    listaTrigrammi.append(trigramma) 
    #calcolo la frequenza di ciascun trigramma
    freqTrigrammi=collections.Counter(listaTrigrammi)
    #restituisco i primi 20 in ordine di frequenza decrescente
    trigrammiPiuFrequenti=freqTrigrammi.most_common(20)
    return trigrammiPiuFrequenti
 
#questa funzione estrae i bigrammi aggettivo-sostantivo in cui ogni token ha frequenza maggiore di 2
def BigrammiAggettivoSostantivo(testoTokenizzato):
    POStag=nltk.pos_tag(testoTokenizzato)
    #per ogni token calcolo quante volte occorre
    listaFreqToken=collections.Counter(testoTokenizzato)
    #creo una lista che contiene solo i token con frequenza maggiore di due
    listaToken=[]
    for tok in listaFreqToken:
        if listaFreqToken.values()>2:
            listaToken.append(tok)
    #estraggo i bigrammi
    bigrammi=nltk.bigrams(POStag)
    listaBigrammi=[]
    #lista dei tag per la classificazione di aggettivi e sostantivi usati nel PoS tagging (Penn Treebank)
    #da http://www.clips.ua.ac.be/pages/mbsp-tags
    tagAggettivi = ["JJ", "JJR", "JJS"]
    tagSostantivi = ["NN", "NNS", "NNP", "NNPS"]
    for ((tok1, pos1), (tok2, pos2)) in bigrammi:
        #se le POS sono rispettivamente un aggettivo e un nome
        if (pos1 in tagAggettivi) and (pos2 in tagSostantivi):
            #se i token dei bigrammi appartengono alla lista dei token con frequenza maggiore di 2
            if (tok1 in listaToken) and (tok2 in listaToken):
                bigramma= (tok1, tok2)
                #creo una lista di bigrammi che rispettano le condizioni, eliminando le POS che non mi servono per i calcoli successivi
                listaBigrammi.append(bigramma)
    return listaBigrammi

#questa funzione calcola la frequenza del primo elemento del bigramma (ovvero degli aggettivi) in tutto il corpus
def CalcolaFreqAggettivi(testoTokenizzato):
    POStag=nltk.pos_tag(testoTokenizzato)
    tagAggettivi = ["JJ", "JJR", "JJS"]
    #creo una lista con tutti gli aggettivi osservati nel corpus
    listaAggettivi=[]
    for (token, POS) in POStag:
        if POS in tagAggettivi:
           listaAggettivi.append(token)
    #calcolo la frequenza per ciascun aggettivo osservato
    freqAggettivo=collections.Counter(listaAggettivi)
    #trasformo l'oggetto Counter in una lista
    freqAggettivi=freqAggettivo.items() #contiene le frequenze degli aggettivi nel corpus
    return freqAggettivi

#questa funzione calcola la frequenza del secondo elemento del bigramma (ovvero dei sostantivi) in tutto il corpus
def CalcolaFreqSostantivi(testoTokenizzato):
    POStag=nltk.pos_tag(testoTokenizzato)
    tagSostantivi = ["NN", "NNS", "NNP", "NNPS"]
    #creo una lista con tutti i sostantivi osservati nel corpus
    listaSostantivi=[]
    for (token, POS) in POStag:
        if POS in tagSostantivi:
           listaSostantivi.append(token)
    #calcolo la frequenza per ciascun sostantivo osservato
    freqSostantivo=collections.Counter(listaSostantivi)
    #trasformo l'oggetto Counter in una lista
    freqSostantivi=freqSostantivo.items() #contiene le frequenze dei sostantivi nel corpus
    return freqSostantivi

#questa funzione calcola la prob condizionata di bigrammi agg-sost
def CalcoloProbCondizionata(testoTokenizzato):
    #estraggo i bigrammi che rispettano le condizioni
    listaBigrammi=BigrammiAggettivoSostantivo(testoTokenizzato)
    #per ogni bigramma agg-sost calcolo la sua frequenza
    freqBigramma=collections.Counter(listaBigrammi)
    #trasformo l'oggetto Counter in una lista
    freqBigrammi=freqBigramma.items() #contiene le frequenze dei bigrammi agg-sost nel corpus
    #calcolo la frequenza degli aggettivi
    freqAggettivi=CalcolaFreqAggettivi(testoTokenizzato)
    #creo una lista con i bigrammi e le relative probabilita' condizionate
    lista=[]
    for (agg, freqA) in freqAggettivi:
        for ((elem1, elem2), freqB) in freqBigrammi:
            if agg==elem1: #accoppio gli aggettivi con il bigramma in cui compaiono
               #calcolo la probabilita' condizionata
               probCondizionata=freqB*1.0 / freqA*1.0
               elemento= (elem1, elem2), probCondizionata
               lista.append(elemento)
    return lista

#questa funzione estrae i 20 bigrammi agg-sost con probabilita' condizionata massima
def BigrammiProbCondizionata(testoTokenizzato):
    #dalla funzione precedente estraggo una lista con tutte le prob condizionate per ciascun bigramma
    listaProbCondiz=CalcoloProbCondizionata(testoTokenizzato)
    #ordino la lista per probabilita' decrescenti
    listaOrdinata= sorted(listaProbCondiz, key = lambda a: -a[1], reverse=False)
    #restituisco i primi 20 bigrammi
    return listaOrdinata[:20]

#questa funzione calcola la prob congiunta di bigrammi agg-sost
def CalcoloProbCongiunta(testoTokenizzato):
    #Per calcolare la probabilita' congiunta e' necessario usare la probabilita' condizionata
    #estraggo una lista con tutte le prob condizionate per ciascun bigramma
    listaProbCondiz=CalcoloProbCondizionata(testoTokenizzato)
    #calcolo la frequenza degli aggettivi
    freqAggettivi=CalcolaFreqAggettivi(testoTokenizzato)
    lista=[]
    for (agg, freqA) in freqAggettivi:
        for ((elem1, elem2), probCondiz) in listaProbCondiz:
            if agg==elem1: #accoppio gli aggettivi con il bigramma in cui compaiono
                #calcolo la probabilita' congiunta
                probCongiunta=probCondiz*(freqA*1.0/len(testoTokenizzato)*1.0)
                elemento= (elem1, elem2), probCongiunta
                lista.append(elemento)
    return lista

#questa funzione estrae i 20 bigrammi agg-sost con probabilita' congiunta massima
def BigrammiProbCongiunta(testoTokenizzato):  
    #dalla funzione precedente estraggo una lista con tutte le prob congiunte per ciascun bigramma
    listaProbCong=CalcoloProbCongiunta(testoTokenizzato) 
    #ordino la lista per probabilita' decrescenti
    listaOrdinata= sorted(listaProbCong, key = lambda a: -a[1], reverse=False)
    #restituisco i primi 20 bigrammi
    return listaOrdinata[:20]

#questa funzione applica la formula della probabilita' (definizione frequentista)
def CalcoloProbabilita(frequenza, testoTokenizzato):
    probabilita=frequenza*1.0/len(testoTokenizzato)*1.0
    return probabilita

#questa funzione calcola il valore della Local Mutual Information per ciascun bigramma
def CalcoloLMI(testoTokenizzato):
    #calcolo la frequenza degli aggettivi
    freqAggettivi=CalcolaFreqAggettivi(testoTokenizzato)
    #calcolo la frequenza dei sostantivi
    freqSostantivi=CalcolaFreqSostantivi(testoTokenizzato)
    #estraggo i bigrammi che rispettano le condizioni
    listaBigrammi=BigrammiAggettivoSostantivo(testoTokenizzato)
    #per ogni bigramma agg-sost calcolo la sua frequenza
    freqBigramma=collections.Counter(listaBigrammi)
    #trasformo l'oggetto Counter in una lista
    freqBigrammi=freqBigramma.items() #contiene le frequenze dei bigrammi agg-sost nel corpus
    lista=[]
    for ((elem1, elem2), freqB) in freqBigrammi:
        for (agg, freqA) in freqAggettivi:
            for (sost, freqS) in freqSostantivi:
                #per i bigrammi agg-sost calcolo sia la prob del bigramma che quella dei singoli elementi che lo compognono
                if (elem1==agg) and (elem2==sost):
                   probabilitaAgg=CalcoloProbabilita(freqA, testoTokenizzato)
                   probabilitaSost=CalcoloProbabilita(freqS, testoTokenizzato)
                   probabilitaBigr=CalcoloProbabilita(freqB, testoTokenizzato)
                   #calcolo la MI memorizzando i valori intermedi del calcolo in una variabile
                   var=probabilitaBigr*1.0/(probabilitaAgg*probabilitaSost)*1.0
                   MI=math.log(var, 2)
                   #dalla MI ricavo la LMI
                   LMI=freqB*MI
                   elemento= (elem1, elem2), LMI
                   lista.append(elemento)
    return lista

#questa funzione estrae i 20 bigrammi agg-sost con forza associativa massima
def BigrammiLMI(testoTokenizzato):
    #dalla funzione precedente estraggo una lista con tutti i valori di LMI per ciascun bigramma
    listaBigrammiLMI=CalcoloLMI(testoTokenizzato)
    #ordino la lista per LMI decrescenti
    listaOrdinata= sorted(listaBigrammiLMI, key = lambda a: -a[1], reverse=False)
    #restituisco i primi 20 bigrammi
    return listaOrdinata[:20]

#questa funzione estrae la frase con probabilita' massima, calcolata con un modello markoviano di ordine 0
def MarkovOrdine0(testoTokenizzato, frasi):
    lunghezzaCorpus=len(testoTokenizzato) 
    #tokenizzo frase per frase
    listaFrasiTokenizzate=[]
    for frase in frasi:
        fraseTokenizzata=nltk.word_tokenize(frase)
        listaFrasiTokenizzate.append(fraseTokenizzata)
    #calcolo la freqenza di ciascun token osservato nella frase
    freqToken=collections.Counter(fraseTokenizzata)
    prob=1.0
    probMassima=0.0
    #calcolo la probabilita' di ciascun token
    for fraseTokenizzata in listaFrasiTokenizzate:
      for tok in fraseTokenizzata:
        probToken=CalcoloProbabilita(freqToken[tok], fraseTokenizzata)
        #nel modello di ordine 0 la probabilita' della frase equivale al prodotto delle probabilita' dei singoli token
        prob=prob*probToken
        #estraggo la probabilita' massima
        if prob > probMassima:
           probMassima=prob
    return fraseTokenizzata, "-------probabilita':", probMassima

#questa funzione estrae la frase con probabilita' massima, calcolata con un modello markoviano di ordine 1
def MarkovOrdine1(testoTokenizzato, frasi):
    lunghezzaCorpus=len(testoTokenizzato)
    freqToken=collections.Counter(testoTokenizzato) #lista di frequenze di ogni token nel testo
    bigrammi=nltk.bigrams(testoTokenizzato) #estraggo i bigrammi
    freqBigrammi=collections.Counter(bigrammi) #lista di frequenze di ogni bigramma nel testo
    probMassima=0.0
    fraseProbMax=""
    for frase in frasi:
        i=0.0
        #per ogni frase la tokenizzo ed estraggo i bigrammi
        tokens=nltk.word_tokenize(frase)
        frasiBigrammi=nltk.bigrams(tokens)
        #considero solo le frasi lunghe almeno 10 token e i token con frequenza maggiore di 2
        if len(tokens)>=10:
           for tok in tokens:
               if freqToken[tok]<2:
                  i=i+1
        if i==len(tokens): #quando ho letto tutta la frase
           #inizio calcolando la probabilita' semplice del primo token della frase
           probIntermedia=freqToken[tokens[0]]*1.0/lunghezzaCorpus*1.0
           for bigramma in frasiBigrammi:
               #nel modello di ordine 1 bisogna calcolare, per ogni bigramma, la prob condizionata(del secondo token del bigramma dato il primo)
               probBigr=freqBigrammi[bigramma]*1.0/freqToken[bigramma[0]]*1.0
               #faccio il prodotto di ogni valore ottenuto
               probIntermedia=probIntermedia*probBigr
           #confronto la probabilita' della frase (ottenuta dal prodotto) con la prob massima
           if probIntermedia>probMassima:
              probMassima=probIntermedia
              fraseProbMax=frase
    #restituisco la frase con la relativa probabilita' massima
    return fraseProbMax, "-------probabilita':", probMassima

#questa funzione restituisce i 20 nomi di persona piu' frequenti nel corpus
def NomiPropriPersona(testoTokenizzato):
    tutteLeNE=[]
    listaPersone=[]
    listaLuoghi=[]
    tokensPOS=nltk.pos_tag(testoTokenizzato) #lista di bigrammi (token, POS)
    analisi=nltk.ne_chunk(tokensPOS) #rappresentazione ad albero
    IOBformat=nltk.chunk.tree2conllstr(analisi) #trasformo in formato IOB
    for nodo in analisi: #ciclo l'albero scorrendo i nodi
        if hasattr(nodo, 'label'): #controlla se e' un nodo intermedio
           if nodo.label() =="PERSON":
              elementoP= nodo.leaves()
              #converte l'elemento in una tupla (utile per elementi composti da piu token che altrimenti verrebbero restituiti in sottoliste)
              listaPersone.append(tuple(elementoP)) 
    #calcolo le frequenze
    freqPersone=collections.Counter(listaPersone)
    #restituisco i primi 20
    persone=freqPersone.most_common(20)
    return persone
 
#questa funzione restituisce i 20 nomi di luogo piu' frequenti nel corpus       
def NomiPropriLuogo(testoTokenizzato):
    tutteLeNE=[]
    listaPersone=[]
    listaLuoghi=[]
    tokensPOS=nltk.pos_tag(testoTokenizzato) #lista di bigrammi (token, POS)
    analisi=nltk.ne_chunk(tokensPOS) #rappresentazione ad albero
    IOBformat=nltk.chunk.tree2conllstr(analisi) #trasformo in formato IOB
    for nodo in analisi: #ciclo l'albero scorrendo i nodi
        if hasattr(nodo, 'label'): #controlla se e' un nodo intermedio 
           if nodo.label() =="GPE":
              elementoL= nodo.leaves()
              #converte l'elemento in una tupla (utile per elementi composti da piu token che altrimenti verrebbero restituiti in sottoliste)
              listaLuoghi.append(tuple(elementoL))  
    #calcolo le frequenze
    freqLuoghi=collections.Counter(listaLuoghi)
    #restituisco i primi 20
    luoghi=freqLuoghi.most_common(20)
    return luoghi

def main(file1, file2):
  fileInput1 = codecs.open(file1, "r", "utf-8")
  fileInput2 = codecs.open(file2, "r", "utf-8")
  var1 = fileInput1.read()
  var2 = fileInput2.read()
  #carico il modello statistico utilizzato dalla funzione tokenize
  sent_tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
  #divido i testi dei due file in frasi 
  frasi1 = sent_tokenizer.tokenize(var1) 
  frasi2 = sent_tokenizer.tokenize(var2)
  #tokenizzo il file1 
  testoTokenizzato1=TokenizzaTesto(frasi1)
  #tokenizzo il file2
  testoTokenizzato2=TokenizzaTesto(frasi2)
  #memorizzo su due variabili i due testi annotati sulla base delle Part-Of-Speech
  POStag1=nltk.pos_tag(testoTokenizzato1)
  POStag2=nltk.pos_tag(testoTokenizzato2)
  
  print "\n\nPROGRAMMA #2\n"

  #le 10 POS piu' frequenti
  POSFrequenti1=POSFrequenti(testoTokenizzato1)
  POSFrequenti2=POSFrequenti(testoTokenizzato2)
  print "\nLe 10 POS piu' frequenti del file", file1, "(ordinate in senso descrescente), sono:\n"
  for POSFrequente1 in POSFrequenti1:
      print POSFrequente1
  print "\n\nLe 10 POS piu' frequenti del file", file2, "(ordinate in senso descrescente), sono:\n"
  for POSFrequente2 in POSFrequenti2:
      print POSFrequente2

  #i 20 token piu' frequenti
  tokenFrequenti1=TokenFrequenti(testoTokenizzato1)
  tokenFrequenti2=TokenFrequenti(testoTokenizzato2)
  print "\n\nI 20 token piu' frequenti nel file", file1, "sono:\n"
  for tokenFrequente1 in tokenFrequenti1:
      print tokenFrequente1
  print "\n\nI 20 token piu' frequenti nel file", file2, "sono:\n"
  for tokenFrequente2 in tokenFrequenti2:
      print tokenFrequente2
  
  #i 20 bigrammi piu' frequenti
  bigrammi1=BigrammiFrequenti(testoTokenizzato1)
  bigrammi2=BigrammiFrequenti(testoTokenizzato2)
  print "\n\nI 20 bigrammi piu' frequenti nel file", file1, "sono:\n"
  for bigramma1 in bigrammi1:
     print bigramma1
  print "\n\nI 20 bigrammi piu' frequenti nel file", file2, "sono:\n"
  for bigramma2 in bigrammi2:
     print bigramma2
  
  #i 20 trigrammi piu' frequenti
  trigrammi1=TrigrammiFrequenti(testoTokenizzato1)
  trigrammi2=TrigrammiFrequenti(testoTokenizzato2)
  print "\n\nI 20 trigrammi piu' frequenti nel file", file1, "sono:\n"
  for trigramma1 in trigrammi1:
     print trigramma1
  print "\n\nI 20 trigrammi piu' frequenti nel file", file2, "sono:\n"
  for trigramma2 in trigrammi2:
     print trigramma2

  #i 20 bigrammi aggettivo-sostantivo con probabilita' condizionata massima
  bigrammiProbCondizionata1=BigrammiProbCondizionata(testoTokenizzato1)
  bigrammiProbCondizionata2=BigrammiProbCondizionata(testoTokenizzato2)
  print "\n\nI 20 bigrammi aggettivo-sostantivo con probabilita' condizionata massima nel file", file1, "sono:\n"
  for bigrammaProbCondizionata1 in bigrammiProbCondizionata1:
      print bigrammaProbCondizionata1
  print "\n\nI 20 bigrammi aggettivo-sostantivo con probabilita' condizionata massima nel file", file2, "sono:\n"
  for bigrammaProbCondizionata2 in bigrammiProbCondizionata2:
      print bigrammaProbCondizionata2

  #i 20 bigrammi aggettivo-sostantivo con probabilita' congiunta massima
  bigrammiProbCongiunta1=BigrammiProbCongiunta(testoTokenizzato1)
  bigrammiProbCongiunta2=BigrammiProbCongiunta(testoTokenizzato2)
  print "\n\nI 20 bigrammi aggettivo-sostantivo con probabilita' congiunta massima nel file", file1, "sono:\n"
  for bigrammaProbCongiunta1 in bigrammiProbCongiunta1:
      print bigrammaProbCongiunta1
  print "\n\nI 20 bigrammi aggettivo-sostantivo con probabilita' congiunta massima nel file", file2, "sono:\n"
  for bigrammaProbCongiunta2 in bigrammiProbCongiunta2:
      print bigrammaProbCongiunta2

  #i 20 bigrammi aggettivo-sostantivo con forza associativa massima
  bigrammiLMI1=BigrammiLMI(testoTokenizzato1)
  bigrammiLMI2=BigrammiLMI(testoTokenizzato2)
  print "\n\nI 20 bigrammi aggettivo-sostantivo con forza associativa massima nel file", file1, "sono:\n"
  for bigrammaLMI1 in bigrammiLMI1:
      print bigrammaLMI1
  print "\n\nI 20 bigrammi aggettivo-sostantivo con forza associativa massima nel file", file2, "sono:\n"
  for bigrammaLMI2 in bigrammiLMI2:
      print bigrammaLMI2

  #Entita' Nominate
  persone1=NomiPropriPersona(testoTokenizzato1)
  persone2=NomiPropriPersona(testoTokenizzato2)
  luoghi1=NomiPropriLuogo(testoTokenizzato1)
  luoghi2=NomiPropriLuogo(testoTokenizzato2)
  print "\n\nNel file", file1, "i 20 nomi propri di persona piu' frequenti sono:\n" 
  for persona1 in persone1:
      print persona1
  print "\nNel file", file1, "i 20 nomi propri di luogo piu' frequenti sono:\n" 
  for luogo1 in luoghi1:
      print luogo1
  print "\n\nNel file", file2, "i 20 nomi propri di persona piu' frequenti sono:\n" 
  for persona2 in persone2:
      print persona2
  print "\nNel file", file2, "i 20 nomi propri di luogo piu' frequenti sono:\n" 
  for luogo2 in luoghi2:
      print luogo2
  
  #le due frasi con probabilita' piu' alta calcolate con modello di ordine 0
  probFrase01=MarkovOrdine0(testoTokenizzato1, frasi1)
  print "\n\nLa frase con probabilita' piu' alta, calcolata con catena di Markov di ordine 0, nel file", file1, " e':\n", probFrase01
  probFrase02=MarkovOrdine0(testoTokenizzato2, frasi2)
  print "\n\nLa frase con probabilita' piu' alta, calcolata con catena di Markov di ordine 0, nel file", file2, " e':\n", probFrase02

  #le due frasi con probabilita' piu' alta calcolate con modello di ordine 1
  probFrase11=MarkovOrdine1(testoTokenizzato1, frasi1)
  print "\n\nLa frase con probabilita' piu' alta, calcolata con catena di Markov di ordine 1, nel file", file1, " e':\n", probFrase11
  probFrase12=MarkovOrdine1(testoTokenizzato2, frasi2)
  print "\n\nLa frase con probabilita' piu' alta, calcolata con catena di Markov di ordine 1, nel file", file2, " e':\n", probFrase12  

main(sys.argv[1], sys.argv[2])

PROGRAMMA #1


Il file clinton e' lungo 8156.0 token
Il file trump e' lungo 6479.0 token
clinton e' piu' lungo di trump

Le frasi del file clinton hanno lunghezza media pari a 18.8360277136 token
Le frasi del file trump hanno lunghezza media pari a 20.4384858044 token

Il vocabolario del file clinton ha 1909 tipi
Il vocabolario del file trump ha 1244 tipi
clinton ha un vocabolario piu' ricco di trump

Grandezza del vocabolario del file clinton all'aumento del corpus per porzioni incrementali di 1000 token:
465
742
981
1190
1420
1575
1757
1890
1909
1909

Grandezza del vocabolario del file trump all'aumento del corpus per porzioni incrementali di 1000 token:
371
631
880
1055
1157
1218
1244
1244
1244
1244

Notiamo dal risultato che il vocabolario tende a crescere sempre piu' lentamente.

Ricchezza lessicale del file clinton all'aumento del corpus per porzioni incrementali di 1000 token:
0.465
0.371
0.327
0.2975
0.284
0.2625
0.251
0.23625
0.212111111111
0.1909

Ricchezza lessicale del file trump all'aumento del corpus per porzioni incrementali di 1000 token:
0.371
0.3155
0.293333333333
0.26375
0.2314
0.203
0.177714285714
0.1555
0.138222222222
0.1244
Piu' e' alto il valore della Type-Token-Ratio, maggiore e' la ricchezza del vocabolario

Il rapporto sostantivi/verbi nel file clinton e':  1.47268408551
Il rapporto sostantivi/verbi nel file trump e':  1.81444332999

La densita' lessicale del file clinton e':  0.56704929102
La densita' lessicale del file trump e':  0.574747474747

PROGRAMMA #2


Le 10 POS piu' frequenti del file clinton (ordinate in senso descrescente), sono:

('NN', 899)
('IN', 816)
('DT', 661)
('JJ', 550)
('PRP', 479)
('NNS', 462)
('VB', 460)
('NNP', 449)
('.', 433)
('RB', 395)


Le 10 POS piu' frequenti del file trump (ordinate in senso descrescente), sono:

('NN', 855)
('IN', 584)
('NNP', 558)
('DT', 496)
('JJ', 381)
('VB', 370)
('NNS', 364)
('.', 297)
(',', 262)
('CC', 251)


I 20 token piu' frequenti nel file clinton sono:

(u'the', 314)
(u'to', 313)
(u'and', 246)
(u'of', 150)
(u'a', 133)
(u'I', 120)
(u'that', 104)
(u'in', 93)
(u"'s", 93)
(u'we', 92)
(u'for', 87)
(u'it', 69)
(u'our', 67)
(u'is', 61)
(u'will', 61)
(u'Iran', 57)
(u'on', 54)
(u'have', 53)
(u'with', 52)
(u'as', 52)


I 20 token piu' frequenti nel file trump sono:

(u'the', 261)
(u'and', 223)
(u'to', 196)
(u'of', 153)
(u'will', 118)
(u'a', 96)
(u'our', 92)
(u'for', 63)
(u'is', 62)
(u'in', 60)
(u'We', 51)
(u'we', 50)
(u'Hillary', 49)
(u'American', 44)
(u'that', 41)
(u'I', 40)
(u'on', 37)
(u'are', 35)
(u'government', 33)
(u'plan', 32)


I 20 bigrammi piu' frequenti nel file clinton sono:

((u'to', u'be'), 19)
((u'United', u'States'), 18)
((u'Iran', u"'s"), 17)
((u'I', u'will'), 15)
((u'need', u'to'), 13)
((u'Cuban', u'people'), 12)
((u'have', u'to'), 11)
((u'will', u'be'), 11)
((u'I', u'would'), 11)
((u'it', u"'s"), 10)
((u'It', u"'s"), 10)
((u'I', u"'ll"), 10)
((u'I', u"'m"), 9)
((u'is', u'not'), 9)
((u'want', u'to'), 8)
((u'we', u'will'), 8)
((u'Latin', u'America'), 8)
((u'ca', u"n't"), 8)
((u'I', u'believe'), 8)
((u'we', u'need'), 8)


I 20 bigrammi piu' frequenti nel file trump sono:

((u'going', u'to'), 31)
((u'We', u'will'), 25)
((u'are', u'going'), 21)
((u'we', u'will'), 18)
((u'plan', u'to'), 17)
((u'We', u'are'), 17)
((u'will', u'also'), 16)
((u'Hillary', u'Clinton'), 16)
((u'United', u'States'), 15)
((u'Mr.', u'Trump'), 14)
((u'our', u'government'), 12)
((u'rebuild', u'our'), 12)
((u'our', u'country'), 12)
((u'lied', u'to'), 11)
((u'I', u'will'), 11)
((u'we', u'are'), 10)
((u'American', u'Voter'), 10)
((u'illegal', u'immigration'), 10)
((u'Trump', u'Administration'), 10)
((u'will', u'be'), 10)


I 20 trigrammi piu' frequenti nel file clinton sono:

((u'we', u'need', u'to'), 7)
((u'We', u'ca', u"n't"), 5)
((u'I', u'want', u'to'), 5)
((u'need', u'to', u'be'), 5)
((u'We', u'have', u'to'), 4)
((u'to', u'step', u'up'), 4)
((u'do', u"n't", u'want'), 4)
((u'go', u'back', u'to'), 4)
((u'be', u'able', u'to'), 4)
((u"'s", u'why', u'I'), 4)
((u'Cuban', u'American', u'community'), 4)
((u'Iran', u"'s", u'nuclear'), 3)
((u'we', u'have', u'to'), 3)
((u"n't", u'go', u'back'), 3)
((u'We', u'need', u'to'), 3)
((u'to', u'make', u'it'), 3)
((u'ca', u"n't", u'go'), 3)
((u'They', u'do', u"n't"), 3)
((u'Iran', u'tries', u'to'), 2)
((u'we', u"'ve", u'got'), 2)


I 20 trigrammi piu' frequenti nel file trump sono:

((u'are', u'going', u'to'), 21)
((u'We', u'are', u'going'), 14)
((u'We', u'will', u'also'), 10)
((u'Trump', u'Administration', u'will'), 9)
((u'Mr.', u'Trump', u'will'), 9)
((u'biggest', u'tax', u'cut'), 7)
((u'made', u'13', u'phones'), 7)
((u'lied', u'to', u'Congress'), 7)
((u'13', u'phones', u'disappear'), 7)
((u'to', u'15', u'percent'), 7)
((u'deleted', u'33,000', u'emails'), 6)
((u'Radical', u'Islamic', u'Terrorists'), 6)
((u'keep', u'Radical', u'Islamic'), 6)
((u'to', u'bring', u'back'), 6)
((u'unnecessary', u'job-killing', u'regulation'), 5)
((u'we', u'are', u'going'), 5)
((u'rebuild', u'our', u'military'), 5)
((u'Supreme', u'Court', u'who'), 5)
((u'who', u'will', u'uphold'), 5)
((u'reduce', u'surging', u'crime'), 5)


I 20 bigrammi aggettivo-sostantivo con probabilita' condizionata massima nel file clinton sono:

((u'malicious', u'activity'), 1.0)
((u'uranium', u'enrichment'), 1.0)
((u'Israel-or', u'talks'), 1.0)
((u'fifty', u'years'), 1.0)
((u'bright', u'future'), 1.0)
((u'interim', u'agreement'), 1.0)
((u'multilateral', u'talks'), 1.0)
((u'abundant', u'energy'), 1.0)
((u'religious', u'groups'), 1.0)
((u'previous', u'attempts'), 1.0)
((u'21st', u'century'), 1.0)
((u'northern', u'Israel'), 1.0)
((u'allies-including', u'intelligence'), 1.0)
((u'courageous', u'Ladies'), 1.0)
((u'only', u'answer'), 1.0)
((u'compelling', u'advertisement'), 1.0)
((u'advanced', u'radar'), 1.0)
((u'constant', u'threat'), 1.0)
((u'enhanced-our', u'capacity'), 1.0)
((u'executive', u'authority'), 1.0)


I 20 bigrammi aggettivo-sostantivo con probabilita' condizionata massima nel file trump sono:

((u'executive', u'branch'), 1.0)
((u'Public', u'Corruption'), 1.0)
((u'Congressional', u'Subpoena'), 1.0)
((u'previous', u'deportation'), 1.0)
((u'Democratic', u'policies'), 1.0)
((u'longstanding', u'ties'), 1.0)
((u'failed', u'elites'), 1.0)
((u'Clinton-backed', u'deal'), 1.0)
((u'civil', u'rights'), 1.0)
((u'easy', u'way'), 1.0)
((u'congressional', u'seats'), 1.0)
((u'real', u'change'), 1.0)
((u'confidential', u'information'), 1.0)
((u'spur', u'innovation'), 1.0)
((u'advanced', u'manufacturing'), 1.0)
((u'Pay-For-Play', u'scheme'), 1.0)
((u'Trump', u'Administration'), 1.0)
((u'middle-class', u'family'), 1.0)
((u'unnecessary', u'job-killing'), 1.0)
((u'common', u'core'), 1.0)


I 20 bigrammi aggettivo-sostantivo con probabilita' congiunta massima nel file clinton sono:

((u'nuclear', u'weapons'), 0.0006130456105934282)
((u'Cuban', u'American'), 0.0004904364884747424)
((u'human', u'rights'), 0.0003678273663560569)
((u'foreign', u'policy'), 0.0003678273663560569)
((u'civil', u'society'), 0.0003678273663560569)
((u'next', u'president'), 0.0003678273663560569)
((u'long', u'time'), 0.00036782736635605686)
((u'American', u'leadership'), 0.00036782736635605686)
((u'nuclear', u'program'), 0.00036782736635605686)
((u'global', u'coalition'), 0.0002452182442373713)
((u'broader', u'Iran'), 0.0002452182442373713)
((u'failed', u'policy'), 0.0002452182442373713)
((u'bad', u'behavior'), 0.0002452182442373713)
((u'bad', u'actors'), 0.0002452182442373713)
((u'free', u'expression'), 0.0002452182442373713)
((u'many', u'others'), 0.0002452182442373713)
((u'additional', u'steps'), 0.0002452182442373713)
((u'political', u'prisoners'), 0.0002452182442373713)
((u'dangerous', u'path'), 0.0002452182442373713)
((u'Iranian', u'aggression'), 0.0002452182442373713)


I 20 bigrammi aggettivo-sostantivo con probabilita' congiunta massima nel file trump sono:

((u'illegal', u'immigration'), 0.001543448062972681)
((u'American', u'Voter'), 0.0015434480629726809)
((u'biggest', u'tax'), 0.0010804136440808766)
((u'illegal', u'server'), 0.0007717240314863406)
((u'unnecessary', u'job-killing'), 0.0007717240314863404)
((u'inner', u'cities'), 0.0007717240314863404)
((u'open', u'borders'), 0.0006173792251890724)
((u'illegal', u'Obama'), 0.0006173792251890724)
((u'middle', u'class'), 0.0006173792251890724)
((u'Real', u'change'), 0.0006173792251890724)
((u'other', u'countries'), 0.0006173792251890723)
((u'illegal', u'conduct'), 0.00046303441889180435)
((u'Congressional', u'Subpoena'), 0.0004630344188918043)
((u'elected', u'President'), 0.0004630344188918043)
((u'Republican', u'House'), 0.0004630344188918043)
((u'email', u'evidence'), 0.0004630344188918043)
((u'Syrian', u'Refugee'), 0.0004630344188918043)
((u'American', u'business'), 0.0004630344188918043)
((u'highest', u'levels'), 0.0004630344188918043)
((u'special', u'interests'), 0.0004630344188918043)


I 20 bigrammi aggettivo-sostantivo con forza associativa massima nel file clinton sono:

((u'nuclear', u'weapons'), 39.32181521535816)
((u'Cuban', u'American'), 37.515744863605555)
((u'civil', u'society'), 31.226050677886327)
((u'human', u'rights'), 29.980938180049794)
((u'foreign', u'policy'), 28.6026433241379)
((u'next', u'president'), 28.22605067788632)
((u'long', u'time'), 25.04936961072562)
((u'terrorist', u'organization'), 22.817367118590884)
((u'nuclear', u'program'), 22.04936961072562)
((u'honest', u'disagreements'), 21.987292120033192)
((u'bad', u'actors'), 21.987292120033192)
((u'American', u'leadership'), 21.55887341387698)
((u'additional', u'steps'), 20.817367118590884)
((u'bad', u'behavior'), 19.987292120033192)
((u'political', u'prisoners'), 19.987292120033192)
((u'free', u'expression'), 19.647442117148568)
((u'dangerous', u'path'), 19.34343593025847)
((u'Iranian', u'aggression'), 19.34343593025847)
((u'global', u'coalition'), 18.81736711859088)
((u'failed', u'policy'), 17.898503881316287)


I 20 bigrammi aggettivo-sostantivo con forza associativa massima nel file trump sono:

((u'illegal', u'immigration'), 75.82604101072937)
((u'American', u'Voter'), 75.74092601217419)
((u'biggest', u'tax'), 57.88466613782299)
((u'unnecessary', u'job-killing'), 51.69813673790198)
((u'inner', u'cities'), 49.27100260205077)
((u'middle', u'class'), 41.358509390321586)
((u'other', u'countries'), 38.129089702091164)
((u'Real', u'change'), 37.966521764101785)
((u'illegal', u'server'), 35.56559408885858)
((u'open', u'borders'), 35.52078291577239)
((u'natural', u'gas'), 33.229778825239805)
((u'Congressional', u'Subpoena'), 33.229778825239805)
((u'Republican', u'House'), 33.229778825239805)
((u'Syrian', u'Refugee'), 31.984666327403275)
((u'email', u'evidence'), 31.984666327403275)
((u'special', u'interests'), 31.01888204274119)
((u'clean', u'coal'), 30.739553829566745)
((u'illegal', u'Obama'), 30.556750517757216)
((u'highest', u'levels'), 30.229778825239805)
((u'massive', u'inflow'), 29.562601561230466)


Nel file clinton i 20 nomi propri di persona piu' frequenti sono:

(((u'Latin', 'NNP'), (u'America', 'NNP')), 6)
(((u'Cuba', 'NNP'),), 4)
(((u'Obama', 'NNP'),), 4)
(((u'Strobe', 'NNP'),), 3)
(((u'Pope', 'NNP'), (u'Francis', 'NNP')), 2)
(((u'Frank', 'NNP'),), 2)
(((u'Third', 'NNP'),), 2)
(((u'Ernie', 'NNP'), (u'Moniz', 'NNP')), 1)
(((u'Bill', 'NNP'), (u'Burns', 'NNP')), 1)
(((u'Putin', 'NNP'),), 1)
(((u'Chuck', 'NNP'), (u'Schumer', 'NNP')), 1)
(((u'Venezuela', 'NNP'),), 1)
(((u'Frankly', 'NNP'),), 1)
(((u'Ebola', 'NNP'),), 1)
(((u'Tehran', 'NNP'),), 1)
(((u'John', 'NNP'), (u'Kerry', 'NNP')), 1)
(((u'Martin', 'NNP'),), 1)
(((u'Capitol', 'NNP'), (u'Hill', 'NNP')), 1)
(((u'Google', 'NNP'),), 1)
(((u'Joe', 'NNP'),), 1)

Nel file clinton i 20 nomi propri di luogo piu' frequenti sono:

(((u'Iran', 'NNP'),), 55)
(((u'American', 'JJ'),), 21)
(((u'Israel', 'NNP'),), 21)
(((u'United', 'NNP'), (u'States', 'NNPS')), 18)
(((u'Cuban', 'NNP'),), 16)
(((u'Cuba', 'NNP'),), 15)
(((u'America', 'NNP'),), 14)
(((u'Iranian', 'JJ'),), 10)
(((u'Cubans', 'NNPS'),), 6)
(((u'U.S.', 'NNP'),), 4)
(((u'Israeli', 'NNP'),), 3)
(((u'Havana', 'NNP'),), 3)
(((u'Cuban', 'JJ'),), 3)
(((u'Iranians', 'NNPS'),), 3)
(((u'American', 'NNP'),), 3)
(((u'Americans', 'NNPS'),), 3)
(((u'Castro', 'NNP'),), 2)
(((u'Yemen', 'NNP'),), 2)
(((u'White', 'NNP'),), 2)
(((u'Syrian', 'JJ'),), 2)


Nel file trump i 20 nomi propri di persona piu' frequenti sono:

(((u'Hillary', 'NNP'),), 28)
(((u'Hillary', 'NNP'), (u'Clinton', 'NNP')), 16)
(((u'Mr.', 'NNP'), (u'Trump', 'NNP')), 14)
(((u'Obamacare', 'NNP'),), 9)
(((u'Ronald', 'NNP'), (u'Reagan', 'NNP')), 7)
(((u'Radical', 'NNP'), (u'Islamic', 'NNP')), 6)
(((u'Bill', 'NNP'), (u'Clinton', 'NNP')), 2)
(((u'Bill', 'NNP'),), 2)
(((u'Flint', 'NNP'),), 2)
(((u'Clinton', 'NNP'),), 2)
(((u'Hillary', 'JJ'),), 2)
(((u'Black', 'NNP'), (u'America', 'NNP')), 2)
(((u'Michigan', 'NNP'),), 2)
(((u'Currency', 'NNP'), (u'Manipulation', 'NNP')), 2)
(((u'Real', 'NNP'),), 2)
(((u'Naval', 'NNP'), (u'Air', 'NNP')), 1)
(((u'Obama', 'NNP'),), 1)
(((u'Donald', 'NNP'), (u'Trump', 'NNP')), 1)
(((u'Coast', 'NNP'), (u'Guard', 'NNP')), 1)
(((u'School', 'NNP'),), 1)

Nel file trump i 20 nomi propri di luogo piu' frequenti sono:

(((u'American', 'JJ'),), 21)
(((u'United', 'NNP'), (u'States', 'NNPS')), 15)
(((u'America', 'NNP'),), 14)
(((u'American', 'NNP'),), 10)
(((u'Washington', 'NNP'),), 9)
(((u'China', 'NNP'),), 5)
(((u'Middle', 'NNP'),), 4)
(((u'Florida', 'NNP'),), 3)
(((u'D.C.', 'NNP'),), 3)
(((u'Pennsylvania', 'NNP'),), 2)
(((u'Michigan', 'NNP'),), 2)
(((u'North', 'NNP'), (u'Carolina', 'NNP')), 2)
(((u'Arizona', 'NNP'),), 2)
(((u'U.S.', 'NNP'),), 1)
(((u'State', 'NNP'),), 1)
(((u'Nevada', 'NNP'),), 1)
(((u'Detroit', 'NNP'),), 1)
(((u'Veterans', 'NNPS'),), 1)
(((u'Mexico', 'NNP'),), 1)
(((u'New', 'NNP'), (u'Navy', 'NNP')), 1)


La frase con probabilita' piu' alta, calcolata con catena di Markov di ordine 0, nel file clinton  e':
([u'Thank', u'you', u'.', u"''"], "-------probabilita':", 0.3333333333333333)


La frase con probabilita' piu' alta, calcolata con catena di Markov di ordine 0, nel file trump  e':
([u'...', u'We', u'are', u'fighting', u'to', u'unlock', u'the', u'potential', u'of', u'every', u'American', u'community', u',', u'and', u'every', u'American', u'family', u',', u'who', u'hope', u'and', u'pray', u'and', u'yearn', u'for', u'a', u'better', u'future', u'.', u"''"], "-------probabilita':", 0.0)


La frase con probabilita' piu' alta, calcolata con catena di Markov di ordine 1, nel file clinton  e':
('', "-------probabilita':", 0.0)


La frase con probabilita' piu' alta, calcolata con catena di Markov di ordine 1, nel file trump  e':
('', "-------probabilita':", 0.0)