APPUNTI CORSO R

A cura di: Valentina Orlandi

Simone Rosati
LEZIONE 2
#CREAZIONE VETTORI LOGICI E VERIFICARNE LA CLASSE
A<-c(TRUE)
A
B<-c(FALSE)
B
class(A)
class(B)
length(C) #per vedere la lunghezza di vettori con più elementi (esempio C<-(A,B))

A & B #INTERSEZIONE
!B #B NEGATO (ovvero la negazione di B che èssendo falso, è vero!)
A&!B #A INTERSECATO B NEGATO (dato che entrambi si verificano è vero)

#CREAZIONE VETTORI NUMERICI (si possono fare operazioni)

a<-c(2)
b<-c(4)
factor(b) #calcolo fattoriale
choose(b,a) #calcolo del coefficiente binomiale (es.4 su 2)

#OPERAZIONI SU VETTORI CON PIU' ELEMENTI

#ad esempio se fai a/2, ogni elemento di a verrà diviso per due)
#per considerare solo un elemento del vettore, ad esempio il numero nella posizione 2
x[2]
#per accedere a più elementi
x[1:2]
x[x>0]

#come visualizzare gli elementi che soddisfano la condizione logica "compreso o uguale a 2 e 8"
x<-c(1,2,3,4,5,6,8,9,10)
x[x>=2&x<8]

#CREAZIONE DI UN VETTORE PARTENDO DA UNO ESISTENTE

#contente x
y1<-c(x,1,2,4)
#escludendo l'elemento di posizione tre
y2<-x[-c(3)]

#DIVERSI MODI DI CREARE UN VETTORE NUMERICO

x1<-c(1,2,3,4,5)
x2<-c(1:5)

x3<-seq(1,5,by=1) #1 è la partenza, 5 è l'arrivo, by è il passo ad esmpio se metti passo 0.5 si avrà una
sequenza tale 1.5 2 2.5 e così via. SE SI VUOLE PARTIRE DA 50 E ARRIVARE A -50 IL PASSO DEVE ESSERE
NEGATIVO

x4<-rep(1,5) #permette di replicare il numero 1 per 5 volte, e funziona anche per replicare vettori
x1==x2 #per verificare l'uguaglianza di 2 diversi vettori
all(x1==x2) #per sintetizzare i risultati (ad esempio se sono tutti T e un solo F, il risultato sarà FALSE)

#OPERAZIONI
sum(x1) #somma di tutti gli elementi di x1
sum(x1,x3) #somma di tutti gli elementi di x1 e x3
prod(x1) #prodotto di tutti gli elementi di x1
length(x1) #lunghezza
range(x1) #per visualizzare sia il valore max che min
min(x1) #per visualizzare il valore minimo
max(x1) #per visualizzare il valore massimo

#WHICH permette di determinare la posizione nel vettore degli elemnti che soddisfano il criterio
contenuto nelle(...)
x<-c(12,-3,15,4,25,29)
which(x>16) #ci da le posizioni degli elementi maggiori a 16, in tal caso la posizione 5 e 6

#ORDINARE GLI ELEMENTI CON SORT

x<-c(20,18,10,34,45)
x_ord<-sort(x,decreasing=F) #se volessimo riordinarli in modo decrescente "decreasing=T"

#VALORI MANCANTI NA, non permettono operazioni senza determinare la loro omissione
x<-c(1,2,3,NA,7,9,10)
#somma del vettore x escludendo il valore mancante
sum(na.omit(x))
sum(x.na.rm=TRUE)
#verifica della presenza di NA
is.na(x)
!is.na(x)
#sostituire i valori mancanti
x_2<-replace(x,is.na(x),300) #sostituisce ad NA il numero 300
x_3<-replace(x,is.na(x),sum(x,na.rm=TRUE)) #sostituisce ad NA la somma

#VETTORI CARATTERI, se ne può verificare la classe e la lunghezza e si possono riordinare con sort in
ordine alfabetico
nomi<-c("Anna","Pasquale","Giovanni","Antonio")
nchar(nomi) #lunghezza di ogni singola stringa, ovvero di ogni elemento del vettore (in tal caso 4,8,8,7)

#incollare ad un oggetto un altro elemento con un separatore

nomi_cognomi<-paste(nomi, "Rossi",sep=" ") #incollo il cognome Rossi a tutti

past(rep("M",25),1:25,sep="_") #replica M per 25 volte, li numera da 1 a 25 separandoli con_

substring(nomi,3,5) #estrae dall'oggetto nomi le stringhe, ovvero le lettere dalla terza alla quinta posizione
del nome

as.numeric(gregexpr(pattern=" ","Anna Rossi")) #permette di individuare nella stringa "Anna Rossi" la

posizione, in questo caso dello spazio

#separare i nomi dai cognomi

nomi_cognomi<-c("Anna Rossi","Pasquale Verde","Giovanni Nero")
white_space<-as.numeric(gregexpr(pattern=" ",nomi_cognomi)) #posizione dello spazio
lungh_nomi_cog<-nchar(nomi_cognomi) #lunghezza di ogni stringa
nomi_estrat<-substring(nomi_cognomi,1,white_space-1) #estrae una sottostringa da nomi_cognomi che
parte dalla prima posizione e che arriva allo spazio bianco (si estraggono solo i nomi)
cognomi_estrat<-substring(nomi_cognomi,white_space-1,lung_nomi_cog) #estrae solo i cognomi

#VETTORE ALFA-NUMERICO (classe= character)

mix<-c(3,4,"Rossi")
#CREAZIONE DI FATTORI
ripart_geo<-c("Nord","Nord","Est","Ovest","Sud","Sud") #vettore
factor_ripart_geo<-factor(ripart_geo) #permette di trasformare un vettore in fattore e determina i livelli
#CAMBIARE ORDINE DEI LIVELLI
levels(factor_ripart_geo)
levels(factor_ripart_geo)[c(2,3,1,4)] #per ordinare nord(che era nella posizione 2)-ovest(3)-est(1)-sud(4)

LEZIONE 3
#COSTRUIRE UNA MATRICE
matrice<-matrix(data=c(1.2, 34, 4.3,4.2),nrow=2,ncol=2) #DATA=elementi nella matrice; NROW=numero
righe; NCOL=numero colonne- le posiziona in colonna (alto a sinistra 1.2, basso a sx 34…)

mat2<-matrix(data=50:1,nrow=10,ncol=5) #sequenza decrescente, da 50 a 1 nella direzione della colonna

mat1<-matrix(data=50,nrow=10,ncol=5) #matrice con stesso elemento che si ripete

#COSTRUIRE UNA MATRICE PARTENDO DA UN VETTORE z

z<-seq(from=-10, to=10, length.out=9) #elementi=numeri da -10 a 10; length.out=voglio 9 numeri presi
nell’intervallo da -10 e 10 che siano equidistanziati e che incorporano il valore inf e sup dell’intervallo

mat4<-matrix(data=z,nrow=3,ncol=3) #per colonna

matrice5<-matrix(data=z,nrow=3,ncol=3,byrow=T) #nella direzione della riga (byrow=FALSE lo ordina come
se non ci fosse tale indicazione

#HAI DUE VETTORI CHE VUOI UNIRE PER FORMARE UNA MATRICE
mat6<-rbind(c(3,4,8,6),c(2,0,5,3)) #primo vettore=1 riga; secondo vettore=2 riga)
mat7<-cbind(c(3,4,8,6),c(2,0,5,3)) #primo vettore= 1 colonna; secondo vettore=2 colonna..)

#UNIRE DUE MATRICI

mat8<-rbind(mat2,mat3) #per riga
mat9<-cbind(mat2,mat3) #per colonna

#MATRICE DIAGONALE= TUTTI 0 TRANNE NELLA DIAGONALE (sia quadrata che rettangolare)
unit1<-diag(rep(1,5),nrow=5,ncol=5) # ripete il valore 1 per 5 volte nel riempire la diagonale principale
mm<-diag(1,nrow=5,ncol=5) #stesso risultato

diag(mat3) #per vedere diagonale principale di una matrice già creata (sia quadrata che non)
diag(mat1)<-c(15,20,4,3,2) #ridefinizione diagonale principale di una matrice esistente

#MATRICE DI ELEMENTI LOGICI

mat10<-matrix(data=FALSE,nrow=5,ncol=8) #matrice 5x8 formata da tutti false
mat12<-matrix(data=c(FALSE,TRUE,TRUE,FALSE),nrow=5,ncol=8,byrow=TRUE) #con byrow per riga

#replica con elementi non multipli, con segnalazione errore da R

mat13<-matrix(data=c(FALSE,TRUE,TRUE),nrow=5,ncol=8,byrow=TRUE)

mat14<-matrix(data="Hello",nrow=4,ncol=2) #matrice con character

mat15<-matrix(data=c(rep("Hello",4),rep("Bye",4)),nrow=5,ncol=8) #primi 4 elementi replica hello e
successivi 4 elementi replica bye

#OPERAZIONI
length(mat1) #numero di tutti gli elementi della matrice
c(mat1) #vettorizzazione matrice, cioè destrutturazione matrice in vettore
dim(mat1) #per conoscere numero righe e colonne (primo numero=righe, 2=colonne) -non si applica ai
vettori
nrow(mat1) #numero di righe
ncol(mat1) #numero colonne
head(mat9) #permette di vedere solo le prime 6 righe di una matrice molto grande
tail(mat9) #permette di vedere le ultime 6 righe di una matrice molto grande
t(mat9) #trasporto, invertire righe e colonne
det(matrice) #determinante, solo per matrici quadrate
solve(matrice) #per invertite una matrice quadrata (è invertibile solo se il det è diverso da 0)
sum(mat1) #somma tutti gli elementi della matrice
prod(mat1) #prodotto tra tutti gli elementi della matrice

