Prepara gli esami con i nostri Tutor Online prova gratis

Stat - Introduzione a R, Appunti di Statistica Applicata. Università di Cassino

Statistica Applicata

Descrizione: Le basi per l'ultilizzo degli Script in R
Mostro le pagine  1  -  2  di  23
La preview di questo documento finisce qui| Per favore o per leggere il documento completo o scaricarlo.
Informazioni sul documento
Caricato da: sector
Visite: 1000+
Downloads : 0
Universita: Università di Cassino
Indirizzo: Economia
Data di caricamento: 13/04/2011
Incorpora questo documento nel tuo sito web:

scriptIntroduzioneR.R #------------------------------------------------------------------------------- ---------- #per chiamare una funzione anche senza argomenti è sempre necessario inserire le parentesi help.start help.start() #------------------------------------------ #ricerca nell'help #------------------------------------------ #per parola chiave (due possibili modalità) help.search("regression") ??regression #per nome della funzione help(mean) ?mean #per l'help di alcune funzioni (quelle di programmazione e gli operatori) #è necessario usare gli apici (singoli o doppi) ?for ?"for" #digitando il nome di una funzione è possibile visualizzare il codice associato mean #alcune funzioni sono di tipo generico (che lavorano in modo differente a seconda #del tipo di argomento passato in input) #per vedere quali funzioni sono disponibili per i vari oggetti si può utilizzare #la funzione methods methods(mean) #la funzione mean.default è quella che viene chiamata nel caso in cui non sia #disponibile una funzione specifica per il tipo di argomento passato in input mean.default #gli esempi della funzioni possono essere provati usando la funzione example example(mean) example(plot) example(plotmath) #per alcune funzioni è disponibile un insieme di esempi più esteso accessibile #attraverso il comando demo() demo(graphics) #per visualizzare la lista di funzioni con demo associate #(dipende anche da quali librerie sono installate) demo() #per visualizzare le demo in tutte le librerie installate demo(package = .packages(all.available = TRUE))

#assegnazione esplicita primaVariabile <- 1 + 1 #e stampa a video print(primaVariabile) #scorciatoia per la stampa primaVariabile #attenzione: in alcuni casi (all'interno di funzioni e nei cicli di iterazione) è necessario #usare la funzione print esplicitamente per visualizzare il contenuto di un oggetto (questo #vale inparticolare per i grafici)

#assegnazione con stampa (secondaVariabile <- 2 + 2) #assegnazione implicita 3 + 3 #variabile utilizzata per l'assegnazione implicita .Last.value #il contenuto di un'espressione non assegnata può essere recuperato terzaVariabile <- .Last.value #il nome di una variabile che inizia per . .quartaVariabile <- "prova" #una variabile stringa che contiene un apice quintaVariabile <- "un'altra prova" #alternativa quintaVariabile <- 'un\'altra prova'

1agina p

scriptIntroduzioneR.R quintaVariabile

#due valori particolari TRUE FALSE #e relative scorciatoie T F #che succede se cerco di accedere ad una variabile che non esiste variabileNonEsistente

#quali sono le variabili disponibili? ls() #attenzione: dove è finita quella che inizia con il punto ls(all.names=TRUE) #il vettore dei semi casuali .Random.seed #per assicurare la riproducibilità dei risultati, nel caso si lavori con numeri #pseudo-casuali, è necessario fissare il seme set.seed(17)

#proviamo a fare un pò di pulizia ls() rm(primaVariabile) ls() #proviamo a fare piazza pulita rm(list=ls()) ls() #attenzione però alle variabili che iniziano con un punto ls(all.names=TRUE)

#gli operatori sono una scorciatoia: ogni espressione può essere scritta usando una #sintassi funzionale variabile1 <- 1 #usando un nome associato all'operatore assign("variabile2", 2) ls() #o l'operatore tra apici (singoli o doppi) "<-"("variabile3", 3) ls()

#partiamo da capo rm(list=ls()) #ecco uno scalare scalare <- 1 #un vettore di due numeri (vettoreLunghezza2 <- c(2, 3)) #un vettore di tre caratteri vettoreCaratteri <- c("a", "b", "cc") #un vettore di 10 numeri vettoreLunghezza10 <- 1:10 #una matrice matrice1 <- matrix(1:10, 5, 2); matrice1 #che avrei potuto creare anche a partire da una variabile #presente sul workspace matrix(vettoreLunghezza10, 5, 2) #guardiamo i dettagli della funzione matrix ?matrix #sintassi di chiamata per posizione matrice1 <- matrix(1:10, 5, 2); matrice1 #sintassi di chiamata per nome matrice1 <- matrix(nrow=5, ncol=2, data=1:10); matrice1 #sintassi di chiamata mista matrice1 <- matrix(nrow=5, 1:10, 2); matrice1 #cambio il valore di un argomento che ha un default matrice1 <- matrix(1:10, 5, 2, byrow=T); matrice1 #se il numero di elementi eccede le posizioni vengono presi solo quelli necessari

2agina p

scriptIntroduzioneR.R (matrice2 <- matrix(12:1, 1, nrow=6)) #posso specificare tutti i parametri (matrice2 <- matrix(12:1, 1, nrow=6, ncol=2)) #ma posso fare calcolare a R i valori di alcuni argomenti a partire da quelli passati #in input (matrice2 <- matrix(12:1, ncol=2)) #anche se il numero di elementi è minore delle posizioni da riempire R provvede #automaticamente a "sistemare" le cose (matrice2 <- matrix(100, 1, nrow=6)) #attenzione: anche se potrebbe sembrare, questa è una matrice e non un vettore #il vettore con una dimensione

#per inizializzare vettori numerici da riempire successivamente numeric(10) #o fissando il tipo integer(10) double(10)

#per inizializzare un vettore di stringhe character(10)

#un altro vettore (con 12 elementi) vettoreLunghezza12 <- 12:1 #e uno con tre elementi vettoreLunghezza3 <- 1:3 #un array tridimensionale array3d <- array(1:24, dim=c(4,3,2)) array3d #stampo degli oggetti disponibili con informazioni sul relativo contenuto ls.str() #lunghezza di un vettore length(vettoreLunghezza10) #di una matrice length(matrice1) #e di un array a più dimensioni length(array3d)

#dimensione di un vettore dim(vettoreLunghezza10) #di una matrice dim(matrice1) #e di un array a più dimensioni dim(array3d)

#è possibile assegnare una dimensione differente e cambiare l'oggetto varAppoggio <- vettoreLunghezza10 dim(varAppoggio) <- c(2,5) varAppoggio

varAppoggio <- matrice1 dim(varAppoggio) <- c(2,5) #confrontate la posizione degli elementi: come sono disposti rispetto all'oggetto di partenza? matrice1 varAppoggio

#è anche possibile impostare a NULL la dimensione di un oggetto senza perdere il contenuto varAppoggio <- array3d dim(varAppoggio) <- NULL varAppoggio

#è possibile concatenare oggetti dello stesso tipo c(vettoreLunghezza2, vettoreLunghezza10) #o di tipo differente c(vettoreLunghezza2, vettoreCaratteri) #il tipo più forte ha però la meglio mode(c(vettoreLunghezza2, vettoreCaratteri))

3agina p

scriptIntroduzioneR.R

