[ Slajdovi ] [ R Code ]
Opšti pregled
Jedna od glavnih atrakcija korišćenja R (http://cran.at.r-project.org)
okruženja je lakoća sa kojom korisnici mogu da napišu svoje sopstvene programe i prilagođene funkcije. Sintaksa R programiranja je izuzetno laka za učenje, čak i za korisnike koji nemaju prethodnog iskustva u programiranju. Jednom kada se osnovne strukture programiranja u R razumeju, korisnici mogu da koriste R jezik kao moćno okruženje za izvršavanje složene prilagođene analize skoro bilo koje vrste podataka.
Format ovog prirucnika
U ovom priručniku su date sve komande u kodu kutijama, gde je kod R štampan u crnoj boji, komentar teksta u plavoj
i output generisan u R-u u zelenoj. Svi komentari ili objašnjenja počinju sa standardnim znakom '#'
kako se one ne bih svatile kao komande u R-u. Na ovaj način sadržaj kutije koda(code boxes) mogu biti zalepljeni sa svojim komentarima teksta u R konzoli da bi se lakše mogla proceniti njihova korisnost. Povremeno, neke komande se štampaju na jednoj liniji, a razdvojene su sa tačka-zarez ';'.
Komande koje počinju sa znakom '$'
treba da se izvrše iz Uniksa ili Linuk Shell. Korisnici Windows-a mogu jednostavno da ignorišu taj kod.
Osnove R-a
Osnove R i BioConductor
uputstva pružaju opšti uvid korišćenja R sredine i njenu osnovnu komandnu sintaksu.
Editori R koda
Nekoliko odličnih editora koda su na raspolaganju da obezbede funkcije kao što su podvlačenje sintakse R koda,auto izjednačavanje koda i komande koje šalju kod ili funkcije u R konzolu.
Programiranje u R-u koristeći Vim ili Emacs Programiranje u R-u koristeći RStudio
Integrisanje R-a pomoću Vim i Tmux
Korisnici koji su zainteresovani u integrisanje R-a pomoću Vim-a i Tmux-a bi mogli da pregledaju
Vim-R-Tmux configuration page (stranica za konfiguraciju).
Pronaći pomoć
Referentna lista R programiranja
- R Programming for Bioinformatics, od Robert Gentleman
- S Programming, od W. N. Venables i B. D. Ripley
- Programming with Data, od John M. Chambers
- R Help & R Coding Conventions, Henrik Bengtsson, Lund University
- Programming in R (Vincent Zoonekynd)
- Peter's R Programming Pages, University of Warwick
- Rtips, Paul Johnsson, University of Kansas
- R for Programmers, Norm Matloff, UC Davis
- High-Performance R, Dirk Eddelbuettel uputstvo prezentovano na useR-2008
- C/C++ level programming for R, Gopi Goswami
Kontrolne strukture
Uslovi izvršavanja
Poredjenja računskih radnji
- equal: ==
- not equal: !=
- greater/less than: > <
- greater/less than or equal: >= <=
Logične računske radnje
IF izveštaji
IF izveštaji rade na dužini jednog logičkog vektora.
Sintaksa
if(cond1=true) { cmd1 } else { cmd2 }
Primer
if(1==0) {
print(1)
} else {
print(2)
}
[1] 2
Pokušajte da izbegavate nove linije izmedju ' } else'.
Ifelse izveštaji
Ifelse izveštaji radi na vektorima promenljivih dužina.
Sintaksa
ifelse(test, true_value, false_value)
Primer
x <- 1:10 # Creates sample data
ifelse(x<5 | x>8, x, 0)
[1] 1 2 3 4 0 0 0 0 9 10
Petlje
Najčešće korišćene petlje u R-u su for, while i apply petlje.Manje korišćena je repeat petlja.Funkcija break se koristi za izlazak iz petlje,funkcija next zaustavlja obradu tekuće ponavljanje petlje i unapređuje indeks petlju.
For Loop
For loops are controlled by a looping vector. In every iteration of the loop one value in the looping vector is assigned to a variable that can be used in the statements of the body of the loop. Usually, the number of loop iterations is defined by the number of values stored in the looping vector and they are processed in the same order as they are stored in the looping vector.
Sintaksa
for(variable in sequence) {
statements
}
Primer
mydf <- iris
myve <- NULL # Creates empty storage container
for(i in seq(along=mydf[,1])) {
myve <- c(myve, mean(as.numeric(mydf[i, 1:3]))) # Note: inject approach is much faster than append with 'c'. See below for details.
}
myve
[1] 3.333333 3.100000 3.066667 3.066667 3.333333 3.666667 3.133333 3.300000
[9] 2.900000 3.166667 3.533333 3.266667 3.066667 2.800000 3.666667 3.866667
Primer: uslov*
x <- 1:10
z <- NULL
for(i in seq(along=x)) {
if(x[i] < 5) {
z <- c(z, x[i] - 1)
} else {
z <- c(z, x[i] / x[i])
}
}
z
[1] 0 1 2 3 1 1 1 1 1 1
Primer: Zaustavljanje na stanju i izbacivanje Error poruke
x <- 1:10
z <- NULL
for(i in seq(along=x)) {
if (x[i]<5) {
z <- c(z,x[i]-1)
} else {
stop("values need to be <5")
}
}
Error: values need to be <5
z
[1] 0 1 2 3
While petlja
Slična je for petlji, ali ponavljanje se kontroliše uslovnom naredbom.
Sintaksa
while(condition) statements
Primer
z <- 0
while(z < 5) {
z <- z + 2
print(z)
}
[1] 2
[1] 4
[1] 6
Familija Apply petlji
Za dvo-dimenzionalne data setove: apply
Sintaksa
apply(X, MARGIN, FUN, ARGs)
X: tabela,matrica ili podatak; MARGINA: 1 za redove, 2 za kolone,
c(1,2) za oba slučaja; FUN: za dve ili više funkcija; ARGs: mogući argument funkcije
Primer
## Primer for applying predefined mean function
apply(iris[,1:3], 1, mean)
[1] 3.333333 3.100000 3.066667 3.066667 3.333333 3.666667 3.133333 3.300000
...
## With custom function
x <- 1:10
test <- function(x) { # Defines some custom function
x-1
} else {
x / x
}
}
apply(as.matrix(x), 1, test) # Returns same result as previous for loop*
[1] 0 1 2 3 1 1 1 1 1 1
## Same as above but with a single line of code
apply(as.matrix(x), 1, function(x) { if (x<5) { x-1 } else { x/x } })
[1] 0 1 2 3 1 1 1 1 1 1
For Ragged Arrays: tapply
Applies a function to array categories of variable lengths (ragged array). Grouping is defined by factor.
Sintaksa
tapply(vector, factor, FUN)
Primer
## Computes mean values of vector agregates defined by factor
tapply(as.vector(iris[,i]), factor(iris[,5]), mean)
setosa versicolor virginica
0.246 1.326 2.026
## The aggregate function provides related utilities
aggregate(iris[,1:4], list(iris$Species), mean)
Group.1 Sepal.Length Sepal.Width Petal.Length Petal.Width
1 setosa 5.006 3.428 1.462 0.246
2 versicolor 5.936 2.770 4.260 1.326
3 virginica 6.588 2.974 5.552 2.026
Za vektore i liste: lapply i sapply
Obe primenjuju funkcije na vektor ili listu objekata. Funkcija lapply
vraća listu, dok sapply pokušava da povrati prost objektni podatak, kao što su vektor ili matrica a ne cela lista.
Sintaksa
lapply(X, FUN)
sapply(X, FUN)
Primer
## Creates a sample list
mylist <- as.list(iris[1:3,1:3])
mylist
$Sepal.Length
[1] 5.1 4.9 4.7
$Sepal.Width
[1] 3.5 3.0 3.2
$Petal.Length
[1] 1.4 1.4 1.3
## Compute sum of each list component and return result as list
lapply(mylist, sum)
$Sepal.Length
[1] 14.7
$Sepal.Width
[1] 9.7
$Petal.Length
[1] 4.1
## Compute sum of each list component and return result as vector
Sepal.Length Sepal.Width Petal.Length
14.7 9.7 4.1
Druge petlje
Repeat petlja
Sintaksa
repeat statement
Petlja se ponavlja sve dok ne dodje do navedene tačke na kojoj se zaustavlja.Ovo znači da treba da se u njoj nadje druga naradba koja testira da li treba da se izadje ili ne iz petlje.
Primer
z <- 0
repeat {
z <- z + 1
print(z)
if(z > 100) break()
}
Poboljšavanje brzine izvršenja petlji
Rad na veoma velikim skupovima može usporiti rad R-a.Ovo ograničenje se može prevazići eliminisanje određenih operacija u petlje ili izbegavanjem petlje koje imaju veliki broj podataka ili objekata.Ovo poslednje se može postići vršeći uglavnom vektor-na-vektor ili matrica-na-matricu proračunima koje se pokreću često preko 100 puta brže nego što je odgovarajuća
for() ili apply()
petlja u R-u.Za tu namenu, mogu da iskoriste funkcije koje su namenjene brzom radu u R-u kao što su (npr.: rowSums, rowMeans, table, tabulate)
ili pojedinac može napraviti svoju funkciju koja će izbeći prevelike R petlje koristeći petlje bazirane na vektorima ili matricama.Alternativno, može se pisati programe koji će obavljati sve vreme proračune na C-nivou.
(1) Uporedjivanje brzine for pridodavanjem nasuprot ubacivanjem koraka:
myMA <- matrix(rnorm(1000000), 100000, 10, dimnames=list(1:100000, paste("C", 1:10, sep="")))
results <- NULL
system.time(for(i in seq(along=myMA[,1])) results <- c(results, mean(myMA[i,])))
user system elapsed
39.156 6.369 45.559
results <- numeric(length(myMA[,1]))
system.time(for(i in seq(along=myMA[,1])) results[i] <- mean(myMA[i,]))
user system elapsed
1.550 0.005 1.556
pristup ubacivanja je 20/50 puta brži nego pridodavanje
(2) Uporedjivanje brzine apply petlje naspram rowMeans
za izvršavanje značenja pojedinačnog reda u velikoj matrici:
system.time(myMAmean <- apply(myMA, 1, mean))
user system elapsed
1.452 0.005 1.456
system.time(myMAmean <- rowMeans(myMA))
user system elapsed
0.005 0.001 0.006
rowMeans pristup je 200 puta brži od apply petlje.
(3) Uporedjivanje brzine apply petlje naspram vektorsog pristupa izvršavanju standardne devijacije pojedinačnog reda:
system.time(myMAsd <- apply(myMA, 1, sd))
user system elapsed
3.707 0.014 3.721
myMAsd[1:4]
1 2 3 4
0.8505795 1.3419460 1.3768646 1.3005428
system.time(myMAsd <- sqrt((rowSums((myMA-rowMeans(myMA))^2)) / (length(myMA[1,])-1)))
user system elapsed
0.020 0.009 0.028
myMAsd[1:4]
1 2 3 4
0.8505795 1.3419460 1.3768646 1.3005428
Pristup baziran na vektorima je 200 puta brži od apply petlje.
(4) Primer za izračunavanje znači za bilo koji prilagođeni izbor kolona, bez ugrožavanja performansi brzine:
## In the following the colums are named according to their selection in myList
myList <- tapply(colnames(myMA), c(1,1,1,2,2,2,3,3,4,4), list)
myMAmean <- sapply(myList, function(x) rowMeans(myMA[,x]))
colnames(myMAmean) <- sapply(myList, paste, collapse="_")
myMAmean[1:4,]
C1_C2_C3 C4_C5_C6 C7_C8 C9_C10
1 0.0676799 -0.2860392 0.09651984 -0.7898946
2 -0.6120203 -0.7185961 0.91621371 1.1778427
3 0.2960446 -0.2454476 -1.18768621 0.9019590
4 0.9733695 -0.6242547 0.95078869 -0.7245792
## Alternative to achieve the same result with similar performance, but in a much less elegant way
myselect <- c(1,1,1,2,2,2,3,3,4,4) # The colums are named according to the selection stored in myselect
myList <- tapply(seq(along=myMA[1,]), myselect, function(x) paste("myMA[ ,", x, "]", sep=""))
myList <- sapply(myList, function(x) paste("(", paste(x, collapse=" + "),")/", length(x)))
myMAmean <- sapply(myList, function(x) eval(parse(text=x)))
colnames(myMAmean) <- tapply(colnames(myMA), myselect, paste, collapse="_")
myMAmean[1:4,]
C1_C2_C3 C4_C5_C6 C7_C8 C9_C10
1 0.0676799 -0.2860392 0.09651984 -0.7898946
2 -0.6120203 -0.7185961 0.91621371 1.1778427
3 0.2960446 -0.2454476 -1.18768621 0.9019590
4 0.9733695 -0.6242547 0.95078869 -0.7245792
FUNKCIJE
Vrlo korisna funkcija R okruženje je mogućnost da se prošire postojeće funkcije i da se lako napišu nove funkcije. U stvari, većina R softvera može da se posmatra kao niz R funkcija.
Sintaksa za definisanje funkcija
myfct <- function(arg1, arg2, ...) {
function_body
}
Vrednost koju funkcija vrati je vrednost tela funkcije, koja je obično nerasporedjen konačan izraz, pr.: return()
sintaksa za poziv funkcije
myfct(arg1=..., arg2=...)
Sintaksa pravila funkcije
Generalno
Funkcije se definišu (1) upisivanje function, (2) deklaracijom argumenata,varijabli (arg1, arg2, ...) i (3) definisanjem operacija koje (function_body) treba da izvrši.Funkciji se treba udeliti naziv ,da bi ista uopšte bila pozvana od strane programa-pogledati ispod
Naziv
Funkciji se može biti nazvana bilo kako,ali treba se obratiti pažnja da se izbegnu imena već postojećih funkcija.
Argumenti
Često je korisno da se obezbede vrednosti argumenata (pr. arg1=1:10). Na taj način one se ne moraju dodavati u trenutku kada program pozove funkciju.Lista argumenata takodje se može ostaviti prazna ( myfct - function() { fct_body }) kada se očekuje da funkcija uvek vrati istu vrednost.Argument '...' se može koristiti kada funkcija treba da prenese vrednosti u drugu funkciju.
Telo funkcije
Doslovan izraz (komande-operacije) su definisane u telu funkcije koje moraju da se nalaze izmedju zagrada. Individualne komande su razdvojene sa ‘;’ ili novom linijom(kako kome više odgovara).
Pozivanje funkcije
Funkcije se pozivaju njihovim imenom koje je unapred navedeno kao argument izmedju zagrada u programu.Prazne zagrade posle pozivanja funkcije će da dovedu do toga da program prikaže grešku.
Oblast delovanja
Varijable koje su definisane u funkciji,postoje samo dok je funkcija aktivna.Tako da se njima ne može pristupiti izvan funkcije.Da bi naterali varijablu iz funkcije da postoji globalno u celom programu koristite ovu operaciju:'-'. Ako se globalna varijabla koristi unutar funkcije,onda će globalna varijabla biti prikrivena samo u funkciji.
Primer: Osnovi funkcije
myfct <- function(x1, x2=5) {
z1 <- x1/x1
z2 <- x2*x2
myvec <- c(z1, z2)
return(myvec)
}
myfct # prints definition of function
myfct(x1=2, x2=5) # applies function to values 2 and 5
[1] 1 25
myfct(2, 5) # the argument names are not necessary, but then the order of the specified values becomes important
myfct(x1=2) # does the same as before, but the default value '5' is used in this case
Primer: Funkcije sa opcionalnim argumentima.
myfct2 <- function(x1=5, opt_arg) {
if(missing(opt_arg)) { # 'missing()' is used to test whether a value was specified as an argument
z1 <- 1:10
} else {
z1 <- opt_arg
}
cat("my function returns:", "\n")
return(z1/x1)
}
myfct2(x1=5) # performs calculation on default vector (z1) that is defined in the function body
my function returns:
[1] 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0
myfct2(x1=5, opt_arg=30:20) # a custom vector is used instead when the optional argument (opt_arg) is specified
my function returns:
[1] 6.0 5.8 5.6 5.4 5.2 5.0 4.8 4.6 4.4 4.2 4.0
Kontrolna sredstva funkcija: return, warning i stop
Return
Tok evaluacije funkcije može biti prekinut u bilo kojoj fazi komandom return Ovo se često koristi u kombinaciji sa zavisnim jednačinama.
Stop
Da bi se prekinula funkcija i pojavila poruka Error(Greška) pojedinac može da koristi funkciju stop.
Warning
Da bi se prikazala poruka upozorenja bez zaustavljanja rada funkcije koristi se funkcija warning("...").
myfct <- function(x1) {
if (x1>=0) print(x1) else stop("This function did not finish, because x1 < 0")
warning("Value needs to be > 0")
}
myfct(x1=2)
[1] 2
Warning message:
In myfct(x1 = 2) : Value needs to be > 0
myfct(x1=-2)
Error in myfct(x1 = -2) : This function did not finish, because x1 < 0
KORISNI Utilities
Debugging Utilities
Nekoliko debugging utilities su dostupni za R.Najvažniji utilities su: traceback(), browser(), options(error=recover), options(error=NULL) i debug(). Debugging in R
pruža pregled svih dostupnih resursa.
REGULARNI IZRAZI
Regularni izrazi u R-u rade slično kao i u drugim programskim jezicima.Da naušite kako da ih koristite u R-u ,možete konsultovati main help page u ovom odeljku ?regexp. U nastavku su nekoliko osnovnih primera.
Funkcija grep može se koristiti za pronalaženje šablona u nizovima,ovde je slovo A u vektoru month.name.
month.name[grep("A", month.name)]
[1] "April" "August"
gsub("(i.*a)", "xxx_\\1", "virginica", perl = TRUE)
[1] "vxxx_irginica"
Primer split i paste funkcija
x <- gsub("(a)", "\\1_", month.name[1], perl=TRUE) # performs substitution with back reference which inserts in this Primer a '_' character
x
[1] "Ja_nua_ry"
strsplit(x, "_") # splits string on inserted character from above
[[1]]
[1] "Ja" "nua" "ry"
paste(rev(unlist(strsplit(x, NULL))), collapse="") # reverses character string by splitting first all characters into vector fields and then collapsing them with paste
[1] "yr_aun_aJ"
Primer za uvoz određene linije u fajlu sa regularnim izrazom.Sledeći primer pokazuje pronalaženje određenih linija iz eksternog fajla sa regularnim izrazom.Prvo se spoljni fajl kreira sa cat funkcijom, sve linije ovog fajla su umetnute u vektor pomoću readLines, specifične linije se zatim vraćaju funkcijom grep, u rezultirajuće linije su ubačene u vektor pomoću strsplit.
cat(month.name, file="zzz.txt", sep="\n")
x <- readLines("zzz.txt")
x <- x[c(grep("^J", as.character(x), perl = TRUE))]
t(as.data.frame(strsplit(x, "u")))
[,1] [,2]
c..Jan....ary.. "Jan" "ary"
c..J....ne.. "J" "ne"
c..J....ly.. "J" "ly"
PRIKAZIVANJE NIZA KARAKTERA KAO SKUP BROJEVA
Primer
mylist <- ls() # generates vector of object names in session
mylist[1] # prints name of 1st entry in vector but does not execute it as expression that returns values of 10th object
get(mylist[1]) # uses 1st entry name in vector and executes it as expression
eval(parse(text=mylist[1])) # alternative approach to obtain similar result
VREME,DATUM i SLEEP
Primer
system.time(ls()) # returns CPU (and other) times that an expression used, here ls()
user system elapsed
0 0 0
date() # returns the current system date and time
[1] "Wed Dec 11 15:31:17 2012"
Sys.sleep(1) # pause execution of R expressions for a given number of seconds (e.g. in loop)
POZIVANJE SPOLJAŠNJEG SOFTVERA POMOĆU SISTEMSKIH KOMANDI
Sistemske komande omogućavaju poziv iz R-a svake softverske komandne linije Linux-a,UNIX-a i OSX sistema.
system("...") # provide under '...' command to run external software e.g. Perl, Python, C++ programs
Povezane utilities Windows operativnog sistema
x <- shell("dir", intern=T) # reads current working directory and assigns to file
shell.exec("C:/Documents and Settings/Administrator/Desktop/my_file.txt") # opens file with associated program
(1) Grupni uvoz ili izvoz mnogo datoteka.
U sledećem primeru sva imena datoteka završavaju se sa *.txt u tekućem direktorijumu kao prvo (znak '$'
označava kraj niza).Drugo, fajlovi se uvoze jedan po jedan koristići for petlju u kojoj su originalni nazivi raspoređeni datumske ramove koristeći assign funkciju. Konsultujte pomoć koristeći ?read.table da bi ste razumeli argumente row.names=1 i comment.char = "A". Treće, okviri podataka su izvezeni i koriste svoja imena za datoteku imenovanjem i dodavanje ekstenzije *.out.
files <- list.files(pattern=".txt$")
for(i in files) {
x <- read.table(i, header=TRUE, comment.char = "A", sep="\t")
assign(i, x)
print(i)
write.table(x, paste(i, c(".out"), sep=""), quote=FALSE, sep="\t", col.names = NA)
}
(2) Pokretanje Web Aplikacije (osnovi o dizajniranju web client/crawling/scraping scripts u R)
Primer korišćenja MW vrednosti depeptid sekvence EXPASY's pI/MW Tool web stranice.
myentries <- c("MKWVTFISLLFLFSSAYS", "MWVTFISLL", "MFISLLFLFSSAYS")
myresult <- NULL
for(i in myentries) {
myurl <- paste("http://ca.expasy.org/cgi-bin/pi_tool?protein=", i, "&resolution=monoisotopic", sep="")
x <- url(myurl)
res <- readLines(x)
close(x)
mylines <- res[grep("Theoretical pI/Mw:", res)]
myresult <- c(myresult, as.numeric(gsub(".*/ ", "", mylines)))
print(myresult)
Sys.sleep(1) # halts process for one sec to give web service a break
}
final <- data.frame(Pep=myentries, MW=myresult)
cat("\n The MW values for my peptides are:\n")
final
Pep MW
1 MKWVTFISLLFLFSSAYS 2139.11
2 MWVTFISLL 1108.60
3 MFISLLFLFSSAYS 1624.82
POKRETANJE R PROGRAMA
(1) Izvršavanje R skripte iz R konzole.
source("my_script.R")
(2.1) Sintaksa za pokretanje programa R iz komandne linije.Zahtev u prvoj liniji od my_script.R sledećom naredbom: #!/usr/bin/env Rscript
$ Rscript my_script.R # or just ./myscript.R after making file executable with 'chmod +x my_script.R'
Sve komande koje počinju znakom '$' treba da se izvrše iz Unix ili Linux Shella.
(2.2) Alternativno,pojedinac može koristiti sledeći sintaksu za pokretanje programa R-a iz BATCH moda iz komandne linije.
$ R CMD BATCH [options] my_script.R [outfile]
Izlazni fajl izlistava komande iz skripte datoteke i negovih izlaza. Ako izlazni fajl nije naznačen, ime će biti ime ulaznog fajla prispojeno sa .Rout. Da bi se zaustavilo da se informacije R comandne linije prepišu u izlazni fajl, dodajte ovo u prvu liniju skripte my_script.R fajl:options(echo=FALSE). Ako je komanda pokrenuta kao R CMD BATCH --no-save my_script.R, onda ništa neće biti sačuvano u .rdata fajl koji je uglavnom veoma veliki. Više o ovome možete naći na stranici: $ R CMD BATCH --help or ?BATCH.
(2.3) Još jedna alternativa za pokretanje R programa najtiše moguće
$ R --slave < my_infile > my_outfile
Argument --slave čini da se R program pokrene “najtiše” moguće.
(3) Dodavanje komandne linije argumentima u R programima
Napravite R skriptu, ovde je nazvana test.R, kao ovu:
######################
myarg <- commandArgs()
print(iris[1:myarg, ])
######################
Zatim je pokrenite iz komandne linije kao ovde:
$ Rscript test.R 10
U ovom prikazanom primeru broj 10 je dodat iz komandne linije kao argument R skripte koja je korišćena u STDOUT u prvih deset redova iris datoteci iz primera. Ako je nekoliko argumenata obezbedjeno, oni će biti prikazani kao jedan niz koji treba da se razdvoji u R programu pomoću funkcije strsplit.
(4) Dodati R skriptu u Linux Cluster koristeći Torque
Napravite sledeću shell skriptu my_script.sh
#################################
#!/bin/bash
cd $PBS_O_WORKDIR
R CMD BATCH --no-save my_script.R
#################################
Ova skripta ne mora da ima dozvolu za pokretanje.Koristite sledeću komandu qsub
da pošaljete ovu skriptu u Linux Cluster iz direktorijuma gde je R skripta my_script.R je pronadjena. Da biste iskoristili nekoliko procesora na Linuk cluster, možete podeliti ulazne podatke na nekoliko manjih skupova i izvršava za svaki podskup odvojen proces od namenskog direktorijuma.
$ qsub my_script.sh
Ovde je kratak R skripta koja generiše potrebne fajlove i direktorijume automatski i dostavlja na čvorove:
submit2cluster.R.
Za više detalja pogledati 'Tutorial on Parallel Programming in R' by Hanna Sevcikova
OBJEKTNO-ORJENTISANO PROGRAMIRANJE
R podržava dva sistema za objektno-orijentisanog programiranja (OOP).Stariji S3 sistem i nedavno uvedena S4 sistem. Ovo poslednji je više formalna, podržava više zaostavštine više opreme i introspekcije. Mnoge od ovih funkcija nisu dostupni u starijoj verziji S3 sistema.U principu, OOP pristup je preuzela R je da se razdvoje specifikacije klase iz specifikacija generičkih funkcija (funkcija-centric sistem). Sledeći uvod je ograničena na S4 sistemu, jer danas je preferirani OOP metod R. Više informacija o OOP istraživanju mogu se naći u sledećem: Vincent Zoonekynd's introduction to S3 Classes, S4 Classes in 15 pages, Christophe Genolini's S4 Intro, The R.oo package, BioC Course: Advanced R for Bioinformatics, Programming with R by John Chambers i R Programming for Bioinformatics by Robert Gentleman.
DEFINISANJE S4 KLASA
(A) Definišite s4 klase sa setClass() i new()
y <- matrix(1:50, 10, 5) # Sample data set
setClass(Class="myclass",
representation=representation(a="ANY"),
prototype=prototype(a=y[1:2,]), # Defines default value (optional)
validity=function(object) { # Can be defined in a separate step using setValidity
if(class(object@a)!="matrix") {
return(paste("expected matrix, but obtained", class(object@a)))
} else {
return(TRUE)
}
}
)
setClass funkcija definiše klasu.Najvažniji argumenti su:
- Class: ime klase
- representation: slotovi koje nova klasa treba da ima ili stara klasa koja povećava ovu klasu.
- prototype: objekat koji obezbedjuje podrazumevane podatke za slotove.
- contains: klase koje ova klasa proširuje.
- validity, access, version: sadržani kontrolni argumenti kompaktibilni sa SPlus.
- where: okruženje u koje će da se umetne ili iz kog će se izbrisati .
(B) Funkcija new kreira novu klasu (ovde myclass)
myobj <- new("myclass", a=y)
myobj
An object of class "myclass"
Slot "a":
[,1] [,2] [,3] [,4] [,5]
[1,] 1 11 21 31 41
[2,] 2 12 22 32 42
...
new("myclass", a=iris) # Returns an error message due to wrong input type (iris is data frame)
Error in validObject(.Object) :
invalid class myclass object: expected matrix, but obtained data.frame
Argumenti su:
- Class: ime klase
- ...: podaci uključeni u novi objekat sa argumentima koji definišu slotove u definiciji klase.
(C) Višegenerički način stvaranja klase umesto da definiše metod otvaranja (detalji ispod)
setMethod("initialize", "myclass", function(.Object, a) {
.Object@a <- a/a
.Object
})
new("myclass", a = y)
[1] "initialize"
new("myclass", a = y)> new("myclass", a = y)
An object of class "myclass"
Slot "a":
[,1] [,2] [,3] [,4] [,5]
[1,] 1 1 1 1 1
[2,] 1 1 1 1 1
...
(D) Korisne i pomoćne funkcije
myobj@a # The '@' extracts the contents of a slot. Usage should be limited to internal functions!
initialize(.Object=myobj, a=as.matrix(cars[1:3,])) # Creates a new S4 object from an old one.
# removeClass("myclass") # Removes object from current session; does not apply to associated methods.
(E) Nasledstvo:dopušta da se definiše nova klasa koja nasledjuje sve osobine (pr. data slots, methods) od svoje roditeljske klase
setClass("myclass1", representation(a = "character", b = "character"))
setClass("myclass2", representation(c = "numeric", d = "numeric"))
setClass("myclass3", contains=c("myclass1", "myclass2"))
new("myclass3", a=letters[1:4], b=letters[1:4], c=1:4, d=4:1)
An object of class "myclass3"
Slot "a":
[1] "a" "b" "c" "d"
Slot "b":
[1] "a" "b" "c" "d"
Slot "c":
[1] 1 2 3 4
Slot "d":
[1] 4 3 2 1
getClass("myclass1")
Class "myclass1" [in ".GlobalEnv"]
Slots:
Name: a b
Class: character character
Known Subclasses: "myclass3"
getClass("myclass2")
Class "myclass2" [in ".GlobalEnv"]
Slots:
Name: c d
Class: numeric numeric
Known Subclasses: "myclass3"
getClass("myclass3")
Class "myclass3" [in ".GlobalEnv"]
Slots:
Name: a b c d
Class: character character numeric numeric
Extends: "myclass1", "myclass2"
Argument contains dopušta da proširite postojeću klasu.
(F) naterati objekte da predju u drugu klasu
setAs(from="myclass", to="character", def=function(from) as.character(as.matrix(from@a)))
as(myobj, "character")
[1] "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14" "15"
...
(G) Virtualne klase se konstruišu kada se ne zna da li će trebati ili ne da se kreira klasa.Oni se koriste da povežu klase koje imaju različit prikaz (pr. ne mogu naslediti jedna od druge) ali obe slične po funkcionalnosti.Često je poželjno stvoriti virtuelnu klasu a onda je proširiti drugim klasama. Virtuelne klase se mogu definisati tako što se izostavi representation agrument ili dati ime VIRTUAL:
setClass("myVclass")
setClass("myVclass", representation(a = "character", "VIRTUAL"))
(H) Funkcije koje ispunjavaju klase
- getClass("myclass")
- getSlots("myclass")
- slotNames("myclass")
- extends("myclass2")
DODELITI SVOJSTVA I METODE
Dodeliti svojstvo ili metodu koristeći setGeneric() i setMethod()
(A) accessor funkciju (izbegavati '@')
setGeneric(name="acc", def=function(x) standardGeneric("acc"))
setMethod(f="acc", signature="myclass", definition=function(x) {
return(x@a)
})
acc(myobj)
[,1] [,2] [,3] [,4] [,5]
[1,] 1 11 21 31 41
[2,] 2 12 22 32 42
...
(B.1) zamena metode korišćenjem funkcije (acc <-)
setGeneric(name="acc<-", def=function(x, value) standardGeneric("acc<-"))
setReplaceMethod(f="acc", signature="myclass", definition=function(x, value) {
x@a <- value
return(x)
})
## After this the following replace operations with 'acc' work on new object class
acc(myobj)[1,1] <- 999 # Replaces first value
colnames(acc(myobj)) <- letters[1:5] # Assigns new column names
rownames(acc(myobj)) <- letters[1:10] # Assigns new row names
myobj
An object of class "myclass"
Slot "a":
a b c d e
a 999 11 21 31 41
b 2 12 22 32 42
...
(B.2) zameniti metodu koristeći "[" operator ([<-)
setReplaceMethod(f="[", signature="myclass", definition=function(x, i, j, value) {
x@a[i,j] <- value
return(x)
})
myobj[1,2] <- 999
myobj
An object of class "myclass"
Slot "a":
a b c d e
a 999 999 21 31 41
b 2 12 22 32 42
...
(C) definišite ponašanje "["
setMethod(f="[", signature="myclass",
definition=function(x, i, j, ..., drop) {
x@a <- x@a[i,j]
return(x)
})
myobj[1:2,] # Standard subsetting works now on new class
An object of class "myclass"
Slot "a":
a b c d e
a 999 999 21 31 41
b 2 12 22 32 42
...
(D) definišite ponašanje štampača
setMethod(f= show", signature="myclass", definition=function(object) {
cat("An instance of ", "\"", class(object), "\"", " with ", length(acc(object)[,1]), " elements", "\n", sep="")
if(length(acc(object)[,1])>=5) {
print(as.data.frame(rbind(acc(object)[1:2,], ...=rep("...", length(acc(object)[1,])),
acc(object)[(length(acc(object)[,1])-1):length(acc(object)[,1]),])))
} else {
print(acc(object))
}})
myobj # Prints object with custom method
An instance of "myclass" with 10 elements
a b c d e
a 999 999 21 31 41
b 2 12 22 32 42
... ... ... ... ... ...
i 9 19 29 39 49
j 10 20 30 40 50
(E) definišite odredjenu funkciju (ovde nasumišno medja mesto redova)
setGeneric(name="randomize", def=function(x) standardGeneric("randomize"))
setMethod(f="randomize", signature="myclass", definition=function(x) {
acc(x)[sample(1:length(acc(x)[,1]), length(acc(x)[,1])), ]
})
randomize(myobj)
a b c d e
j 10 20 30 40 50
b 2 12 22 32 42
...
(F) definišite grafišku razradnu funkciju i dozvolite korisniku da joj pristupi pomoću funkcije plot
setMethod(f="plot", signature="myclass", definition=function(x, ...) {
barplot(as.matrix(acc(x)), ...)
})
plot(myobj)
(G) Funkcije koje proveravaju metode
- showMethods(class="myclass")
- findMethods("randomize")
- getMethod("randomize", signature="myclass")
- existsMethod("randomize", signature="myclass")
IZGRADNJA R PAKETA
Da se upoznaju sa strukturom, zgrade i podnošenje proces R paketa, korisnici treba da pažljivo pročitate dokumentaciju o ovoj temi dostupna na ovim sajtovima:
Kratak pregled izgradnje R paketa
-
(A) Autokatska izgradnja paketa pomoću funkcije package.skeleton :
package.skeleton(name="mypackage", code_files=c("script1.R", "script2.R"), namespace=TRUE)
Napomena:Ovo je opcionalno, ali veoma pogodna funkcija da se počne sa novim paketom.Dati primer će kreirati direktorijum nazvan mypackage
i sadržaće kostur paketa za sve funkcije,metode i klase definisane u R skripti dodato na argumet code_files
Osnovna struktura direktorijuma paketa je opisana ovde.
Datoteka paketa će takodje sadržati fajl pod nazivom ' Read-and-delete-me' sa kompletnim uputstvom datog paketa:
- Editujte pomoćni fajl skeleta u man, po mogućstvu da sadrži pomoć za sve funkcije
- Editujte izlaze u NAMESPACE,i sve neophodne ulaze
- Stavite C/C++/Fortran kod u src.
- Ako imate preveden kod,dodajte useDynLib()direktivu u NAMESPACE.
- Pokrenite R CMD build da bi napravili tarball paketa.
- Pokrenite R CMD check da bi proverili tarball paketa.
- Pročitajte Writing R Extensions za više informacija.
(B) Jednom kada skelet paketa bude dostupan,pojedinac može da gradi paket iz komandne linije (Linux/OS X):
Ovo će kreirati tarball paketa sa verzijom enkodiranog broja u imenu fajla. pr.: mypackage_1.0.tar.gz.
Odmah paket tarball treba ispitati da li ima grešaka.
$ R CMD check mypackage_1.0.tar.gz
All issues in a package's source code and documentation should be addressed until R CMD check returns no error or warning messages anymore.
(C) Instalirajte paket sa source-a
Linux:
install.packages("mypackage_1.0.tar.gz", repos=NULL)
OS X:
install.packages("mypackage_1.0.tar.gz", repos=NULL, type="source")
Windows zahteva zip arhivu za instaliranje R paketa, koja se najlakše može kreirati na komandnoj liniji (Linux/OS X) tako što će se instalirati paket na lokalnom direktorijumu,a zatim biti kreiran zip fajl instaliranog direktorijuma paketa.
$ mkdir tempdir
$ R CMD INSTALL -l tempdir mypackage_1.0.tar.gz
$ cd tempdir
$ zip -r mypackage mypackage
## The resulting mypackage.zip archive can be installed under Windows like this:
install.packages("mypackage.zip", repos=NULL)
Ova procedura važi samo za pakete koji se ne ukrštaju sa kodovima kreiranim u (C/C++-u). Uvod kako kreirati pakete u Windowsu možete pronaći ovde i ovde.
(D) Zadržite/Proširite postojeći paket
- Dodajte novu funkciju,metodu ili klasu u skriptovan fajl u ./R direktorijum u vašem paketu.
- Dodajte njihova imena u NAMESPACE fajl u paketu.
- Dodatni *.Rd pomaže da se templates generišu sa funkcijama kao što je promt*()
source("myscript.R") # imports functions, methods and classes from myscript.R
prompt(myfct) # writes help file myfct.Rd
promptClass("myclass") # writes file myclass-class.Rd
promptMethods("mymeth") # writes help file mymeth.Rd
- The resulting *.Rd help files can be edited in a text editor and properly rendered and viewed from within R like this:
library(tools)
Rd2txt("./mypackage/man/myfct.Rd") # renders *.Rd files as they look in final help pages
checkRd("./mypackage/man/myfct.Rd") # checks *.Rd help file for problems
(E) Postavite paket na javno mesto
Najbolji način razmene R paketa sa zajednicom je da stavite vaš paket na CRAN ili Bioconductor.Detalji kako postaviti pakete možete pronaći na pomenutim mestima:
REPRODUKTIVNO PRETRAŽIVANJE POMOĆU INTEGRISANJA R SA LATEX-OM
VEŽBE ZA PROGRAMIRANJE U R-u
Slajdovi za vežbe
[ Slajdovi ] [ Vežbe ] [ Dodatne vežbe ]
Preuzmite iznad fajlove za vežbu , a zatim počnite sa editovanjem R source fajla uz pomoć programskih teks editora kao što su Vim,Emacs ili jednim od R GUI editora teksta.Ovde se nalazi
HTML verzija koda sa obojenom sintaksom.
Primer Skripte
Paket operacija sa mnogo fajlova
## (1) Start R from an empty test directory
## (2) Create some files as sample data
for(i in month.name) {
mydf <- data.frame(Month=month.name, Rain=runif(12, min=10, max=100), Evap=runif(12, min=1000, max=2000))
write.table(mydf, file=paste(i , ".infile", sep=""), quote=F, row.names=F, sep="\t")
}
## (3) Import created files, perform calculations and export to renamed files
files <- list.files(pattern=".infile$")
for(i in seq(along=files)) { # start for loop with numeric or character vector; numeric vector is often more flexible
x <- read.table(files[i], header=TRUE, row.names=1, comment.char = "A", sep="\t")
x <- data.frame(x, sum=apply(x, 1, sum), mean=apply(x, 1, mean)) # calculates sum and mean for each data frame
assign(files[i], x) # generates data frame object and names it after content in variable 'i'
print(files[i], quote=F) # prints loop iteration to screen to check its status
write.table(x, paste(files[i], c(".out"), sep=""), quote=FALSE, sep="\t", col.names = NA)
}
## (4) Same as above, but file naming by index data frame. This way one can organize file names by external table.
name_df <- data.frame(Old_name=sort(files), New_name=sort(month.abb))
for(i in seq(along=name_df[,1])) {
x <- read.table(as.vector(name_df[i,1]), header=TRUE, row.names=1, comment.char = "A", sep="\t")
x <- data.frame(x, sum=apply(x, 1, sum), mean=apply(x, 1, mean))
assign(as.vector(name_df[i,2]), x) # generates data frame object and names it after 'i' entry in column 2
print(as.vector(name_df[i,1]), quote=F)
write.table(x, paste(as.vector(name_df[i,2]), c(".out"), sep=""), quote=FALSE, sep="\t", col.names = NA)
}
## (5) Append content of all input files to one file.
files <- list.files(pattern=".infile$")
all_files <- data.frame(files=NULL, Month=NULL, Gain=NULL , Loss=NULL, sum=NULL, mean=NULL) # creates empty data frame container
for(i in seq(along=files)) {
x <- read.table(files[i], header=TRUE, row.names=1, comment.char = "A", sep="\t")
x <- data.frame(x, sum=apply(x, 1, sum), mean=apply(x, 1, mean))
x <- data.frame(file=rep(files[i], length(x[,1])), x) # adds file tracking column to x
all_files <- rbind(all_files, x) # appends data from all files to data frame 'all_files'
write.table(all_files, file="all_files.xls", quote=FALSE, sep="\t", col.names = NA)
}
## (6) Write the above code into a text file and execute it with the commands 'source' and 'BATCH'.
source("my_script.R") # execute from R console
$ R CMD BATCH my_script.R # execute from shell
OPŠIRNA ANALIZA NIZA
Primer skripte koja izvršava opširnu analizu niza kompleksnim upitom: lsArray.R. Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/lsArray.R")
GRAFIČKE PROCEDURE: Funkcija Mapa Primer
Skripta za iscrtavanje karte funkcije gena ili hromozoma: featureMap.R. Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/featureMap.txt")
Analiza Sekvenci Utilities-a
Sadrži sekvence ulaznih, sub-postavke i podudaranje šablona,AA Composition,NEEDLE, PHYLIP,itd. Skripta ' sequenceAnalysis.R'
demonstrira kako R može da se koristi kao moćno oružije rasporedjivanja i analize velikog broja biloških sekvenci.Ovaj primer takodje pokazuje kako je lako da integrišete R sa
EMBOSS projektima ili sa spoljašnjim programima.Skripta sadrži sledeće funkcionalnosti:
- Gomilu sekvenci unesenu u R vremenske okvire
- Motif pretraživanje sa statistikom
- Analizu kompozicija sekvence
- Komparaciju svih sa svim sekvencama
- Proizvodnju filogenetičkog stabla
Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/sequenceAnalysis.txt")
PODUDARANJE ŠABLONA I POZICIONO RAŠČLANJIVANJE SEKVENCI
Funkcije za ubacivanje sekvenci u R,reprodukovanje i dopunjavanje sekvence nukleotida,podudaranje šablona,poziciono raščlanjivanje i zvoženje pronadjenih rezultata u HTML formatu: patternSearch.R. Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/patternSearch.R")
IDENTIFIKACIJE PREZASTUPLJENIH NIZOVA SEKVENCIONALNM GRUPAMA
Funkcije za pronalaženje prezastupljenih reči u nizovima DNK,RNK ili proteinskim sekvencama: wordFinder.R.
Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/wordFinder.R")
PREVODJENJE DNK U PROTEIN
Skripta 'translateDNA.R' za prevodjenje sekvenci NN u AA sekvence. codon table). Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/translateDNA.R")
SUBPODEŠAVANJA STRUKTURNO DEFINISANIH FAJLOVA(SDF)
Skripta za uvodjenje i subpodešavanje SDF fajlova: sdfSubset.R. Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/sdfSubset.R")
Rukovodjenje Latex BibTeX Bazom podataka
Skripta za uvodjenje BibTeX baze podataka u R,pronalaženje individualnih referenci u full-text pretraživanju
funkcija i prikaz rezultata u R ili HubMed: BibTex.R. Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/BibTex.R")
PLAĆANJE POZAJMICA I TABELA AMORTIZACIJE
Ova skripta obračunava mesečnu i godišnju hipoteku ili plaćanje dugovanja,generiše tabelu amortizacije i prikazuje rezultate: mortgage.R. Za demo kako skripta radi pokrenite ovde:
source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/mortgage.R")
KURS ZADATAKA:GC SADRŽAJ OBRT I DOPUNA
Primenite gore pomenute informacije da bi napisali funkciju koja izračunava deo DNK sekvence njen GC sadržaj i generiše njihov obrt i dopunu. Evo nekih korisnih komandi koje se mogu koristiti u funkciji:
## Generate an Primer data frame with ID numbers and DNA sequences
fx <- function(test) {
x <- as.integer(runif(20, min=1, max=5))
x[x==1] <- "A"; x[x==2] <- "T"; x[x==3] <- "G"; x[x==4] <- "C"
paste(x, sep = "", collapse ="")
}
z1 <- c()
for(i in 1:50) {
z1 <- c(fx(i), z1)
}
z1 <- data.frame(ID=seq(along=z1), Seq=z1)
z1
## Write each character of sequence into separate vector field and reverse its order
my_split <- strsplit(as.character(z1[1,2]),"")
my_rev <- rev(my_split[[1]])
paste(my_rev, collapse="")
## Generate the sequence complement by replacing G|C|A|T by C|G|T|A
## Use 'apply' or 'for loop' to apply the above operations to all sequences in sample data frame 'z1'
## Calculate in the same loop the GC content for each sequence using the following command
table(my_split[[1]])/length(my_split[[1]])
|