cumsum(mat1) #somma sequenziale degli elementi della matrice (primo elemento=a11; secondo
elemento=a11+a21… quindi procede per colonna)
rowSums(mat1) #somma degli elementi di ogni riga
colSums(mat1) #somma degli elementi di ogni colonna
rowMeans(mat1) #media per riga
colMeans(mat1) #media per colonna

#OPERAZIONI CON MATRICE FORMATA DA ELEMENTI LOGICI (false and true)

#false=0, true=1
sum(mat11) #offre la somma dei true
prod(mat11) #moltiplica i false=0 con i true=1)
cumsum(mat11) #cumulate calcolate dalla matrice (di soli true)

PER LE MATRICI FORMATE DA PAROLE NON SI POSSONO ESEGUIRE QUESTE OPERAZIONI, TRANNE
cumsum(..) che darà tutti NA

#ESTRARRE GLI ELEMENTI DA UNA MATRICE

mat2[2,3] #estrae l’elemento nella riga due, colonna 3
mat2[2,] #estrae tutti gli elementi della seconda riga (si può fare anche viceversa)
mat2[2,1:2] #estrae gli elementi della seconda riga nella prima e seconda colonna (e viceversa)
mat2[2,c(1,3)] #estrarre elementi in riga 2 e colonne 1 e 3
#estrarre elementi in posizioni [2,3] e [3,1]
rbind(c(2,3),c(3,1))
mat2[rbind(c(2,3),c(3,1))] #da una matrice dove nella prima riga ci sono 2 e 3 e nella seconda 3 e 1
#può essere anche visto come
pp<-rbind(c(2,3),c(3,1))
mat2[pp]

#estrarre elementi in posizioni [1,1] e [3,2]

cbind(c(1,3),c(1,2))
mat2[cbind(c(1,3),c(1,2))] #da una matrice dove la prima colonna è data da 1,3 e la seconda colonna da 1,2
#può essere anche visto come
oo<-cbind(c(1,3),c(1,2))
mat2[oo]

mat2[-c(2),] #per considerare mat2 omettendo la seconda riga

mat2[-c(1,2),] #considera mat2 omettendo la prima e la seconda riga
mat2[-c(1,2),,drop=FALSE] #se mat2 è formata da 3 righe e ne togli due, rimane un vettore. Con questo
procedimento si può mantenere la struttura della matrice, quindi uscirebbe una matrice con 3r e 1c

mat2>=0 #verificare valori superiori o uguali creando una matrice=a mat2 dove se è soddisfatta la
condizione= TRUE, dove non è soddisfatta=FALSE
mat2[mat2>=0] #estrae dalla matrice gli elementi che soddisfano la condizione nelle []

which(mat2>=0) #per conoscere quali sono le posizioni degli oggetti che soddisfano la condizione
(considerando le colonne)
which(mat2>=0,arr.ind=TRUE) #permette di creare una matrice con le coordinate degli elementi che
soddisfano la condizione
mat1[which(mat2>=0)] #da come risultato un vettore e lo stesso accade con la formula successiva
mat1[which(mat2>=0,arr.ind=TRUE)] #ottengo un vettore come output

#evidenziare elementi sotto diagonale principale

mat4[lower.tri(mat4)] #restituisce una matrice di logici dove abbiamo true in tutti gli elementi al di sotto
della diagonale principale
#evidenziare elementi sopra diagonale principale
mat4[upper.tri(mat4)] #restituisce una matrice di logici dove abbiamo true in tutti gli elementi al di sopra
della diagonale principale

#cambiare valori in matrice

mat3[1,1]<-0 #sostituisci all’elemento della prima riga, prima colonna il numero 0
mat3[,3]<--mat3[,3] #sostituisce la colonna 3 con i valori sempre della stessa colonna ma cambiati di segno

#OPERAZIONI TRA MATRICI (stessa dimensione)

mat2-mat3
mat2*mat3
mat2/2
mat2^3
v1<-c(0,2,4,2.5,1,8)
v2<-c(4,9,2)
# I VETTORI IN R SONO DI DEFAULT VETTORI COLONNA, PER VERIFICARLO PUOI NOTARE LA TRASPOSTA
t(v1) #ciò che ne uscirà sarà dunque un vettore riga
v1%*%v2 #prodotto righe per colonne (il n delle colonne della prima matrice deve essere = al n delle righe
della seconda matrice)
v1%*%t(v2)

#ASSEGNARE DEI NOMI

names(v1)<-paste("Comp",1:length(v1),sep=" " ) #prende il vettore v1 e nomina l’elemento1= comp1,
l’elemento 2 “comp2” e così via per tutta la lunghezza del vettore con separatore= “ “

colnames(mat2)<-c("First-Column", "Second-Column","Third_Column","Fouth-Column","Fifth-Column")
#dare il nome alle colonne
colnames(mat2)<-paste(c("First","Second","Third","Fourth","Fifth"), "Column",sep="-") #stesso risultato
rownames(mat2)<-
paste(c("First","Second","Third","Fourth","Fifth","Sixth","Seventh","Eightht","Ninth","Tenth"),
"Row",sep="-") #dare il nome alle righe
mat2[,”First-Column”] #estrae la prima colonna
mat2[“First-Row”,c(“First-Column”,”Third-Column”)] #estrae la prima riga, colonna1 e 3

#ARRAY (estensione a più dimensioni di una matrice)

arr1<-array(1:24,dim=c(4,3,2)) #elementi da 1 a 24 disposti in 4 righe, 3 colonne e 2 “panni” (matrici)
arr1[1,,] #estrae la prima riga (che comprende la prima riga di entrambi i panni) e li posiziona in colonne
arr1[1,c(2,3),] #estrae la prima riga, colonna 2 e 3, mantenendo gli indici della terza dimensione
arr1[,,-c(2)] #elimina la seconda “matrice”-array
arr1[,,-c(2),drop=FALSE] #stesso output ma ti fa capire che è un array e non una matrice

#LISTE (contenitore di elementi eterogeni)

list.0<-list(c(1,2,3),matrix(data=1:10,nrow=5,ncol=2),c(rep(FALSE,2),rep(TRUE,4)),c("Bye bye"))
#1° elemento=vettore numerico; 2°elemento=matrice; 3° elemento=vettore logico; 4° elemento=vettore
caratteri
list.0[[1]] #estrae il primo elemento (doppia parentesi quadra)
list.0[2:3] #singola parantesi quadra=estrae sottoinsiemi- estrae elementi 2 e 3

list.2<-list(welcome=c("Hallo","Friends","Hallo"),mynumbers=c(30,50,0.5,0.1),myidea=c(TRUE,TRUE,FALSE))
#dare i nomi a priori agli elementi di una lista- 1°vettore=welcome; 2°vettore=my numbers…
list.2[[1]]
#è equivalente a
list.2$welcome #il simbolo del dollaro è chiave d'accesso a elementi nominati
names(list.2) #restituisce i nomi della lista

names(list.0)<-c("Pane","Pasta","Pizza","Carciofi") #dare nomi a posteriori agli elementi della lista

dimnames(mat1)<-list(paste("Riga",1:nrow(mat1)),paste("Colonna",1:ncol(mat1))) #usare le liste per