#la regola del riciclaggio #nel caso di due vettori vettoreLunghezza10 + vettoreLunghezza10 vettoreLunghezza2 + vettoreLunghezza10 vettoreLunghezza3 + vettoreLunghezza10 #per capire meglio come funziona la regola del riciclaggio cbind(vettoreLunghezza10, vettoreLunghezza10) cbind(vettoreLunghezza10, vettoreLunghezza2) cbind(vettoreLunghezza10, vettoreLunghezza3)

#in alcuni casi l'accostamento di oggetti di dimensione diversa porta a modifiche #sulla struttura risultante cbind(scalare, array3d)

#il riciclaggio tra un vettore e una matrice cbind(matrice1, scalare) cbind(matrice1, vettoreLunghezza10) cbind(matrice1, vettoreLunghezza2) cbind(matrice1, vettoreLunghezza3) #operazioni tra un vettore e una matrice matrice1 + scalare matrice1 + vettoreLunghezza2 matrice1 + vettoreLunghezza3 #operazioni tra un vettore e un array array3d + scalare array3d + vettoreLunghezza2

#il riciclaggio tra due matrici non funziona cbind(matrice1, matrice2) #si può però semplificare la struttura di output c(matrice1, matrice2) #lo stesso avviene anche se si lavora su un solo oggetto c(matrice1)

#alcune funzioni per avere informazioni sui tipi di oggetti e sul loro contenuto vettoreIntero <- integer(2) c(mode(vettoreIntero), class(vettoreIntero), typeof(vettoreIntero))

vettoreDouble <- double(2) c(mode(vettoreDouble), class(vettoreDouble), typeof(vettoreDouble))

vettoreCaratteri <- character(2) c(mode(vettoreCaratteri), class(vettoreCaratteri), typeof(vettoreCaratteri))

matriceInteri <- matrix(integer(4),2,2) c(mode(matriceInteri), class(matriceInteri), typeof(matriceInteri))

matriceDouble <- matrix(double(4),2,2) c(mode(matriceDouble), class(matriceDouble), typeof(matriceDouble))

matriceCaratteri <- matrix(character(4),2,2) c(mode(matriceCaratteri), class(matriceCaratteri), typeof(matriceCaratteri))

arrayDouble <- array(double(24), c(4,3,2)) c(mode(arrayDouble), class(arrayDouble), typeof(arrayDouble))

#alcuni funzioni di conversione tra tipi as.character(vettoreLunghezza2) as.integer(as.character(vettoreLunghezza2)) as.integer(2.3) as.double(as.integer(2.3))

#alcune funzioni per controllare il tipo is.integer(vettoreIntero) is.integer(vettoreDouble) is.integer(vettoreCaratteri)

4agina p

scriptIntroduzioneR.R

is.double(vettoreIntero) is.double(vettoreDouble) is.double(vettoreCaratteri)

is.numeric(vettoreIntero) is.numeric(vettoreDouble) is.numeric(vettoreCaratteri)

is.character(vettoreIntero) is.character(vettoreDouble) is.character(vettoreCaratteri)

is.vector(scalare) is.vector(vettoreLunghezza3) is.vector(matrice1) is.vector(array3d)

is.matrix(scalare) is.matrix(vettoreLunghezza3) is.matrix(matrice1) is.matrix(array3d)

is.array(scalare) is.array(vettoreLunghezza3) is.array(matrice1) is.array(array3d)

#tutti i tipi atomici hanno sempre elementi dello stesso tipo is.atomic(scalare) is.atomic(vettoreLunghezza3) is.atomic(matrice1) is.atomic(array3d)

#per salvare l'intero contenuto del workspace su file #se si salva su un file senza nome ma con estensione nella directory di lavoro #il file sarà caricato direttamente in R al prossimo avvio save.image("C:\\Documents and Settings\\Docente\\Desktop\\introduzioneR\\.RData") #se si salva specificando il nome è necessario caricare il file in R usando il #comando load save.image("C:\\Documents and Settings\\Docente\\Desktop\\scuolaR_2009\\comandiR.RData")

#carichiamo il prezioso tesoro #non necessario se abbiamo salvato un file .RData (senza nome) nella directory di lavoro di default load("C:\\Documents and Settings\\Docente\\Desktop\\scuolaR_2009\\comandiR.RData")

#una prima (grossolana) funzione per la gestione di output su file ?sink #controlliamo la directory corrente getwd() #e redirezionamo l'output su file: invece di scrivere sulla console R utilizzerà il file sink("provaOutut.txt") #due comandi di prova a <- 1:10 a #chiusura del file sink() #la funzione history permette di visualizzare una lista dei comandi inviati history() #maggiori dettagli sono forniti nell'help ?history #posso chiedere di visualizzare solo un certo numero di comandi #i primi digitati nella sessione history(10, rev=FALSE)

5agina p

scriptIntroduzioneR.R #o gli ultimi history(10, rev=TRUE) #posso usare il valore speciale Inf per visualizzare l'intera history dei comandi history(Inf)

#un semplice esempio di un file script #salviamo le seguenti istruzioni nel file provaScript.R nella directory corrente #-------------------------------------------- matrice1 <- matrix(nrow=5, ncol=2, data=1:10) print(matrice1) #e la stampo a video (matrice2 <- matrix(12:1, 1, nrow=6, ncol=2)) vettoreLunghezza10 <- 1:10 vettoreLunghezza12 <- 12:1 ls() #--------------------------------------------

#per richiamare un file script si può usare la funzione source source("provaScript.R")

#due funzioni speciali che vengono eseguite #all'avvio di R .First #prima della chiusura di R .Last

#le due funzioni devono trovarsi nel workspace corrente #per la funzione .First è quindi necessario che ci sia un workspace caricato automaticamente all'avvio di R #ovvero un file .RData nella directory di lavoro dove vi sia una funzione .First definita

#un semplice esempio di funzione .First #che esegue lo script creato sopra .First <- function() source("C:\\Documents and Settings\\Docente\\Desktop\\scuolaR_2009\\provaScript.R") #un semplice esempio di funzione .Last #che stampa un messaggio a video e aspetto che l'utente prema INVIO .Last <- function() {print("ciao"); scan()}

#per visualizzare il codice associato alla funzione (stampo l'oggetto funzione) .Last #in alternativa print(.Last) #per chiamare le funzioni (senza aspettare la chiusura di R) .Last() .First()

#vediamo cosa abbiamo disponibile sul workspace ls() #un oggetto non atomico #in grado di contenere oggetti di struttura e con contenuto differente listaSenzaNomi <- list(scalare, vettoreLunghezza10, vettoreCaratteri, matrice1) is.atomic(listaSenzaNomi) listaSenzaNomi #possiamo decidere di assegnare un nome a ciascun componente della lista #da utilizzare in seguito in alternativa alla posizione per richiamare gli elementi listaNomi <- list(scal=scalare, vettore=vettoreLunghezza10, vetCar=vettoreCaratteri, mat=matrice1) listaNomi

#qualche informazione tecnica sulla lista c(mode(listaNomi), class(listaNomi), typeof(listaNomi))

#un tipo particolare di lista: la tabella dati (o dataframe) dfNomi <- data.frame(var1=vettoreCaratteri, var2=vettoreLunghezza3) is.atomic(dfNomi) dfNomi

6agina p

scriptIntroduzioneR.R

#qualche informazione tecnica sul dataframe (da confrontare con quelle della lista) c(mode(dfNomi), class(dfNomi), typeof(dfNomi))

#per la funzione generica print esiste una funzione diversa per ciascuno dei tipi #in particolare dovreste vedere una funzione che regola la stampa di una lista #e di un dataframe methods(print)

#la regola del riciclaggio viene applicato anche nel caso della creazione del dataframe data.frame(scalare, vettoreLunghezza10) data.frame(vettoreLunghezza2, vettoreLunghezza10) #ma non nel caso in cui il numero di elementi dell'oggetto di lunghezza più piccolo #non è un sottomultiplo esatto del numero di elementi dell'oggetto di lunghezza più grande data.frame(vettoreLunghezza3, vettoreLunghezza10) cbind(vettoreLunghezza3, vettoreLunghezza10) #un piccolo sotterfugio per aggirare l'ostacolo as.data.frame(cbind(vettoreLunghezza3, vettoreLunghezza10)) #sintassi equivalente data.frame(cbind(vettoreLunghezza3, vettoreLunghezza10)) #attenzione però alla conversione dei tipi in queste operazioni data.frame(vettoreLunghezza3, vettoreCaratteri) #solo apparentemente la creazione del data.frame avviene conservando #i tipi reali degli oggetti (entrambi vengono gestiti come fattori) data.frame(cbind(vettoreLunghezza3, vettoreCaratteri)) #per convincersene basta guardare l'output del comando interno cbind(vettoreLunghezza3, vettoreCaratteri) #una controprova: cambiamo il parametro che per default converte le variabili di tipo #stringa in fattori df1 <- data.frame(vettoreLunghezza3, vettoreCaratteri, stringsAsFactors=FALSE) df2 <- data.frame(cbind(vettoreLunghezza3, vettoreCaratteri), stringsAsFactors=FALSE) #per accedere ad una colonna si può usare il $ e il nome della colonna (dopo ci sono ulteriori dettagli) df1$vettoreLunghezza3 df1$vettoreCaratteri df2$vettoreLunghezza3 df2$vettoreCaratteri

#un dataframe è un sotto-tipo di una lista (con un vincolo: lunghezza uguale per tutti i componenti #della lista) dfNomi is.list(dfNomi) is.data.frame(dfNomi)

listaNomi is.list(listaNomi) is.data.frame(listaNomi)

#conversione tra le due strutture as.list(dfNomi) as.data.frame(listaNomi) as.data.frame(as.list(dfNomi))

#in alcuni casi si può rinunciare alla struttura e cercare di prese #ma con qualche necessario compromesso unlist(listaNomi) unlist(dfNomi)

#gli oggetti, oltre a mode e dim, hanno anche un attributo che regola i nomi #dei singoli elementi names(vettoreLunghezza2)

7agina p

scriptIntroduzioneR.R names(vettoreLunghezza2) <- c("primo","secondo") vettoreLunghezza2

#la regola del riciclaggio non vale per i nomi names(vettoreLunghezza10) <- c("lun","mar","mer","gio","ven") vettoreLunghezza10 names(vettoreLunghezza10) <- rep(c("lun","mar","mer","gio","ven"), 2) vettoreLunghezza10

#si possono fissare sia nomi per i singoli elementi matrice1 names(matrice1) <- letters[1:10] matrice1 #che nomi associati alle dimensioni (laddove queste siano presenti) dimnames(matrice1) #una parentesi: la funzione paste può essere usata per creare al volo le etichette paste("prova", 1:10) paste("prova", 1:10, sep="") #nel caso della matrice potremmo usare paste("riga", 1:nrow(matrice1), sep="")

#è possibile assegnare dei nomi a una sola delle dimensioni dimnames(matrice1) <- list(paste("riga", 1:nrow(matrice1), sep=""), NULL) matrice1 colnames(matrice1) #o ad entrambe dimnames(matrice1) <- list( paste("riga", 1:nrow(matrice1), sep=""), paste("colonna", 1:ncol(matrice1), sep="") ) matrice1

#è possibile anche sfruttare una funzione differente per i nomi di riga e per i nomi di colonna dimnames(matrice1) <- NULL matrice1 rownames(matrice1) <- paste("riga", 1:nrow(matrice1), sep="") colnames(matrice1) <- paste("colonna", 1:ncol(matrice1), sep="")

#per visualizzare gli attributi impostati di un oggetto attributes(matrice1) #la funzione attributes permette di visualizzare gli attributi impostati attributes(matrice2)

#la funzione attr permette di accedere ad un singolo attributo di un oggetto #usando il nome dell'attributo attr(matrice1,"dim") attr(matrice1,"names") attr(matrice1,"dimnames")

#sistemiamo nuovamente l'array 3d impostando le dimensioni corrette array3d dim(array3d) <- c(4, 3, 2) array3d

#anche nel caso dell'array3d è possibile impostare i nomi per i singoli elementi names(array3d) names(array3d) <- letters[1:length(array3d)] array3d #e i nomi per ciascuna delle dimensioni array3d dimnames(array3d) dimnames(array3d) <- list(paste("riga", 1:dim(array3d)[1], sep=""), paste("colonna", 1:dim(array3d)[2], sep=""), paste("strato", 1:dim(array3d)[3],sep="")) array3d attributes(array3d)

8agina p

scriptIntroduzioneR.R

#nel caso delle liste i nomi dei singoli elementi sono quelli attribuiti esplicitamente #in fase di creazione della lista names(listaSenzaNomi) names(listaNomi)

#è possibile assegnare dei nomi agli elementi della lista anche dopo la creazione names(listaSenzaNomi) <- letters[1:4] listaSenzaNomi #anche nel caso della lista la funzione attributes permette di accedere agli #attributi impostati per l'oggetto attributes(listaSenzaNomi)

#se si usa la funzione attributes per il data frame si nota che esistono due tipi di #nomi associati #names indica i nomi degli elementi del dataframe (ovvero delle due colonne della tabella) #row.names indica i nomi di riga che, se non esplicitamente definiti (come nel nostro caso) #sono rappresentati da un numero sequenziale #NOTA: in questo caso l'attributo è row.names attributes(dfNomi) #è possibile accedere ai nomi di riga del dataframe usando la funzione row.names e ai nomi #di colonna usando la funzione names row.names(dfNomi) names(dfNomi) #è anche possibile usare le due funzioni rownames e colnames viste per l'accesso ai nomi di #riga e colonna di una matrice (questo sempre nella logica che il dataframe può essere visto #sia come una particolare lista con un vincolo aggiuntivo che come una tabella con un vincolo #in meno, ovvero come una tabellla "non atomica") rownames(dfNomi) colnames(dfNomi)

vettoreLunghezza10 #i valori booleani TRUE e FALSE sono trattati nelle operazioni algebriche come 1 e 0 rispettivamente vettoreLunghezza10 > 5 as.numeric(vettoreLunghezza10 > 5) #questo permette di contare il numero di elementi che soddisfano una o più condizioni usando la funzione sum sum(vettoreLunghezza10 > 5) #questo in alternativa all'estrazione degli elementi e al successivo controllo della lunghezza length(vettoreLunghezza10[vettoreLunghezza10 > 5])

#la funzione which restituisce invece le posizioni degli elementi che soddisfano la condizione which(vettoreLunghezza10 > 5) #queste posizioni possono essere utilizzate per estrarre gli elementi vettoreLunghezza10[which(vettoreLunghezza10 > 5)] #è possibile però passare in input all'operatore di estrazione [ direttamente il vettore di booleani vettoreLunghezza10 > 5 vettoreLunghezza10[vettoreLunghezza10 > 5]