nominare righe e colonne della matrice
Lezione 4 Per conoscere solo n. di righe si crea
Liste vettore con comando nrow()
Creare una lista -> list(), con all’interno i vari c() ➔ n1<-nrow(data1)
Dare un nome a ogni sottocategoria -> names () Per conoscere solo n. di colonne si
(ex. names(list.1)<-c("Nome","Anni","Coniugato") ) crea vettore con comando ncol()
➔ n2<-ncol(data1)
Data Frame
Creazione data frame -> data.frame()
(Ex. data1<-data.frame(Nome=c("Nino","Pino”),Coniugato_a=c(…)) )
Conoscere struttura df -> str()
Conoscere dimensione (righe e colonne) -> dim()

Per conoscere informazioni statistiche come caratteri, i cinque elementi essenziali di una distribuzione
quantitativa (quartili, mediana…) si usa il comando summary()
Per conoscere la media -> mean()
Per approssimare valori -> round(…, digits=n) con n pari al numero di decimali desiderato
(Ex. round(mean(data1$Anni_compiuti),digits=1))

Per conoscere quanti soggetti (somma) soddisfano Frequenza assoluta -> comando
una certa condizione -> sum() Frequenza relativa -> comando/n
(ex. sum(data1$Anni_compiuti>=50) con risultato 2) Frequenza assoluta -> (comm/n)*100

Per creare una tabella di contingenza in cui si classificano le frequenze dei caratteri, si usa il comando
table().

Per conoscere i nomi di row e col -> dimnames()

Per conoscere i nomi delle righe -> rownames()
Per conoscere i nomi delle colonne -> colnames()
Per conoscere i nomi attribuiti ai diversi caratteri -> names()

Si possono attribuire i nomi presenti in una lista come nomi di

righe e colonne -> rownames(data1)<-data1$Nome
Per poi eliminare la variabile dei nomi per evitare
una ripetizione -> data1$Nome<-NULL
Andando a cambiare la struttura delle variabili, come si andrebbe a vedere andando ad eseguire
il comando str().

Per creare tabella di contigenza con caratteri che

rispettino certe condizioni -> data1.rid<-data1[data1$Anni>=50,]
In alternativa, si può usare anche
il comando which () -> data1.rid2<-data1[which(data1$Anni>=50),]
E si possono usare le intersezioni per verificare molteplici condizioni.

Per verificare se due tabelle siano identiche, si usa il comando identical().

Creazione Data Frame da file esistenti e controllo informazioni

→Si possono creare data frame da file esterni con il comando read.table().
(ex. data1<-read.table(file="dataset1.txt",header=TRUE) ).

→Per visualizzare come una tabella il data frame si usa il comando head(), in cui si possono anche
cancellare eventuali colonne non rilevanti, come nell’esempio (ex. head(data1[,-c(3)]) ).

→Per riordinare i file, si possono usare varie accortezze come skip=, na.strings=, sep=.
(ex. dataIncidenti<-read.csv2(file="datasetIncidenti.csv",skip=1,na.strings=c("NA","?","")) )

→Per determinare se ci sono elementi che si ripetono -> duplicate()

Per scovare eventuali caratteri ripetuti, il comando duplicate e vado ad isolare gli elementi ripetuti
(ex. 1. dataIncidenti$id<-as.character(dataIncidenti$id)
2. sum(duplicated(dataIncidenti$id))
3. dupl.id<-dataIncidenti$id[duplicated(dataIncidenti$id)]
4. dataIncidenti[dataIncidenti$id==dupl.id,] )

→Si può cambiare la natura di una variabile, con il comando as.character().

→Per controllare se ci sono valori nulli, si possono usare comandi all() e is.na().
(ex. all(is.na(dataIncidenti$longitudine))

→Si può verificare la presenza di eventi unici con il comando unique(), e si possono impostare come
elementi logici
(ex. 1. unique(dataIncidenti$confermato)
2. dataIncidenti$confermato<-(dataIncidenti$confermato=="True") )

→In presenza di caratteri quantitativi, può dar fastidio leggere parole che dovrebbero essere sottintese, e
per questo si può usare il comando gsub() che serve per sostituire o eliminare elementi.
(ex. 1. dataIncidenti$localizzazione1<-gsub(pattern="Strada ", replacement="",
x=dataIncidenti$localizzazione1)
2. unique(dataIncidenti$localizzazione1) )

→Le variabili possono essere poste anche come fattori (categorie) e riordinare le modalità con il comando
factor().
(ex. dataIncidenti$traffico<-factor(dataIncidenti$traffico,levels=c("Scarso","Normale","Intenso")) )

→Si possono impostare anche risposte a doppia uscita a posteriori per un fattore, con il comando levels(),
utilizzato come per creare un vettore.
(ex. 1. dataIncidenti$traffico_intenso<-(dataIncidenti$traffico=="Intenso")
2. levels(dataIncidenti$traffico_intenso)
3. dataIncidenti$traffico_intenso<-factor(dataIncidenti$traffico_intenso)
4. levels(dataIncidenti$traffico_intenso)<-c("No","Si") )
Un metodo alternativo ed equivalente è quello di creare una triplice uscita.
(ex. 1. dataIncidenti$traffico_intenso2<-dataIncidenti$traffico
2. levels(dataIncidenti$traffico_intenso2)
3. levels(dataIncidenti$traffico_intenso2)<-c("No","No","Si") )

Funzioni
→Per creare una funzione si usa il comando function().
→Una funzione può essere usata per fare di tutto, anche restituire una semplice parola alla sua esecuzione,
come nel caso del comando print() usato all’interno di function().
→Funzione area cerchio -> area.circle<-function(radius){
out<-(radius^2)*pi
return(round(out, digits=2))
} Esecuzione -> area.circle(radius=3)
→ Si può prefissare all’interno dell’argomento della funzione un valore prefissato
Ex. Funzione cerchio -> meas.circle<-function(radius=1){
d<-2*radius
circonferenza<-pi*d
area<-(radius^2)*pi
 out<-c(d,circonferenza,area)
names(out)<-c("Diametro","Circonferenza","Area")
return(round(out, digits=2))
}

→ ci sono operazioni modulo %% che ti restituiscono il resto della divisione.

Ex. oddcount<-function(x){
mod<-x%%2
count<-sum(mod)
return(count)
}

→Altra funzione che contiene operazioni è

Ex. my_fun<-function(x,y,z=1){
s<-(x-y)/z
return(s)
}
LEZIONE 5
db<-read.csv(file="fast_foods.csv",header=T,sep=",") #header significa che l’intestazione delle singole
variabili è presente

db<-db[,-1] #elimina la prima colonna

ampiezza_classe<-diff(range(db$costo_fitto_locali))/4 #trasforma le variabili continue in 4 classi di uguale

ampiezza – range=valore min e max della variabile, ne calcola la differenza e divide per 4

breaks<-seq(min(db$costo_fitto_locali),max(db$costo_fitto_locali),
by=ampiezza_classe)
breaks #calcola gli estremi della classe partendo dal valore più piccolo, terminando con il valore più
grande, creando una sequenza su un passo pari all’ampiezza

db$classi_costo<-cut(db$costo_fitto_locali,
breaks,include.lowest = T,right=T) #cut permette di identificare la variabile di interesse; secondo
imput=classi; specifico che bisogna includere sia il valore più piccolo che l’estremo superiore

levels(db$classi_costo)
levels(db$classi_costo)<-c("Molto basso", "Basso", "Alto", "Molto alto") #nominare i livelli

db$classi_costo<-ordered(db$classi_costo,levels=levels(db$classi_costo)) #trasforma il factor in ordered

factor (la classe non è più un fattore su scala nominale-che non è possibile ordinare, ma su una scala
ordinale)

#DISTRIBUZIONI DI FREQUENZA
table(db$classi_costo) #freq assolute
col_1<-cbind(table(db$classi_costo)) # inserisce in colonna le freq assolute
col_2<-cbind(cumsum(col_1)) #inserisce in colonna le freq cumulate
col_3<-col_1/sum(col_1) #inserisce in colonna le freq relative
col_4<-cbind(cumsum(col_3)) #inserisce in colonna le freq relative cumulate
tab_f<-cbind(col_1,col_2,col_3,col_4) #metti insieme tutte le colonne create
colnames(tab_f)=c("Freq. Assol.","Freq. Assol. Cumul.","Freq. Relat.","Freq. Relat. Cumul.") #dai nomi alle
colonne
round(tab_f,4) #arrotonda alla quarta cifra decimale

table(db$classi_costo,db$rip_geo) #DISRIBUZIONI DI FREQUENZA CON DUE VARIABILI

N<-nrow(db) #numerosità db
mu<-mean(db$costo_fitto_locali) #media
X<-db$costo_fitto_locali #variabile quantitativa
N^-1*sum (X - mu)^2 #varianza
var(db$costo_fitto_locali) #varianza calcolata dividendo per N-1 (MEGLIO USARE QUESTA)
median(X) #mediana
quantile(X) #calcola min, max, q1, Me, q3
summary(db$costo_fitto_locali) #rilascia i 5 elementi di sintesi in un unico vettore
cor(cbind(db$fatturato), cbind(db$mq)) #calcola l’indice di correlazione tra le colonne “fatturato”, “mq”
#STATISTICHE PER GRUPPI
by(db$costo_fitto_locali, db$rip_geo, function(x) mean(x)) #con by applichi all’oggetto
“db$costo_fitto_locali”, la statistica “function(x) mean(x), sulla base delle diverse modalità riportate nel
secondo input “, db$rip_geo, function(x) -RILASCIA LA MEDIA DEI VARI GRUPPI

by(db$costo_fitto_locali, db$rip_geo, function(x) sd(x)) #RILASCIA LA DEVIAZIONE STANDARD DEI VARI

GRUPPI

#BOXPLOT (carattere quantitativo)

boxplot(costo_fitto_locali ~ rip_geo, data=db) # covariando rispetto alla ripartizione geografica-
RISULTATP= tanti boxplot quante sono le ripartizioni geografiche

boxplot(costo_fitto_locali ~ rip_geo, data=db,col=rainbow(5),

ylab="Costo Fitto Locali", xlab="Ripartizione Geografica",
main="Boxplot") #ylab=nome asse y; xlab=nome asse x; main=titolo grafico; rainbow(5) significa che ogni
singolo boxplot ha un colore diverso (arcobaleno)

pdf(file="boxplot.pdf",height=9,width=16)
boxplot(costo_fitto_locali ~ rip_geo, data=db,col=rainbow(5),
ylab="Costo Fitto Locali", xlab="Ripartizione Geografica",
main="Boxplot")
dev.off() #puoi ritrovare il grafico come pdf nella working directory, height=altezza; width=ampiezza

#GRAFICO A NASTRI E LA FUNZIONE DI RIPARTIZIONE ecdf - tiene conto della distanza tra i nastri
plot(table(mtcars$carb)) #grafico a nastri delle freq assolute del n di carburatori per macchina

#PER FARE IL GRAFICO DELLA FUNZIONE DI RIPARTIZIONE CALCOLA LE FREQ. Assolute, Assolute cumulate,
Relative, Relative cumulare. Crei la matrice che contiene tutte queste info, nominando le colonne con le
relative freq.

plot(ecdf(mtcars$carb),xlab="Carburatori",lwd=3) #rilascia la il grafico della funzione di ripartizione, dove

lwd=spessore linea (NB- asse y= freq relative; x=modalità)

#SETTORE CIRCOLARE, caratteri qualitativi (GRAFICO A TORTA) (carattere qualitativo oppure

carattere quantitativo o trasformato in classi di modalità)
fr_parcheggio<-table(db$parcheggio) #calcola le freq
pie(fr_parcheggio) #grafico a torta, parcheggio si o no

freq_classi_costo<-table(db$classi_costo) #calcola le freq

pie(freq_classi_costo, main="Costo fitto locali") #grafico a torta delle classi di costo, main=titolo del grafico

lab<-paste(names(freq_classi_costo),": ", round((freq_classi_costo/N)*100,2),"%",sep="") #con paste crei

un oggetto che contiene il nome della modalità e la percentuale
pie(freq_classi_costo, main="Costo fitto locali",labels=lab,col=rainbow(4)) #torta delle freq assolute,
main=nome; label= specifica le etichette (es molto alto…affiancato dalla %) + colori
#BARPLOT (si può realizzare con le variabili qualitative, quantitative con classi, quantitative con
poche modalità)- la larghezza delle barre non ha significato
barplot(freq_rip_geo) # frequenze assolute

perc_rip_geo<-(freq_rip_geo/N)*100 # percentuali
barplot(perc_rip_geo,ylab="%",main="Ripartizione Geografica dei Fast Foods") #si possono dare etichette

#ISTOGRAMMA (per variabili quantitative riportate in classi di modalità)- asse x=ampiezza classi;
asse y= densità (freq/ampiezza classe) – area rettangolo= freq relativa o assoluta della classe
# costruiamo per la variabile "fatturato" 6 classi:

breaks_fat<-c(0,250,500,800,1000,1200,1665) #estremi classi

h<-hist(db$fatturato,breaks=breaks_fat,ylab="Densit?",
xlab="Classi",main="Fatturato",col="white") #1°elemento=oggetto di nostro interesse; la specifica
delle classi breaks, etichetta x e y, il colore e il titolo

NB- da questa formula ne esce un risultato che ci permette di visionare: breaks=estremi di ogni classe;
counts=n volte che il fatturato rientra in ogni singola classe; density; mids=valori centrali di ogni classe

h$counts[1] #freq assoluta della prima classe

h$counts[1]/N #freq relativa prima classe
(h$counts[1]/N)/250 #densità prima classe

text(h$mids,h$density/2,h$counts) #ci permette di dire dove inserire sull’asse x (punti centrali); sull’asse y
ci dice l’altezza; INSERISCE le freq di ogni singola classe (sarebbero tutte le info di sopra in una sola formula)

SCATTER PLOT (DIAGRAMMA A DISPERSIONE) – per due caratteri quantitativi

plot(1:25,pch=1:25,cex=1.2) #pch=identifica il diverso tipo di simbolo che può essere inserito nel grafico;
cex=grandezza del simbolo
plot(db$mq, db$fatturato,pch=4) #da il grafico a dispersione tra mq e fatturato
plot(db$fatturato, db$costo_fitto_locali,col="red") #da il grafico a dispersione tra fatturato e costo fitto
locali e sarà di colore rosso
Lezione 6
Strutture di controllo – svolgere operazioni a seconda delle condizioni richieste dal contesto
A) ALTERNATIVE – struttura IF e IF ELSE
Partendo da un soggetto a<-42 con operazioni svolte quali il resto della divisione intera (a %% 2) e la
coincidenza del risultato con un determinato valore (a %% 2 == 0).
Operatori logici valori
STRUTTURA IF() – all’esecuzione della funzione si ha un certo x < y x & y AND
comportamento. x > y ! x neg
x <= y x | y or
All’interno delle parentesi tonde () va messa l’ipotesi che si intende verificare; x >= y
mentre nelle graffe l’esecuzione dei comandi della funzione. x == y
(Ex. if (a %% 2 == 0) {frase <- paste("il numero", a, "è un numero pari") x != y
print(frase)} )
Se invece l’ipotesi non è verificata, non verrà fornito un risultato.

STRUTTURA IF() ELSE() – considera più casi che possono verificarsi.

Funziona come la struttura IF(), solo che si dovrà fornire un argomento anche per ELSE(), da cui verrà dato
un determinato risultato in base ai valori e alle condizioni date.
(Ex. if (a %% 2 == 0) { frase <- paste("il numero", a, "è un numero pari") print(frase)}
else {frase <- paste("il numero", a, "è un numero dispari") print(frase)} )

Per entrambe le strutture si può eseguire una compattazione, non inserendo all’interno della funzione il
comando print(), ma eseguendolo come comando a sé, che riporterà il risultato della funzione.

Da precisare che: in operatore logico &, entrambi elementi devono essere positivi per avere valore TRUE
In operatore logico |, almeno uno dei due elementi deve essere positivo per avere TRUE

INTERVALLO DI VALORI
Andiamo a creare un intervallo (intervallo <- c(10, 20)) con un estremo inferiore (estremo_inf <- a >=
intervallo[1]) ed estremo superiore (estremo_sup <- a <= intervallo[2]).

CONCETTO DI ANNIDAMENTO STRUTTURE DI CONTROLLO - Creiamo ora una struttura di controllo IF ELSE.
La condizione primaria di IF è che siano verificati estremo inferiore e superiore, ma se non sono verificati
(ELSE), verrà utilizzato una ulteriore condizione IF ELSE per tutti i casi che possono verificarsi.
(Ex. if (estremo_inf & estremo_sup) {frase <- paste( "il numero", a, "è compreso tra", intervallo[1], "e",
intervallo[2],"estremi inclusi")} else { if (!estremo_inf) {frase <- paste("il numero", a, "è minore
di"intervallo[1] )} else { frase <- paste("il numero", a, "è maggiore di",intervallo[2])}} )

Comando all() restituisce nel controllo se tutti o no dei risultati sono veri.
Comando any() resituisce nel controllo se alcuni o no dei risultati sono veri.
Questi due comandi servono molto in quanto nelle funzioni R non esamina tutti i gli elementi di un vettore,
ma solo il primo elemento.
(Ex. if (all(x > 0)) {log(x)} else {print(paste("L'elemento in posizione", which(!(x > 0)), "è minore o uguale a
0"))} )

VERIFICA DI INTERVALLO IN FUNCTION() E STRUTTURA DI CONTROLLO ANNIDATA

Inizialmente si prevede una inizializzazione nel caso in cui non si dovesse essere in grado di verificare
nessuna condizione, imponendo frase<-NA, e con cui sarebbe giusto restituire un dato mancante. A seguire
c’è la verificare dell’estremo inferiore e superiore con la struttura di controllo annidata IF ELSE.
verifica_intervallo <- function(a, intervallo = c(10, 20)) { frase <- NA estremo_inf <- a >= intervallo[1]
estremo_sup <- a <= intervallo[2] if (estremo_inf & estremo_sup) { frase <- paste( "il numero", a, "è
compreso tra",intervallo[1], "e", intervallo[2],"estremi inclusi")} else {if (!estremo_inf) {frase <- paste(
"il numero", a, "è minore di", intervallo[1])} else {frase <- paste("il numero", a, "è maggiore
di",intervallo[2])}} return(frase)}
INTERAZIONE – dover far passare ogni singolo elemento del vettore attraverso il ciclo for(), che coincide al
processo di sommatoria degli elementi di un vettore.
(ex. 1. n <- length(vettore)
2. valori <- 1:n
3. risultato <- rep(NA, n)
4. for (i in valori) {risultato[i] <- verifica_intervallo(vettore[i])}
5. risultato)
Stesso procedimento si può utilizzare con i singoli elementi del vettore, senza usare le loro posizioni, ma
andando ad appendere il primo elemento del vettore come null.
(ex. 1. risultato <- NULL
2. for (elemento in vettore) {risultato <- c(risultato, verifica_intervallo(elemento))}
3. risultato)

FUNZIONE VECTORIZE() – Si va a definire una nuova funzione che trasforma una funzione originaria
originaria FUN agli argomenti vectorize.args uno alla volta nella funzione qualora essi siano dei vettori.
(ex. 1º caso: verifica_intervallo_v <- Vectorize(FUN = verifica_intervallo, vectorize.args = "a"
2º caso: verifica_intervallo_v(vettore, intervallo = c(5, 10)) )

FUNZIONE DIVISORE
Si crea funzione sul divisore.
(ex. conta_div <- function(x, divisore = 2) {risultato <- x %% divisore == 0 risultato <- sum(risultato)
return(risultato)} )
Applicando questa funzione alla matrice, ci restituirà risultato come se fosse vettore, andando a dare il
totale degli scalari che soddisfano la condizione.
Andando a creare un ciclo for(), andremo a vedere sempre in una matrice i risultati che ci restituirà.
(ex. 1. r <- nrow(M)
2. c <- ncol(M)
3. P <- matrix(NA, nrow = r, ncol = c)
4. for (i in 1:r) { for (j in 1:c) P[i, j] <- conta_div(M[i, j])} )
La si può applicare sia solo sulle righe, che solo sulle colonne.
Righe -> (ex. 1. pR <- rep(NA, r)
2. for (i in 1:r) {pR[i] <- conta_div(M[i, ])} )
Colonne -> (ex. 1. pC <- rep(NA, c)
2. for (j in 1:c) {pC[j] <- conta_div(M[, j])}

FUNZIONE APPLY() - Simile a vectorize() si va ad applicare funzione su elementi della matrice.

Si arriva a risultati simili alla funzione divisore, in maniera più breve e compatta.
Per identificare i numeri pari -> apply(M, c(1, 2), conta_div)
Per identificare i numeri pari su ciascuna riga -> apply(M, 1, conta_div)
Per identificare i numeri pari su ciascuna colonna -> apply(M, 2, conta_div)

Funziona conta_div può avere anche divisori diversi.

Per identificare i numeri pari -> apply(M, c(1, 2), conta_div, divisore = 3)
Per identificare i numeri pari su ciascuna riga -> apply(M, 1, conta_div, divisore = 3)
Per identificare i numeri pari su ciascuna colonna -> apply(M, 2, conta_div, divisore = 3)

Ci sono altre funzioni derivanti da apply(), ad esempio lapply() che si applica alle liste, e restituisce il
risultato relativo ad ogni componente della lista. Cosa diversa accade con sapply() che tende a semplificare
il risultato.
(Ex. lapply(lista, conta_div)
lapply(lista, conta_div, divisore = 3) )
Inoltre c’è funzione tapply() che contiene elemento aggiuntivo INDEX con l’indice, andando a riportare
anche i risultati dell’indice.
FUNZIONE OUTER() tra due vettori-> da prodotto vettori restituisce matrice.
Partendo da variazione_rel <- function(a, b) { ris <- (a - b) / b return(ris)}
Ottenendo outer(X, Y, variazione_rel).
LEZIONE 7
file1<-https://web.uniroma1.it/memotef/sites/default/files/file%20lezioni/risfam16.csv #setta il file
risparmi<-read.csv(file1) #leggi il file
names(risparmi) #nomina il file
summary(risparmi$S) #richiede i 5 valori della distribuzione

#STUDIARE LA CONCENTRAZIONE (su caratteri trasferibili e positivi)

S<-risparmi$S #oggetto
S.pos<-S[S>0] #devono essere esclusi i caratteri negativi
S.pos.rid<-S.pos[1:20] #prende le prime 20 famiglie che hanno un risparmio positivo (non sono ordinate in
senso crescente)
N<-length(S.pos.rid) #chiamo n la lunghezza del vettore

#L’INDICE DI CONCENTRAZIONE SI BASA SUGLI AMMONTARI DELLA SEGUENZA ORDINATA DELLE

MODALITÀ- prima cosa da fare: riordinare le modalità dalla +piccola alla+ì +grande - SORT

S.pos.ord<-sort(S.pos.rid) #vettore ordinato

A=cumsum(S.pos.ord) #somme cumulate del vettore ordinato
Q=A/A[n] #Qi=frazioni di ammontare possedute dalle i unità più povere fino ad n
P=(1:n)/n #Pi= ammontare che spetta alle i unità più povere con equidistribuzione
G<-sum(P-Q)/sum(P[-n]) #INDICI DI GINI
plot(x=c(0,P),y=c(0,Q),type="b",xlim=c(0,1),ylim=c(0,1)) #RAPPRESENTAZIONE DELLA CURVA DI
CONCENTRAZIONE (type=b permette di usare sia punti che linee
abline(c(0,1)) #aggiungi una retta con coef.ango=0 e intercetta=1

concentrazione<-function(x,plot=TRUE,titolo=NULL){
x=x[x>0]
n=length(x)
A=cumsum(sort(x))
Q=A/A[n]
P=(1:n)/n
G=sum(P-Q)/sum(P[-n])
if(plot){
plot(x=c(0,P),y=c(0,Q),type="l",
xlim=c(0,1),ylim=c(0,1),
xlab=expression(P[i]),
ylab=expression(Q[i]),
col=3,main=titolo)
abline(c(0,1),col=2,lwd=2)
}
return(G)}
#funzione di un vettore numerico x, restituisce un grafico grazie a PLOT=TRUE (se non vuoi grafico metti
false) +titolo; QUESTA FUNZIONE: prende un x e di questo considera solo gli elementi positivi, la lunghezza,
ordina e calcola le cumulate in una sola operazione, calcola le Qi e le Pi. Se plot=true allora esegue tutto il
resto, altrimenti no. Nella sequenza di comandi di plot: type=I= solo la linea, x e y devono andare da 0 a 1;
nomina x e y con x/y lab (expression=per scrivere dei pedici); colore=verde --- calcola Gini
#CALCOLA LA CONCENTRAZIONE PER IL VETTORE DEI RISPARMI POSITIVI
concentrazione(S) #applica la concentrazione a tutte le famiglie eliminando automaticamente gli elementi
negativi e fornisce di default il grafico
Y<-risparmi$Y #prendi la variabile reddito
par(mfrow=c(1,2)) #par permette di dividere la finestra dei grafici in una riga e due colonne (permette
quindi di inserire due grafici
concentrazione(S,titolo="Risparmio") #per nominare il grafico S
concentrazione(Y,titolo="Reddito") #per nominare il grafico Y

file2=https://web.uniroma1.it/memotef/sites/default/files/file%20lezioni/carcom16.csv #nuovo file

carcom=read.csv(file2) #leggi file (caratteristiche componenti)
carfam=carcom[carcom$nord==1,] #carcom$nord restituisce il numero d’ordine della persona all’interno
della famiglia, e ogni famiglia ha almeno 1 persona- questo comando associa a ogni unità con valore 1 la
sua caratteristica (tot= caratteristiche famiglia)
unione=merge(carfam,risparmi) #unisce i due file(caratteristiche della fam e risparmi)

#area geografica (1=Nord Ovest, 2=Nord Est, 3=Centro, 4=Sud, 5=Isole)

for (i in 1:5){
s1=unione$S[unione$AREA5==i]
print(concentrazione(s1,plot=FALSE))} #indice di concentrazione per le diverse aree geografiche
tapply(X=unione$S,INDEX=unione$AREA5,FUN=concentrazione) #stesso risultato del ciclo for

regioni=c("Piemonte", "Valle d'Aosta", "Lombardia", "Trentino", "Veneto", "Friuli","Liguria", "Emilia

Romagna", "Toscana", "Umbria", "Marche", "Lazio", "Abruzzo", "Molise", "Campania", "Puglia",
"Basilicata", "Calabria", "Sicilia", "Sardegna") #vettore delle regioni
conc.reg<-tapply(X=unione$S,INDEX=unione$ireg,FUN=concentrazione) #considerando come indice le
regioni, calcolo di nuovo la concentrazione
data.frame(regioni=regioni,concentrazione=conc.reg) #data frame con alla prima colonna i nomi delle
regioni e nella seconda colonna gli indici di concentrazione
LEZIONE 8
file2<-https://web.uniroma1.it/memotef/sites/default/files/file%20lezioni/carcom16.csv
carcom=read.csv(file2) #file

ANALISI DIPENDENZA TABELLE

Con comando table() andiamo a vedere le frequenze della modalità sex e qual-> table(carcom$sex),
table(carcom$sex)
Ed andiamo a unire i due caratteri insieme per creare una tabella a doppia entrata ->
D=table(carcom$sex,carcom$QUAL)

Con comando proportions() si vanno a vedere le frequenze relative condizionate rispetto una delle due
variabili (ex. fydatox=proportions(D,margin=1) che da come risultato la frequenza relativa condizionata
dello status di lavoratore qual ai generi sex, andando a fissare con margin le righe.
Ex. fxdatoy=proportions(D,margin=2) andando a fissare le colonne con margin, si ottiene la freq. Relativa
condizionata del genere sex agli status di lavoratori qual)

Il totale delle righe e colonne rowSums() e colSums() rispetto alle variabile sarà pari ad 1.

Per fare il barplot, possiamo prendere una delle due modalità e eseguire il comando in funziona alla
variabile desiderata. (ex. barplot(fydatox[1,]) in funzione agli uomini, barplot(fydatox[2,]) in funzione alle
donne.)

Per comporre il barplot affiancando due caratteri, si usa il termine beside=true, che restituisce i due
caratteri per ogni modalità (ex. barplot(fydatox,beside=TRUE,col=c(3,2)) ).

TEST CHI QUADRO

Per trovare frequenze marginali assolute della variabile SEX -> marg.x=rowSums(D)
Per la variabile QUAL -> marg.y=colSums(D)

Per trovare la tabella d’indipendenza, si va ad usare il comando outer() in cui andiamo a fare il prodotto dei
totali di righe e colonne -> outer(marg.x,marg.y)
Dopo bisogna dividere il risultato per il totale della tabella -> ind=outer(marg.x,marg.y)/sum(D)

Per svolgere il test del chi quadro, ci sono due metodi:

1- Usare la formula (Valori osservati – teorici)^2/teorici -> chi2=sum( (D-ind)^2/ind)
2- Usare il comando chisq.test() (per stat descrittiva aggiungere $statistic)

Altro metodo per trovare i valori teorici è quello di usare il comando chisq.test()$expected

Per trovare indice relativo di indipendenza (indice di cramer, psi) -> cramer=sqrt(chi2/sum(d))

Per una tabella con tre variabili

(ex. D=table(carcom$sex,carcom$QUAL,carcom$AREA3)
apply(D,MARGIN=c(3),FUN=chisq.test)
mycramer=function(x) sqrt(chisq.test(x)$statistic/sum(x))
apply(D,MARGIN=c(3),FUN=mycramer) )

REGRESSIONE
file1<-"https://web.uniroma1.it/memotef/sites/default/files/file%20lezioni/risfam16.csv"
risparmi<-read.csv(file1) #file
Per il grafico a dispersione -> plot(x=risparmi$Y,y=risparmi$C)
Per il coefficiente di correlazione -> cor(risparmi$Y,risparmi$C)

Per la variabile x=risparmi$Y trovo la media mean(x) e deviazione standard sd(x).

Per la variabile y=risparmi$C trovo la media mean(y) e deviazione standard sd(y).
Inoltre trovo la codevianza -> cxy=sum( (x-mean(x))*(y-mean(y)))
Ed anche la devianza di x -> dx=sum( (x-mean(x))^2)

Per trovare il parametro b1 della retta di regressione -> b1=cxy/dx

Per trovare il parametro b0 -> b0=mean(y)-b1*mean(x)

Per aggiungere la retta al grafico -> abline(c(b0,b1), col=2)

Per verificare se retta passa nel baricentro tra le due medie, vado a creare le rette aggiuntive ->
abline(v=mean(x),col=3) abline(h=mean(y), col=3)

R integra la funzione lm() (linear model) che serve per costruire direttamente la retta -> lm(y~x)
(oppure lm(C~Y,data=unione))

Se facciamo diventare lm() un oggetto m=lm(), possiamo estrarre molte informazioni tramite il comando
summary().
Possiamo estrarre direttamente il coefficiente m$coef, o da summary la variabile summary(m)$r.squared.

Per ottenere le previsioni in corrispondenza delle x osservate -> m$fitted.values

Per ottenere i residui -> m$residuals

Per verificare più rette di regressione insieme si usa una funzione ->
1- plot(x=unione$Y,y=unione$C,xlab="reddito",ylab="consumo")
2- for(i in 1:5){ m.area=lm(C~Y,data=unione,subset=(AREA5==i))
3- abline(coef(m.area),col=i)}

Per creare più grafici insieme ->

1- unione$AREA5[unione$AREA5==5]=4
2- par(mfrow=c(2,2))
3- for (i in 1:4){
m.area=lm(C~Y,data=unione,subset=(AREA5==i))
plot(x=unione$Y[unione$AREA5==i],
y=unione$C[unione$AREA5==i],
xlab="reddito",ylab="consumo",
xlim=range(unione$Y),
ylim=range(unione$C),
main=paste("area=",i," ",expression(r^2),"=",round(summary(m.area)$r.squared,2)),col=i)
abline(coef(m.area))}
LEZIONE 9
#PROBABILITÀ

moneta<-c("T", "C") #creazione moneta

sample(moneta, size =1) #sample=campiona, dunque lancia la moneta per una volta(size=1)
urna1<- c("G", "V", "R", "B") #creo un’urna con palline G,V,R,B
sample(urna1, size =1) #estrai una pallina
sample(urna1, size =6, rep=T) #eseguo 6 estrazioni con ripetizione (false=senza ripetizione)- se rep non è
specificato è FALSE

#CREARE UN VETTORE CON MOLTI ELEMENTI E CALCOLARNE LA PROBABILITÀ

urna2<-c(rep("G", 5), rep("V",3), rep("R",7), rep("B", 10)) #urna con 5 gialle, 3 verdi, 7 rosse, 10 gialle
campione<-sample(urna2, size = 1000, rep=T) #estrazione 1000 palline, con rinserimento
table(campione)/1000 # vettore freq relative (probabilità)

#ALTRO METODO- MIGLIORE

urna3<-c("G", "V","R","B")
campione2<-sample(urna3, size =1000, rep=T, prob=c(5,3,7,10)) #in questo modo i vari colori sono pesati
diversamente- R prende i pesi e li divide per il totale=25
table(campione2)/1000

# CALCOLO PROBABILITÀ ELENCANDO TUTTI I POSSIBILI RISULTATI DI UN ESPERIMENTO E

CONTEGGIANDO QUANTE VOLTE ESCE UN RISULTATO
dado1= dado2= dado3= 1:6
griglia<-expand.grid(dado1, dado2, dado3) #tutte le combinazioni tra i 3 vettori (216)
somma= rowSums(griglia) #somma per riga
dist.prob3<-table(somma)/length(somma) #distribuzione delle probabilità

#CALCOLARE LA PROB DI QUANTE VOLTE ESCE IL N°3

dado<-1:6
dati<-sample(dado, size=10^5, rep=T) #lancio 10^5 volte il dado
sum(dati==3)/10^5 #sommi quante volte è presente il numero 3 tra i risultati dei lanci e calcoli la prob
dividendo per il numero di prove effettuate

#CALCOLARE LA PROB CHE LANCIANDO 4 DADI SI OTTENGA 11

simula<-function(n=4, target= 11, nsim=10^4){ #n è il numero di dadi che lanciamo; target
if(target > 6*n) print("risultato impossibile") è il risultato di cui vogliamo calcolare la
if(target < n) print("risultato impossibile") probabilità; nsim è il numero di volte che
dado=1:6 ripetiamo l'esperimento – PRIMO
dati<-c() VINCOLO=se giochiamo con 4 dadi non si
for (i in 1:nsim){ può avere una somma maggiore n*6-
ris<-sample(dado, size=n, rep=T) SECONDO VINCOLO= se lanci tre n dadi
dati[i]<-sum(ris) non può uscire un numero minore di n.
}
Ciclo per i che va da 1 a nsim campiona n
freq.ass<-sum(dati==target)
dati. Calcola somma, freq ass, rel.
freq.rel<-freq.ass/nsim
return(freq.rel)
}
LEZIONE 10
Probabilità condizionata
Sappiamo che il calcolo della probabilità di un evento A, sapendo che si è già verificato l'evento $B$, o
comunque supponendo che l'evento B si verifichi, si ottiene dalla formula P(A|B) = P(A intersecato
B)}/P(B).
Quando le probabilità vengono calcolate come frequenze relative ottenute mediante una simulazione, il
calcolo delle probabilità condizionate può essere effettuato in due modi:

1. si segue la formula sopra citata e si calcolano separatamente le due probabilità; oppure

2. si limita il calcolo della frequenza relativa ai casi in cui in P(B) si è verificato

esercizio: Si estraggono, senza ripetizione, 3 palline da un’urna che contiene 6 palline Rosse (R) e 4 palline
verdi (V). Qual è la probabilità che siano tutte e tre Rosse (R), sapendo che almeno una di quelle estratte
è R?

PRIMO METODO
Per ottenere risultati omogenei, si imposta un seed
pari ad un determinato valore-> set.seed()
Si setta il numero delle prove -> prove <- 10^6
Si settano i due casi possibili -> 1. nab <- 0 #numero di volte in cui sono tutte e tre R
2. nb <- 0 #numero di volte in cui almeno 1 è R
Si crea l’urna da cui si estrae -> urna <- c(rep("R",6), rep("V",4) )
Si crea la funzione che estrae le 3 palline (estraz) e tramite i due if contempla i due eventi A e B con i due
casi aumentati di 1-> for(i in 1:prove) {
estraz <- sample(urna, 3, replace = FALSE)
if ("R" %in% estraz) nb <- nb + 1
if ("R" %in% estraz && !("V" %in% estraz)) nab <- nab + 1}
Esecuzione funzione -> print(round(stima, 3))
Si può ipotizzare anche una stima -> stima <- (nab/prove)/(nb/prove) # oppure stima<-nab/nb ...

SECONDO METODO

Si settano i due casi -> 1. n2ab <- 0 #numero di volte in cui sono tutte e tre R
2. n2b <- 0 #numero di volte in cui almeno 1 è R
Si settano il numero di prove -> prove <- 10^5
Si imposta la funzione, con l’estrazione programmata e il controllo degli eventi, dato che R deve uscire in
tutta l’estrazione, in modo che ci sia un if negativo all’interno dell’if principale -> for(i in 1:prove) {
estraz <- sample(urna, 3, replace = FALSE)
#Check
if("R" %in% estraz){
n2b <- n2b + 1
#Check di A
if(!("V" %in% estraz)) #
n2ab <- n2ab + 1 }}
Il risultato ottenuto tramite -> if(n2b > 0)
print(round(n2ab/n2b, 3)) else
print("Numero di casi insufficienti!")

Teorema di Bayes- opposto della probabilità condizionata

Esempio: Durante un esame uno studente, per rispondere ad una domanda, deve scegliere tra \ (5\)
diverse alternative. Supponiamo che sia \(1/3\) la probabilità che lo studente conosca la risposta e quindi
\(2/3\) la probabilità che risponda a caso. Qual è la probabilità che lo studente conosca realmente la
risposta se ha fornito la risposta corretta?

Impostare il numero di simulazioni -> nsim<-10^5

Impostiamo i casi -> 1. rc<-0 #numero di volte in cui si verificano R e C
2. cc<-0 #numero di volte in cui si verifica C
3. risposte<-c("Giusta", "Sbagliata")
Funzione- campiono i possibili esiti con la.sa==1 cioè T, e la.sa==0, cioè F-> for (i in 1:nsim){
la.sa<-sample(0:1, size=1, prob=c(2,1))
if(la.sa==1) { rc= rc + 1
cc=cc+1}
if (la.sa==0) {
dice<-sample(risposte, size =1, prob=c(1,4))
if(dice=="Giusta") cc= cc +1 }}
print(round(prob,3))
Calcolo la probabilità -> prob= rc/ cc

CALCOLO COMBINATORIO

Un primo modo per usare il calcolo combinatorio è quello di installare il package combinat che da accesso a
una serie di comandi esclusivi.

Si crea un vettore-> libri<-c(“A”, “B”, “C)

Si usa il comando permn() che elenca tutte le possibili permutazioni possibili-> permn(libri)

Un secondo metodo invece è quello di calcolarlo tramite la creazione di vettori, operazioni basilari.

ESEMPIO 1. Sei bambini sono allineati. qual è la probabilità che essi si trovino in ordine alfabetico secondo i
loro nomi, assumendo che abbiano sei nomi diversi?

Partendo dal numero di simulazioni -> nn <- 5 * 10^5

Creiamo un vettore con il numero di bambini -> bambini <- 1:6

E supponiamo che inizialmente ci sia un numero di successi pari a 0 -> num_succe <- 0
Andiamo a creare quindi la funzione per trovare la probabilità, data dal numero di successi iniziali
aggiungendo la comparazione tra due vettori tramite il comando identical() per verificare se i bambini
sono disposti in ordine alfabetico ->
for (i in 1:nn) { num_succe <- num_succe + identical(sample(bambini, size = 6), 1:6)}
num_succe / nn
Soluzione analitica -> 1 / factorial(6)

ESEMPIO 2. Riconsideriamo i bambini dell’esercizio precedente e supponiamo che si tratti di 3 maschi (M) e
3 femmine (F). Qual è la probabilità che, in un ordinamento scelto a caso, le tre femmine si trovino nelle
prime tre posizioni?

Fissiamo il numero di simulazioni -> nn <- 5*10^5

Fissiamo il numero di bambini -> bambini <- 1:6
Contatore successi -> num_succe <- 0
Creiamo una funzione per calcolare la probabilità andando ad aggiungere al numero di successi iniziale la
somma dei primi 3 elementi del vettore, che se pari a 6, soddisfano la condizione che siano occupati dalle
3 ragazze, a cui erano stati assegnati i primi 3 posti->
for (i in 1:nn) {num_succe <- num_succe + (sum(sample(bambini, size = 3)) == 6)}
num_succe / nn

DISTRIBUZIONE NORMALE

ESEMPIO Si lanciano 10 dadi un gran numero di volte e si traccia l’istogramma delle frequenze relative

Si fissa il numero delle simulazioni -> nsim=1e5 #significa 10^5

Si crea il vettore del dado -> dado=1:6
Si fissa il numero della somma dei risultato -> somme<-c()
Creiamo la funzione di probabilità per il lancio dei dadi, in modo che il risultato dato dai lanci restituisca
la somma del risultato -> for (i in 1:nsim){ ris<-sample(dado, size=10, rep=T)
somme[i]<-sum(ris)}

Primo metodo creazione grafico:

Si crea l’istogramma -> hist(somme, nclass=30, prob=T, col = "red", main="somma di 10 dadi", ylab =
"Frequenza Relativa")
Sopra l’istogramma si disegna una curva tramite il comando dnorm che si basa sulle densità di frequenza,
basandosi sull’elemento x e sulla media e deviazione standard del vettore somme-> curve(dnorm(x,
mean=mean(somme), sd=sd(somme)), add=T)

Comando dnorm()- va a calcolare la densità di un dato elemento x in un punto, con media e deviazione
standard pari rispettivamente a 0 e 1, per andare a specificare variazione di questi fattori nella funzione se
diversi.
Altre varianti del comando dnorm sono:
- pnorm(), che va a rappresentare la probabilità cumulata fino a quel punto (funzione di ripartizione);
- qnorm() che va a rappresentare il quantile corrispondente al valore della probabilità prefissata.

Secondo metodo costruzione grafico tramite standardizzazione:

Si standardizza valore tramite comando scale() com m=0 e sd=1-> sc.somme<-scale(somme)
Si determinano le classi, con un intervallo compreso tra -5 e 5
segmentato in 20 parti-> classi=seq(-5,5,length=20)
Si crea l’istogramma-> hist(sc.somme, breaks=classi,prob=T, col = "red",
main="somma standardizzata di 10 dadi", ylab = "Frequenza Relativa")
Si aggiunge la curva-> curve(dnorm(x), add=T)

ESEMPIO 2. Qual è la probabilità di ottenere meno di 20?

Rispondendo in maniera empirica-> sum(somme<20)/nsim

Rispondendo con approssimazione della normale-> Poiché, al crescere del numero di dadi lanciati,
l’istogramma tende a diventare “normale”, possiamo usare questa approssimazione

Andiamo a vedere gli elementi fondamentali della distribuzione->summary(somme)

Andiamo a calibrare le densità -> pnorm(20, mean=mean(somme), sd=sd(somme))
(extra) correzione di continuità per avere approssimazioni migliori-> pnorm(19.5, mean=35,
sd=sd(somme))

Se in distribuzione normale vogliamo colorare solo una zona del grafico -> curve(dnorm(x,2,2), -4, +8,
ylab = "", xlab = "Densità N(2,2)")
abline(h=0, lty=1, col="black")
abline(v = 3, lty = 1, col="red")
abline(v = 0, lty = 1, col="red")
asc<-seq(0,3, length=201)
ord<-c(0,dnorm(asc, 2,2),0)
asc<-c(0, asc, 3)
polygon(asc, ord, 15, col="violetred")
LEZIONE 11
#LEGGE DEI GRANDI NUMERI- la media campionaria converge, al crescere di n, alla vera media della
distribuzione

f1 <- function(n,mu,stdev) { mean( rnorm(n, mean=mu, sd=stdev) ) } #distribuzione normale di valori causali
(rnorm per generare valori causali da una normale, rbnorm da una binomiale, runif da un’uniforme)- questa
funzione 1°parametro= nuomero valori che vogliamo generare e gli altri due sono media e sd es: f1(10,5,10)

GRAFICAMENTE
a=vettore generata dalla normale; ps=vettore di
f2 <- function(n,mu,stdev)
medie parziali (media dei primi l elementi del vettore
{
generato per l che va da 1 n); aggiungi linea
a <- rnorm(n, mu, stdev)
orizzontale per il valore vero della pop; aggiungi due
ps <- cumsum(a)/1:n # sequenza delle medie parziali
linee orizzontali rosse in un’intorno del valore vero
plot(ps , type="l", ylim=c(mu-3,mu+3) )
della pop.
abline(h=mu,col="blue")
abline(h=c(mu+0.5,mu-0.5),col="red") Dopo aggiungi per esempio f2(1000,5,1) per verificare
}

#BERNOULLI (media=freq relativa dei successi)

f3 <- function(n,p)
{ Uguale a sopra, tranne:
a <- sample(0:1, n, rep=TRUE, prob=c(1-p,p)) Sample= perché per generare valori
ps <- cumsum(a)/1:n # sequenza delle medie parziali causali da una Bernoulli si devono
plot(ps , type="l", ylim=c(p-0.1,p+0.1) ) campionare elementi con ripetizioni da
abline(h=p,col="blue") 0 a 1 con probabilità 1-p e p
abline(h=c(p-0.01,p+0.01),col="red")
} Prova-> f3(1000,o.5)

#PROB CHE IL log(X^4)>10

x <- rnorm(1e6,5,10) #generare valori da una normale

y <- log(x^4) #trasformazione dei precedenti valori
mean(y > 10) #frequenza relativa del numero di valori generati maggiori di 10 (perché calcoli la media delle
freq ass)

# TEOREMA LIMITE CENTRALE TLC

curve(dunif,-1,2,n=1000) # distribuzione uniforme nell’intervallo [0,1]

runif(3) #generiamo 3 valori dalla distribuzione uniforme

fU1 <- function(m,n){

Per generare m campioni di ampiezza n= ciclo for. Per
medie <- rep(0,m)
ciascun elemento i associamo la media di un campione
for (i in 1:m) { medie[i] <- mean ( runif(n) ) }
generato dalla uniforme
medie
}
#ALTRO METODO- MIGLIORE
Generiamo m*n valori, organizziamo i valori in una
fU2 <- function(m,n){
matrice con n colonne e m righe, ciascuna riga
valori <- runif(m*n)
rappresenta un campione x1,...,xn generato
valori_mat <- matrix(valori,nrow=m,ncol=n)
dall'Uniforme, calcoliamo la media per ogni riga
apply(valori_mat,1,mean)
}

n <- 3 #fissiamo un’ampiezza campionaria, in tal caso=3

medie <- fU2(1e4,n) #1e4=numero simulazioni
hist(medie,breaks=40,prob=TRUE,xlim=c(0,1)) # grafico media campionaria

curve( dnorm(x,0.5,sqrt(1/(12*n))), add=T,lwd=2,lty=2,col="red") #per confrontare la distribuzione simulata

con quella teorica

#VERIFICA GLI STESSI RISULTATI PER LA FREQ DI SUCCESSI- BERNOULLI, con parametro p

fB <- function(m,n,p)
{
a <- sample(0:1,m*n,rep=TRUE,prob=c(1-p,p))
b <- matrix(a,ncol=n)
apply(b,1,mean)
}

p <- 0.7 #parametro p

n <- 10 #ampiezza (più aumenta e più si approssima alla normale
medie <- fB(1e5,n,p)

hist(medie,breaks=10,prob=TRUE) #istogramma
curve(dnorm(x,p,sqrt(p*(1-p)/n)),add=T,lwd=2,lty=2,col="red") # confrontiamo graficamente la
distribuzione simulata con una normale di media p e varianza p*(1-p)/n
TUTTO QUESTO SERVE PER VERIFICARE LA BONTÀ DI ADATTAMENTI DEGLI STIMATORI

#campionamento ripetuto- DISTRIBUZIONE DELLA MEDIA CAMPIONARIA COME VA

n <- 35
s <- sample(1:150, n, rep=FALSE) #generiamo dei valori tra 1 e 150 (numerosità pop), senza rip
campione <- iris[s,] #creazioni campione
mean(campione$Petal.Length) #media nel campione rispetto alla lunghezza del petalo
mean(campione$Species == "versicolor") #prob che un fiore appartenga a versicolor

format( choose( nrow(iris) , n ) , sci=F ) #numero di campioni possibili= coef binomiale

m <- 50000 #estraiamo 50000 campioni

medie <- rep(0,m) #vettore media lunghezza petali
prob <- rep(0,m) #vettore di prob di appartenenza a una specie definita
for (i in 1:m) Estraiamo valori tra 1 e 150, estraiamo i campioni,
{ media, freq relativa degli elementi di una specie. Dopo
s <- sample(1:150, n, rep=FALSE) questo passaggio si possono verificare gli istogrammi
campione <- iris[s,c("Petal.Length","Species")] per analizzare la distribuzione simulata dei 2 stimatori
medie[i] <- mean(campione$Petal.Length)
prob[i] <- mean(campione$Species=="versicolor")
}

hist(medie,prob=TRUE) #distribuzione campionaria della media della lunghezza petali

hist(prob,prob=TRUE) #distribuzione campionaria della freq relativa del n° fiori appartenenti alla specie

mean(medie<4) #probabilità che la media campionaria della lunghezza dei petali sia < 4cm
mean(prob<0.3) #probabilità che la % di fiori versicolor in un campione sia <30%

#SOLITAMENTE NON SI ESEGUE TALE SIMULAZIONE MA SI FA RIFERIMENTO AL TLC

ESEMPIO1
m_pop <- mean(iris$Petal.Length) #calcolo media
var_pop <- var(iris$Petal.Length) #calcolo varianza
pnorm(4,m_pop,sqrt(var_pop/n)) #distribuzione cumulata della normale- punto 4

ESEMPIO2
m_pop2 <- mean(iris$Species=="versicolor") #numerosità specie versicolor in freq relativa nella pop
var_pop2 <- m_pop2*(1-m_pop2) #varianza con BERNOULLI
pnorm(0.3,m_pop2,sqrt(var_pop2/n)) #approssimazione alla normale
LEZIONE 12
INTERVALLI DI CONFIDENZA- andiamo ad includere nella stima un'informazione sulla variabilità della stessa
fornendo un intervallo di valori plausibili invece di un singolo valore. Includeremo i valori più probabili,
dove la probabilità è misurata sulla base della distribuzione della media campionaria.

Data una popolazione bernoulliana di parametro p=0.6

n <- 50 # numerosità campionaria
p <- 0.6
x <- sample(0:1,n,rep=TRUE,prob=c(1-p,p))
m_cam <- mean(x)

Sappiamo che la media campionaria in questo caso ha distribuzione binomiale, ma dal teorema del limite
centrale, per campione con n elevato, la distribuzione può essere approssimata da una Normale con
media pari a media popolazione e con varianza data da varianza popolazione divisa per n, ovvero con una
deviazione standard pari a:
sd_cam <- sqrt(m_cam*(1-m_cam)/n)

Stimiamo la distribuzione della media campionaria come una distribuzione normale:

curve( dnorm(x,mean=m_cam, sd=sd_cam) , m_cam-3*sd_cam, m_cam+3*sd_cam,ylab="")

La funzione qnorm(p,mean,sd) restituisce il quantile a livello p di una normale con parametri dati
(ex. Mediana -> qnorm(0.5,123,30) )

Troviamo i due quantili della distribuzione:

q1 <- qnorm(0.025,m_cam,sd_cam) # quantile a livello 2.5%
q2 <- qnorm(0.975,m_cam,sd_cam) # quantile a livello 97.5%
Differenza interquartilica -> pnorm(q2,m_cam,sd_cam)-pnorm(q1,m_cam,sd_cam)

Possiamo giugnere allo stesso risultato riferendoci alla Normale standard:

z1 <- qnorm(0.025) # 2.5% quantile di N(0,1)
z2 <- qnorm(0.975) # 97.5% quantile di N(0,1)

Per graficare intervallo:

curve( dnorm(x,mean=m_cam, sd=sd_cam) ,
m_cam-3*sd_cam, m_cam+3*sd_cam,ylab="") #grafico distribuzione
asc <- seq(q1,q2, length=200)
ord <- c(0,dnorm(asc, m_cam, sd_cam),0)
asc <- c(q1,asc,q2) #valori compresi in intervallo
abline(v=c(q1,q2)) #delimitazione intervallo
segments(q1,0,q2,0,lwd = 3)
polygon(asc, ord, 45,col="red") #dare colore ad intervallo

Intervallo di confidenza può essere calcolato come c(m_cam - z2*sd_cam , m_cam - z1*sd_cam)
o visto che z2=-z1 -> c(m_cam - z2*sd_cam , m_cam + z2*sd_cam)
corrispondente ad intervallo precedente -> c(q1,q2)

Ora considerando una distribuzione empirica

con un livello di significatività pari ad α=0,05 -> q1 <- qnorm(0.025,m_cam,sd_cam)
q2 <- qnorm(0.975,m_cam,sd_cam)
con intervallo di confidenza -> c(q1,q2)
vogliamo estrarre m campioni di numerosità dalla popolazione bernoulliana di parametro p, andando a
calcolare l’intervallo di confidenza per ciascun campione:
f <- function(m, n, p){
mat <- matrix( sample(0:1,n*m,rep=T,prob=c(1-p,p)) , nrow=m , ncol= n )
# ogni riga di mat costituisce un campione di n elementi
m_cam <- apply(mat,1,mean) # vettore delle medie campionarie
sd_cam <- sqrt(m_cam*(1-m_cam)) #vettore sd campionarie
z <- qnorm( 0.975 )
lb <- m_cam -z*sd_cam/sqrt(n) # vettore dei limiti inferiori degli intervalli
ub <- m_cam +z*sd_cam/sqrt(n) # vettore dei limiti superiori degli intervalli
data.frame(lb,ub)
}

Secondo il principio del campionamento ripetuto ci aspettiamo che, al crescere del numero di campioni
estratti, la percentuale di intervalli costruiti che includono il valore effettivo della media della popolazione
si approssima a 95%
p <- 0.5
ris <- f(m=1e4 , n=100 , p=p)
head(ris)
vediamo quante volte il valore vero del parametro è incluso -> mean(ris$lb <= p & ris$ub >= p)

Plot dei primi 50 intervalli:

plot( ris$lb[1:50] , pch=19 , col="red" , cex=0.5 ,ylab="" , xlab="Interval" , ylim=c(min(ris$lb),max(ris$ub)) )
points( ris$ub[1:50] , pch=19 , col="red" , cex=0.5)
segments( x0=1:50 , y0=ris$lb[1:50] , x1=1:50 , y1=ris$ub[1:50] )
abline( h=p,col="blue",lwd=2,lty=2)

Andiamo ad estrarre m campioni di numerosità dalla popolazione, cui calcoliamo l’intervallo di confidenza
per ciascun campione:
f_iris <- function(m, n){
lb <- rep(0,m)
ub <- rep(0,m)
v <- iris$Sepal.Length
z <- qnorm( 0.975 )
for (i in 1:m) {
cam <- v[sample(150,n)] # estraggo n righe di iris senza ripetizione
m_cam <- mean(cam)
sd_cam <- sd(cam)
lb[i] <- m_cam -z*sd_cam/sqrt(n)
ub[i] <- m_cam +z*sd_cam/sqrt(n)}
data.frame(lb,ub)}

Anche se stiamo estraendo campioni senza ripetizione da una popolazione finita di distribuzione incognita,
comunque la distribuzione campionaria risulta approssimativamente normale:
ris <- f_iris(m=1e4 , n=20)
head(ris)
vediamo quante volte il valore vero del parametro è incluso -> m_pop <- mean(iris$Sepal.Length)
mean(ris$lb <= m_pop & ris$ub >= m_pop)

TEST D’IPOTESI - Quantificazione della sostenibilità di ipotesi, basandoci su di un campione casuale estratto
dalla popolazione.
Generiamo un campione di numerosità n da una Normale di parametro 99 per vedere cosa succede alla
nostra ipotesi.
x <- rnorm(50 , 99, sqrt(5)) p_cam <- mean(x)
Per calcolare la probabilità di osservare un valore almeno altrettanto distantedall'ipotesi H0 su p utilizziamo
la funzione pnorm(), probabilità di un valore più piccolo di quello osservato (coda sinistra):
pnorm(p_cam, mean=100, sd=sqrt(5/50))

curve( dnorm(x,mean=100, sd=sqrt(5/50)) , 98,102, ylab="")

abline(v=100,lwd=2)
abline(v=p_cam)
asc <- seq(98, p_cam, length=200)
ord <- c(0,dnorm(asc, 100, sqrt(5/50)),0)
asc <- c(98,asc,p_cam)
polygon(asc, ord, 45,col="red")

Per simmetria della Normale, la probabilità di un qualsiasi valore altrettanto

distante nella direzione opposta (coda destra) è la stessa:
1-pnorm(2*100-p_cam, 100, sqrt(5/50))

abline(v=2*100-p_cam)
asc <- seq(2*100-p_cam , 102 , length=200)
ord <- c(0,dnorm(asc, 100, sqrt(5/50)),0)
asc <- c(2*100-p_cam , asc , 102)
polygon(asc, ord, 45,col="red")

Scriviamo una funzione per vedere come cambia la probabilit? al variare dei parametri
f <- function(n,mu,sd,H0){
x <- rnorm(n , mu, sd) # genero dai parametri in input
p_cam <- mean(x)
if(p_cam < H0) # testo ipotesi H0 per la media
{ return(2*pnorm( p_cam, H0, sd/sqrt(n) ))
} else { return(2*(1-pnorm( p_cam, H0, sd/sqrt(n)) ) ) } }