#proviamo ad esempio ad estrarre i numeri pari dal vettore #resto della divisione per due vettoreLunghezza10 %% 2 #i numeri pari hanno resto pari a 0 vettoreLunghezza10 %% 2 == 0 #per cui si può sapere quali sono le posizioni degli elementi che soddisfano la

9agina p

scriptIntroduzioneR.R condizione usando #la funzione which which(vettoreLunghezza10 %% 2 == 0) #ed estrarre gli elementi usando la funzione [ vettoreLunghezza10[vettoreLunghezza10 %% 2 == 0]

#è possibile controllare più condizioni contemporaneamente #l'operatore & (AND logico) controlla se le due condizioni sono verificate simultaneamente #l'operatore | (OR logico) controlla se almeno una delle due condizioni è verificata #controlliamo se il numero è divisibile sia per 2 che per 3 vettoreLunghezza10 %% 2 == 0 & vettoreLunghezza10 %% 3 == 0 #controlliamo se il numero è divisibile per 2 o per 3 vettoreLunghezza10 %% 2 == 0 | vettoreLunghezza10 %% 3 == 0 #possiamo negare la condizione usando l'operatore ! (NOT logico) #in questo caso ci chiediamo quale numero non è divisibile per 2 o per 3 !(vettoreLunghezza10 %% 2 == 0 | vettoreLunghezza10 %% 3 == 0) #questa è la posizione del numero in questione which(!(vettoreLunghezza10 %% 2 == 0 | vettoreLunghezza10 %% 3 == 0)) #e questo è il numero vettoreLunghezza10[!(vettoreLunghezza10 %% 2 == 0 | vettoreLunghezza10 %% 3 == 0)] #la funzione any controlla se la condizione è verificata su almeno uno degli elementi #del vettore considerato any(!(vettoreLunghezza10 %% 2 == 0 | vettoreLunghezza10 %% 3 == 0)) #mentre la funzione all controlla se la condizione è verificata per tutti gli elementi all(!(vettoreLunghezza10 %% 2 == 0 | vettoreLunghezza10 %% 3 == 0))

#si può ripetere la stessa cosa su un oggetto di tipo matrice #controllo se i numeri contenuti sono divisibile per 2 matrice1 %% 2 == 0 #in questo caso le posizioni degli elementi che soddisfano la condizione #sono restituisti usando un solo indice di puntamento che scorre per colonna which(matrice1 %% 2 == 0) #anche se vado ad estrarre gli elementi che soddisfano la condizione richiesta #passo dalla matrice al vettore matrice1[matrice1 %% 2 == 0]

#lo stesso accade sull'oggetto di tipo array array3d %% 2 == 0 which(array3d %% 2 == 0) array3d[array3d %% 2 == 0]

#vediamo come è possibile accedere ai vari elementi di un oggetto #chiaramente questo permette sia di estrarre gli elementi che di cambiarne il valore

#l'operatore per accedere agli elementi è la [ #è possibile usare un vettore di interi che indica la posizione degli elementi #cui voglio accedere #il vettore può essere di numeri positivi per indicare le posizioni di interesse #o di numeri negativi per escludere particolari posizioni #primo elemento vettoreLunghezza10[1] #primo e terzo elemento vettoreLunghezza10[c(1, 3)] #escludo il primo e il terzo elemento vettoreLunghezza10[c(-1, -3)]

#posso utilizzare anche un vettore di valori logici (TRUE/FALSE): l'operatore [ in questo caso #restituisce solo gli elementi corrispondenti alle posizioni TRUE vettoreLunghezza3 vettoreLunghezza3[c(T,F,T)]

#l'uso dei vettori di valori logici permette di estrarre elementi sfruttando gli 10agina p

scriptIntroduzioneR.R operatori relazionali #l'operatore relazione restituisce un vettore di valori logici (TRUE/FALSE) vettoreLunghezza3 %% 2 == 0 #che può essere passato in input all'operatore [ vettoreLunghezza3[vettoreLunghezza3 %% 2 == 0]

#nel caso il vettore di valori logici passato all'operatore [ sia di lunghezza inferiore al numero di #elementi contenuti nel vettore cui si accede, viene applicata la regola del riciclaggio vettoreLunghezza10 vettoreLunghezza10[c(T)] vettoreLunghezza10[c(F)] vettoreLunghezza10[c(T,F)]

#è possibile sfruttare anche i nomi per accedere agli elementi del vettore #attenzione: nel caso di nomi ripetuti viene restituito solo il primo elemento se si passa la stringa #all'operatore [ vettoreLunghezza10 vettoreLunghezza10["lun"] #si può ovviare al programma lavorando direttamente sull'attributo names names(vettoreLunghezza10) == "lun" which(names(vettoreLunghezza10) == "lun") vettoreLunghezza10[names(vettoreLunghezza10) == "lun"]

#le stesse regole valgono anche per le matrici #se si utilizza un solo indice per il puntamento si sta scorrendo la matrice per colonna matrice1 matrice1[7] matrice1[c(2,7)] #nel caso delle matrici lavorando con un solo indice e con gli operatori relazionali si #ottiene in output un vettore con gli elementi della matrice che soddisfano la/e condizione/i #richiesta matrice1 > 4 matrice1[matrice1 > 4] #questo vale anche nel caso la condizione è verificata per un blocco rettangolare che potrebbe #quindi essere restituito ancora come matrice (matrice1 > 3 & matrice1 <6) | (matrice1 > 8) matrice1[(matrice1 > 3 & matrice1 <6) | (matrice1 > 8)]

#posso usare una sintassi per accedere agli elementi di una matrice che sfrutta due indici: il #primo è l'indice di riga e il secondo è l'indice di colonna #per accedere all'elemento (prima riga, seconda colonna) matrice1[1,2] #per accedere all'intera prima riga matrice1[1,] #per accedere all'intera seconda colonna matrice1[,2] #per accedere a tutta la matrice, in alternativa al nome dell'oggetto, posso quindi usare #NOTA: vedi sotto per una differenza con l'accesso usando il solo nome nel caso di assegnazione matrice1[,]

#anche in questo caso posso usare su ciascuna delle due dimensioni un vettore di posizioni #estraggo la sottomatrice considerando la prima e la terza riga matrice1[c(1,3),] #dalla prima alla terza riga matrice1[1:3,] #nel caso in cui l'estrazione corrisponde ad un vettore l'oggetto in output viene automaticamente #semplificato (si perde la dimensione)

11agina p

scriptIntroduzioneR.R matrice1[1:2,2] class(matrice1[1:2,2]) #da confrontare con l'analogo nel caso di estrazione di una sottomatrice matrice1[1:3,] class(matrice1[1:3,])

#una sintassi analoga permette di accedere agli elementi di un array a più dimensioni, naturalmente #includendo un indice per ciascuna delle dimensioni considerate #elemento sulla prima riga, terza colonna, secondo strato array3d[1,3,2] #estraggo il primo strato array3d[,,1] #anche in questo caso, ove possibile, la struttura viene semplificata class(array3d) class(array3d[,,1]) #estraggo la prima riga e tutte le colonne per ciascuno strato array3d[1,,] #attenzione alla disposizione dell'output: la prima colonna corrisponde alla prima riga del primo strato #e la seconda colonna alla prima riga del secondo strato array3d[1,,1] array3d[1,,2] #discorso analogo vale se lavoro con gli indici di colonna array3d[,2,] array3d[,2,1] array3d[,2,2] #anche per gli array posso usare un vettore di indici per indicare le righe/colonne cui sono interessato #(se gli indici sono positivi) o da escludere (se gli indici sono negativi) #estraggo, per ciascuno strato, gli elementi sulla prima e terza riga (tutte le colonne) array3d[c(1,3),,] #estraggo, per ciascuno strato, gli elementi dalla prima alla terza riga (tutte le colonne) array3d[1:3,,] #in alternativa avrei potuto escludere la quarta riga per ciascuno strato array3d[-4,,] #questa volta escludo la prima e la quarta riga per ciascuno strato array3d[c(-1,-4),,]

#anche per gli array, laddove definiti, posso usare i nomi per puntare agli elementi attributes(array3d) #lavorando con i nomi degli elementi devo usare la sintassi con il singolo indice array3d["x"] array3d[c("b","x")] #posso analogamente lavorare sui nomi delle dimensioni #NOTA: attenzione alla disposizione dell'output (i nomi ci aiutano a capire la "provenienza" #dei vari vettori) array3d["riga1",,] array3d[,"colonna3",] array3d[,,"strato2"] #anche nel caso dei nomi posso usare un vettore di nomi array3d[c("riga1","riga3"),,]

#con i nomi non posso però usare la negazione per escludere l'elemento array3d[-"x"] array3d[-c("riga1","riga2"),,] array3d[c(-"riga1",-"riga2"),,] #la sintassi in questo caso diventa più macchinosa #per escludere l'elemento di nome b array3d[names(array3d)!="b"] #per escludere gli elementi sulla riga di nome riga1 array3d[rownames(array3d)!="riga1"] #per escludere gli elementi sulle righe di nome riga1 e riga3 array3d[rownames(array3d)!="riga1" & rownames(array3d)!="riga3"]

12agina p

scriptIntroduzioneR.R

#sull'array posso usare un vettore di valori logici, facendo attenzione al fatto #che la struttura di output in questo caso viene sempre semplificata #i numeri > 12 si trovano tutti nel secondo strato dell'array e quindi potrebbero #essere restituiti come matrice ma questo non avviene array3d > 12 array3d[array3d > 12]

#sia per i vettori che per le matrici che per gli array posso accedere agli elementi #con la sintassi vista sopra per riassegnare nuovi valori alle posizioni specificate vettoreLunghezza10[c(1, 5)] vettoreLunghezza10[c(1, 5)] <- c(10, 50) vettoreLunghezza10 #anche nel caso dell'assegnazione vale la regola del riciclaggio vettoreLunghezza10[c(1, 5)] <- 0 vettoreLunghezza10 #con lo stesso messaggio di warning visto in precedenza vettoreLunghezza10[1:5] <- 1:3 vettoreLunghezza10

#una cosa abbastanza particolare è il ridimensionamento automatico del vettore in fase #di assegnazione #se provo ad accedere al 15° elemento del vettore ho uno strano ouput vettoreLunghezza10[15] #che forse diventa più chiaro se assegno un valore al quindicesimo elemento (che non esiste) vettoreLunghezza10[15] <- 15 vettoreLunghezza10 #NOTA: il ridimensionamento automatico non funziona nel caso di matrici e array matrice1 matrice1[6,4] matrice1[6,4] <- 10

#per accedere a tutti gli elementi di un vettore/matrice/array3d posso usare sia solo il nome #della variabile che una sintassi con l'operatore [ #ad esempio per la matrice1 posso scrivere: matrice1 matrice1[] matrice1[,] #rispetto all'estrazione di elementi non fa alcuna differenza ma una differenza è riscontrabile #se invece si fa riferimento all'assegnazione di elementi varAppoggio <- matrice1 varAppoggio varAppoggio <- 10 varAppoggio #usando una delle sintassi con l'operatore [ l'assegnazione avviene invece preservando la struttura #dell'oggetto varAppoggio <- matrice1 varAppoggio[] <- 100 varAppoggio

#creazione e stampa di una lista lista <- list(vettore=1:10, matrice1=matrix(1:12, 4, 3), testo=letters[1:5]) lista #creazione e stampa di un dataframe df <- data.frame(a=letters[1:10], b=1:10, c=10:1) df

#quanti elementi ci sono nella lista? length(lista) #e quanti nel dataframe? length(df)

13agina p

scriptIntroduzioneR.R

#il dataframe è un tipo particolare di lista is.list(df) is.data.frame(df) as.list(df)

#sia la lista che il dataframe sono contenitori per oggetti di tipo diverso is.atomic(lista) is.atomic(df)

#per puntare agli elementi della lista ci sono diverse opzioni #accesso attraverso l'indice dell'elemento usando l'operatore di estrazione [[ #con l'operatore [[ si accede direttamente all'elemento della lista (semplificando la struttura di output) lista[[1]] is.atomic(lista[[1]]) #si può usare anche l'operatore di estrazione [ lista[1] #in questo caso viene restituita una sottolista con un solo elemento is.atomic(lista[1]) is.list(lista[1]) #l'operatore [ permette di accedere a più elementi della lista lista[c(1,3)] #cosa non possibile usando l'operatore [[ #se si prova il comando lista[[c(1,3)]] #è come se stessi scrivendo lista[[1]][3]

#stesso problema si ha se si cerca di usare la [[ con un indice negativo lista[[-2]] #sintassi consentita con la [ per escludere uno o più elementi lista[-2] lista[c(-1,-3)] #è possibile sfruttare i nomi degli elementi nel caso di una lista con nomi names(lista) #in questo caso è possibile usare l'operatore $ tra nome della lista e nome dell'elemento che si vuole estrarre lista$vettore #in alternativa è possibile usare la [ o le [[ con le differenze viste nel caso degli indici lista[["vettore"]] is.atomic(lista[["vettore"]]) lista["vettore"] is.atomic(lista["vettore"]) #per estrarre due o più elementi è però necessario usare la singola [ lista[c("vettore", "testo")] #così come con gli indici non è possibile usare le [[ lista[[c("vettore", "testo")]]

#il dataframe è una particolare lista: valgono quindi tutte le cose viste per la lista df[[1]] class(df[[1]]) df[1] class(df[[2]]) df$a df[c("a","c")] df[-2]

#in più per i dataframe è possibile usare la singola [ anche con la sintassi di puntamento #vista per le matrici #ecco alcuni esempi: #per estrarre la prima colonna df[,1] #per estrarre la prima e la terza colonna df[,c(1,3)] #per escludere la seconda colonna

14agina p

scriptIntroduzioneR.R df[,-2] #per estrarre la prima riga df[2,] #per escludere la prima riga df[-1,] #per accedere all'elemento sulla riga 5 - colonna 2 df[5, 2] #per estarre un blocco: righe da 5 a 10 + colonna 1 e 2 df[5:10, c(1,3)]

#è possibile utilizzare in combinazione la sintassi per accedere agli elementi della lista #e poi ai particolari elementi #estrae la matrice alla seconda posizione della lista lista[[2]] #estrae la seconda e terza colonna della matrice che si trova alla seconda posizione della lista lista[[2]][,c(2,3)]

#NA è utilizzato per indicare i valori mancanti (missing values) #la gestione dei missing richiede particolare attenzione #creiamo un vettore con missing (vettoreMV <- c(1:3, NA, 5:10, NA)) #quando si lavora con i missing questi rimangono tali qualunque operazione venga effettuata su di essi vettoreMV + 5 vettoreMV < 5

#mentre è possibile usare l'operatore di confronto == per sapere se esiste un valore uguale a 5 vettoreMV == 5 #la stessa cosa non vale per il controllo dei missing vettoreMV == NA #in questo caso esiste una funzione ad hoc is.na(vettoreMV)

#per estrarre gli elementi non mancanti è quindi possibile usare l'operatore logico NOT (!) e la #funzione is.na !is.na(vettoreMV) vettoreMV[!is.na(vettoreMV)] #attenzione alla presenza dei missing nel caso di operazioni di sintesi sum(vettoreMV) mean(vettoreMV) #è possibile calcolare la funzione di sintesi solo sugli elementi validi sum(vettoreMV[!is.na(vettoreMV)]) #molte funzioni di sintesi hanno però un flag per escludere automaticamente i missing sum(vettoreMV, na.rm=TRUE)

#in alternativa è possibile usare la funzione na.omit per escludere i missing na.omit(vettoreMV) #attenzione: se si vuole escludere gli elementi si deve riassegnare l'output di na.omit vettoreMV vettoreMV <- na.omit(vettoreMV) vettoreMV

#na.omit (insieme alla funzioni complete.cases) è molto utile nel caso di dataframe #preparo un data.frame con NA sparsi vettoreMV <- c(1:3, NA, 5:10, NA) df <- data.frame(var1=vettoreMV, var2 = c(NA, 2:10, NA), var3=c(1, NA, 10:2)) df #posso controllare il numero di missing value per colonna sum(is.na(df$var1)) sum(is.na(df$var2)) sum(is.na(df$var3)) #il numero di missing per riga

15agina p

scriptIntroduzioneR.R is.na(df$var1) + is.na(df$var2) + is.na(df$var3) #o usare la funzione apply che permette di applicare una funzione su una delle due dimensioni #di una tabella (1 per le righe e 2 per le colonne) #NOTA: nel caso di array3d se si vuole per strati si usa il valore 3 per il secondo argomento # e così via nel caso di array a più dimensioni #si può definire una funzione e poi passarla alla funzione apply contaNA <- function(x){sum(is.na(x))} #se passo alla funzione l'intero dataframe conta il numero complessivo di missing contaNA(df) #se voglio sapere quanti NA ci sono per colonna apply(df, 2, contaNA) #o per riga apply(df, 1, contaNA) #o definire una funzione "on the fly" come terzo argomento alla funzione #in questo secondo caso la funzione non è disponibile sul workspace per successivi utilizzi apply(df, 2, function(x)sum(is.na(x)))

#il dataframe è una particolare lista per cui è possibile usare sia la funzione lapply che la funzione sapply lapply(df, function(x)sum(is.na(x))) #restituisce una lista sapply(df, function(x)sum(is.na(x))) #semplifica la struttura di output laddove possibile #cambiando il default del flag simplify ottengo una lista anche con la funzione sapply sapply(df, function(x)sum(is.na(x)), simplify=FALSE)

#per estrarre solo le righe senza missing posso quindi procedere usando due alternativa df[is.na(df$var1) + is.na(df$var2) == 0 + is.na(df$var3),] #alternativa 1 df[apply(df,1,function(x)sum(is.na(x))) == 0,] #alternativa 2

#la funzione complete.cases restituisce per ogni unità un FALSE se ci sono missing complete.cases(df) #posso quindi estrarre le sole unità senza missing usando l'output di complete.cases #per indicizzare il dataframe df[complete.cases(df),] #la funzione na.omit scarta automaticamente i valori mancanti na.omit(df)

#altro valore particolare: il non-numero 0/0 ?NaN #e la funzione per controllarne la presenza is.nan(0/0) #Inf è la parola riservata per infinito is.finite(10) is.finite(Inf) is.infinite(Inf)

#un vettore di stringhe quando inserito in un dataframe viene automaticamente convertito in #una variabile di tipo factor, utilizzata in R per la gestione di variabili qualitative #la funzione sample permette di estrarre un campione casuale sample(letters, 10) #in questo caso estraggo 10 lettere dal vettore predefinito letters sample(letters, 100) #se provo ad estrarne 100 ottengo un messaggio di errore length(letters) #errore comprensibile se controllo la lunghezza del vettore letters

#per effettuare un campionamento con ripetizione posso impostare il flag replace a TRUE sample(letters, 10, replace=T)

16agina p

scriptIntroduzioneR.R sample(letters, 100, replace=T)

#nel caso di esperimenti con numeri casuali per assicurarsi la riproducibilità dei risultati #si può fissare il seme della generazione dei numeri casuali usando la funzione set.seed set.seed(17) #variabile con 100 lettere estratte casualmente con ripetizione dal vettore letters var1 <- sample(letters, 100, replace=T) #mi accorgo che si tratta di un oggetto character controllando la modalità dell'oggetto mode(var1) #la funzione factor permette di creare una variabile di tipo factor fVar1 <- factor(var1) #la funzione di stampa per gli oggetti di tipo factor produce una diversa formattazione del #contenuto dell'oggetto fVar1 print(fVar1) #i fattori sono in realtà internamente codificati come numeri c(class(fVar1), mode(fVar1), typeof(fVar1))

#è possibile estrarre i differenti livelli di un fattore usando la funzione levels levels(fVar1) #e sapere quanti sono calcolando la lunghezza dell'output restituito da levels length(levels(fVar1)) #o la funzione nlevels che restituisce direttamente il numero di livelli di una variabile fattore nlevels(fVar1)

#i livelli di un oggetto factor sono ordinati per default in senso crescente #(se si tratta di caratteri in ordine alfabetico crescente) set.seed(17) factor(sample(1:3, 10, replace=TRUE)) #la funzione factor ha un argomento levels che permette di impostare i livelli del fattore set.seed(17) factor(sample(1:3, 10, replace=TRUE), levels=c(1,2,3))

#impostando i livello con l'argomento levels l'ordine viene usato anche per la stampa del fattore set.seed(17) factor(sample(1:3, 10, replace=TRUE), levels=c(2, 3, 1)) #così come nelle tabelle e nei grafici set.seed(17) table(factor(sample(1:3, 10, replace=TRUE), levels=c(2, 3, 1)))

#è possibile impostare anche le etichette del fattore usando l'argomento labels set.seed(17) factor(sample(1:3, 10, replace=TRUE), labels=c("uno","due","tre"))

#i livelli sono associati alle etichette set.seed(17) factor(sample(1:3, 10, replace=TRUE), levels=c(2,3, 1), labels=c("due","tre","uno"))

#è possibile creare un fattore ordinato sia impostando il flag ordered a TRUE set.seed(17) factor(sample(1:3, 10, replace=TRUE), levels=c(1,2,3), ordered=T) #che usando la funzione ordered set.seed(17) ordered(sample(1:3, 10, replace=TRUE), levels=c(1,2,3)) #l'oggetto ottenuto in entrambi i casi è un fattore ordinato class(factor(sample(1:3, 10, replace=TRUE), levels=c(1,2,3), ordered=T)) class(ordered(sample(1:3, 10, replace=TRUE), levels=c(1,2,3)))

#anche per i fattori ordinati è possibile usare sia l'argomento levels che 17agina p

scriptIntroduzioneR.R l'argomento labels set.seed(17) factor(sample(1:3, 10, replace=TRUE), levels=c(1, 2, 3), labels=c("a","b","c"), ordered=TRUE)

#se nell'oggetto non sono presenti dei livelli definiti èerò nell'argomento levels #l'informazione circa il livello non presente non viene persa set.seed(17) factor(sample(1:3, 20, replace=TRUE), levels=1:4) #come si può notare anche dalla tabella di frequenza associata set.seed(17) table(factor(sample(1:3, 105, replace=TRUE), levels=1:4))

#per escludere fattori non utilizzati da una variabile factor si può passare il fattore #alla funzione factor ed utilizzare l'argomento exclude=NULL set.seed(17) fUnusedLevel <- factor(sample(1:3, 105, replace=TRUE), levels=1:4) factor(fUnusedLevel, exclude=NULL) table(factor(fUnusedLevel, exclude=NULL))

#un problema analogo si ha nel caso di estrazioni di un sottoinsieme di osservazioni a partire #da una variabile di tipo factor: anche in questo caso i livelli definiti per la variabile di #tipo factor rimangono invariati #creo una variabile di tipo factor contenente tre valori: a, b e c varCompleta <- factor(c(rep("a",2), rep("b", 5), rep("c", 3))) varCompleta #estraggo dalla variabile completa un sottoinsieme (varRidotta <- varCompleta[varCompleta != "a"]) #il livello a è ancora presente nonostante non sia presente nei dati levels(varRidotta) table(varRidotta) #se provo a forzare i livelli della variabile ai soli fattori presenti #ottengo un messaggio di errore levels(varRidotta) <- c("b","c")

#nell'operazione di estrazione del sottoinsieme dal fattore posso utilizzare #l'argomento drop=TRUE per eliminare dal fattore risultante eventuali livelli #non utilizzati set.seed(17) (varRidotta <- varCompleta[varCompleta != "a", drop=TRUE]) levels(varRidotta) table(varRidotta)

#in alcuni casi può essere utile cambiare il livello di riferimento #in una variabile di tipo fattore: il livello di riferimento è il #primo livello della variabile e assume un ruolo particolare nei modelli #Se si considera ad esempio un modello di regressione lineare, inserendo #una variabile dummy nel modello di regressione automaticamente il sistema #inserisce un numero di dummy pari al nr. di modalità - 1 per evitare il #problema di perfetta collinearità #il livello escluso (rispetto al quale vanno interpretati i coefficienti #di tutti gli altri livelli) è il primo (variabile <- factor(sample(letters[1:5], 20, replace=TRUE))) #la funzione relevel mi permette di cambiare il livello di riferimento #di un fattore variabile <- relevel(variabile, "c") variabile

#creo due variabili fattore che hanno un livello in comune e un livello #non in comune fattore1 <- factor(c("a", "b", "b", "a", "b")) fattore2 <- factor(c("b", "c", "b", "c","c")) #se provo a combinare le due variabili in realtà il vattore che viene #restituito è la combinazione dei valori numerici associati a ciascuna variabile #come posso verificare se semplifico gli oggetti usando la funzione unclass

18agina p

scriptIntroduzioneR.R c(fattore1, fattore2) unclass(fattore1) unclass(fattore2) c(unclass(fattore1), unclass(fattore2))

#in questo caso posso puntare lavorare sui livelli e non sulla loro rappresentazione #numerica usando la variabile fattore come vettore per l'operatore [ sul vettore dei #livelli levels(fattore1)[fattore1] #o in alternativa forzando una conversione al tipo character as.character(fattore1) #per combinare i due fattori posso quindi usare una sintassi analoga anche per l'altro fattore c(levels(fattore1)[fattore1], levels(fattore2)[fattore2]) #per avere un variabile fattore posso passare il valore dell'ultima espressione alla funzione factor fattore1e2 <- factor(c(levels(fattore1)[fattore1], levels(fattore2)[fattore2])) fattore1e2

#NOTA SULLA FUNZIONE SAMPLE #la funzione sample effettua un campionamento casuale semplice attribuendo per default a ciascun #valore del vettore da cui campionare la stessa probabilità di appartenere al campione estratto table(sample(1:4, 1000, replace=TRUE)) #è possibile specificare un vettore di probabilità da utilizzare per il processo di campionamento #usando l'argomento prob table(sample(1:4, 1000, replace=TRUE, prob=c(0.1, 0.7, 0.1, 0.1)))

#la funzione runif permette di generare numeri da una distribuzione uniforme continua #dall'help è possibile vedere i vari argomenti e il loro significato #NOTA: per ogni modello di variabile casuale esistono quattro tipo di funzione con # nome prefissoNomeModello, dove il nomeModello mi permette di scegliere quale # generatore di numeri casuali utilizzare e il prefisso è, per tutti i modelli # una tra le seguenti quattro lettere # rNomeModello (es. runif): il prefisso r indica che la funzione permette di generare numeri # casuali dal modello in question # dNomeModello (es. dunif): il prefisso d indica che la funzione permette di calcolare # il valore della distribuzione di probabilità, nel caso di una # variabile discreta, o della funzione di densità nel caso di una # variabile continua # dNomeModello (es. punif): il prefisso p indica che la funzione permette di calcolare la probabilità # in un punto o un intervallo, a seconda della tipologia di variabile (discreta # o continua) # qNomeModello (es. qunif): il prefisso q indica che la funzione permette di calcolare il quantile # della particolare variabile casuale ?runif #genero un campione di 100 osservazione da un modello ~ U(0, 1) set.seed(1); varUniforme <- runif(100) #la funzione cut permette di ricodificare una variabile quantitativa in classi ?cut #l'argomento breaks della funzione cut permette di fissare il numero di classi #della categorizzazione: divido in 3 classi cut(varUniforme, 3) #posso cambiare il numero di cifre decimali usati per le etichette delle

19agina p

scriptIntroduzioneR.R modalità cut(varUniforme, 3, dig.lab=1) #la variabile generata dalla funzione cut è una variabile di tipo fattore c(mode(cut(varUniforme, 3)), class(cut(varUniforme, 3))) #per default le etichette sono associate agli intervalli usati per la categorizzazione table(cut(varUniforme, 3, dig.lab=1)) #l'argomento labels della funzione cut permette di impostare le etichette da utilizzare #per la variabile factor table(cut(varUniforme, 3, dig.lab=1, labels=c("basso","medio","alto"))) #invece del numero di classi da utilizzare, l'argomento break può essere utilizzato #per specificare gli estremi delle classi #NOTA: gli estremi devono comprendere sia l'estremo inferiore della prima classe # che l'estremo superiore dell'ultima classe table(cut(varUniforme, breaks=c(0, 0.2, 0.8,1))) #se ci sono valori a sinistra del primo valore dell'argomento breaks questi saranno #sostituiti da NA nella categorizzazione cut(varUniforme, breaks=c(0.2, 0.8, 1)) #lo stesso accade nel caso ci siano dati a destra dell'ultimo valore dell'argomento breaks cut(varUniforme, breaks=c(0, 0.2, 0.8)) #l'argomento include.lowest permette di utilizzare la prima classe chiusa a sinistra cut(varUniforme, breaks=c(0, 0.2, 0.8, 1), include.lowest=T) #posso decidere se le classi sono aperte a destra o a sinistra usando il flag right cut(varUniforme, breaks=c(0, 0.2, 0.8, 1), right=T) cut(varUniforme, breaks=c(0, 0.2, 0.8, 1), right=F)

#esistono diverse funzioni in R per la gestione e manipolazione delle date #la funzione Sys.Date permette di ottenere la data di sistema Sys.Date() #la funzione Sys.Date ci permette di fare conoscenza con un nuovo tipo di oggetto: #l'oggetto Date oggi <- Sys.Date() #si tratta di un oggetto di classe Date ma con una codifica interna numerica c(class(oggi), mode(oggi)) #la conversione in tipo numerico avviene in base al calendario giuliano as.numeric(oggi) #esistono diverse funzioni per la manipolazione di oggetti di classe Date months(oggi) #estrae il mese dalla data in formato stringa weekdays(oggi) #estrae il giorno della settimana in formato esteso weekdays(oggi, abbrev=T) #estrae il giorno della settimana in formato abbreviato quarters(oggi) #estrae il quarto corrispondente all'oggetto Date

#la funzione as.Date permette di convertire un oggetto in formato Date ?as.Date #se si passa un oggetto di tipo stringa si può specificare il formato dataProva <- as.Date("09/01/2009") #attenzione al formato dataProva months(dataProva) dataProva <- as.Date("01/09/2009") dataProva months(dataProva) #è però possibile specificare un formato utilizzando l'argomento format #alcuni esempi di utilizzo dell'argomento format per specificare il formato as.Date("09/01/2009", "%m/%d/%Y") as.Date("09/01/09", "%m/%d/%y") as.Date("09012009", "%m%d%Y") as.Date("090109", "%m%d%y") as.Date("01_09_2009", "%d_%m_%Y") as.Date("2009-09-01") as.Date("01-09-2009")

#sugli oggetti di tipo Date è possibile effettuare anche semplice operazioni 20agina p

scriptIntroduzioneR.R algebriche compleanno <- as.Date("1970-08-28") c(oggi, compleanno) oggi - compleanno #la funzione difftime permette di ottenere lo stesso risultato ma di specificare l'unità #di misura dell'output difftime(oggi, compleanno) #per default la differenza è espressa in giorni difftime(oggi, compleanno, units="days") #si può ottenere lo stesso risultato specificando days per l'argomento units difftime(oggi, compleanno, units="auto") #valore di default per l'argomento units difftime(oggi, compleanno, units="weeks") #differenza in settimane difftime(oggi, compleanno, units="hours") #differenza in ore difftime(oggi, compleanno, units="mins") #differenza in minuti difftime(oggi, compleanno, units="secs") #differenza in secondi

#NOTA: la funzione seq, utile per generare sequenze lineare, può essere utilizzata anche per le date

#l'operatore : è una scorciatoia per la funzione seq in cui il passo è unitario #esempio di sequenza crescente 1:10 seq(from=1, to=10, by=1) #esempio di sequenza decresecente 10:1 seq(from=10, to=1, by=-1) #la funzione seq permette però di ottenere sequenze con regole diverse impostando opportunamente i valori #degli argomenti ?seq #quando non si specifica l'argomento by e si utilizzano due argomenti senza specificarne il nome #la funzione seq utilizza un valore di default per l'argomento by (che viene impostato ad 1) #e utilizza il primo valore come punto iniziale della sequenza e il secondo valore come punto #di arresto della sequenza seq(1, 10) #si può impostare un valore differente per l'argomento by seq(from=1, to=10, by=2) seq(from=10, to=1, by=-2) #è possibile specificare anche punto di partenza, passo e lunghezza della sequenza #e lasciare determinare alla funzione seq il punto di arresto seq(from=1, by=3, length.out=10) #la generazione di sequenze può essere utile per creare vettori di etichette vettore <- 1:10 #in particolare sfruttando la funzione paste paste("et",seq(1, along.with=vettore), sep="") #altre due varianti della funzione seq seq_along(vettore) #genera una sequenza di lunghezza uguale a quella specificata dall'oggetto in input seq_len(12) #genera una sequenza con passo unitario di lunghezza specificata in input

#la funzione seq può essere utilizzata anche su oggetti di tipo Date per generare sequenze oggi seq(oggi, by="days", length=5) #posso impostare un passo giornaliero seq(oggi, by="weeks", length=5) #settimanale seq(oggi, by="year", length=5) #annuale seq(oggi, by="5 days", length=5) #ma anche un numero diverso di giorni, settimane, anni

#la funzione di setRepositories apre una finestra popup in cui è possibile specificare il tipo di #repositories usato per il download di librerie setRepositories()

21agina p

scriptIntroduzioneR.R #posso scaricare l'elenco dei pacchetti disponibili usando la funzione available.packages oggettoPacchetti <- available.packages() #l'elenco viene specificato in formato matrice class(oggettoPacchetti) #informazioni disponibili nella matrice colnames(oggettoPacchetti) #numero di pacchetti disponibili sul repository dim(oggettoPacchetti) #diamo un'occhiata al contenuto della matrice head(oggettoPacchetti) #NOTA: la funzione head permette di guardare i primi elementi di una matrice ?head #il secondo argomento della funzione head permette di specificare il numero di elementi in testa #da visualizzare head(oggettoPacchetti, 2) #primi due righe della matrice #usando un numero negativo posso escludere le righe dalla coda della matrice head(oggettoPacchetti, -2000) #la funzione tail ha gli stessi obiettivi ma lavorando sulla coda della matrice tail(oggettoPacchetti, 2) #ultime due righe tail(oggettoPacchetti, -2000) #escludo le prime 2000 e visualizzo le restanti

#la funzione installed.packages permette di ottenere l'elenco dei pacchetti installati pacInstall <- installed.packages() head(pacInstall, 2) #prime righe dell'elenco nrow(pacInstall) #numero di righe -> numero di pacchetti installati #la prima colonna contiene il nome del pacchetto pacInstall[,1] #i nomi dei pacchetti sono utilizzati anche come nomi di riga della matrice restituita #dalla funzione installed.packages rownames(pacInstall) #altre funzioni utili per la gestione dei pacchetti ?new.packages #per avere un elenco dei nuovi pacchetti disponibili ?old.packages #per avere un elenco dei pacchetti installati per cui esiste sul repository #una nuova versione ?remove.packages #per disinstallare un pacchetto #per installare un pacchetto si può usare la funzione install.packages #l'argomento dep fissato a TRUE indica a R di installare anche altri #eventuali pacchetti aggiuntivi richiesti dal pacchetto che si sta #installando

#il pacchetto car contiene una serie di funzioni e di dataset che accompagnano il libro #Companion to Applied Regression di John Fox install.packages("car", dep=T) #il pacchetto Hmisc accompagna il libro Regression Modelling Strategies di Frank Harrel install.packages("Hmisc", dep=T) #il pacchetto gdata contiene una serie di funzioni per la lettura di dati in formato differente #di particolare utilità risulta la funzione read.xls che permette di leggere file in formato #MS-Excel (il pacchetto richiede che sul PC sia installato un interprete PERL) install.packages("gdata", dep=T) #il pacchetto foreign contiene una serie di funzioni che permette di importare dati dai #principali pacchetti statistici (Sas, SPSS, Stata, Systat, ecc.) #una funzione read.formato è disponibile per ciascuno dei formati supportati: ad esempio #read.sav permette di leggere file in formato SPSS, read.dta file in formato Stata, ecc. install.packages("foreign", dep=T) #per mantenere i pacchetti sempre aggiornati rispetto alle versioni presenti sui repository #si consiglia di "lanciare" la funzione update.packages di tanto in tanto

22agina p

scriptIntroduzioneR.R update.packages()

23agina p

Docsity non è ottimizzato per il browser che stai usando. Per una miglior fruizione usa Internet Explorer 9+, Chrome, Firefox o Safari! Scarica Google Chrome