Since 2004, our University project has become the Internet's most widespread web hosting directory. Here we like to talk a lot about web development, networking and server security. It is, after all, our expertise. To make things better we've launched this science section with the free access to educational resources and important scientific material translated to different languages.
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).
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 if(x < 5) { 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
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 sapply(mylist, sum) Sepal.Length Sepal.Width Petal.Length
14.7 9.7 4.1
Druge petlje
Repeat petlja
Sintaksa
repeat statements
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.
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.
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.
Primer korišćenja regularnog izraza koji zamenjuje jedan šablon drugim koristeći funkciju sub/gsub
a povratnom referencom. Zapamtite da jedan razmak '\' treba biti zamenjen u dupli razmak '\\' u R-u.
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.
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
MEŠOVITI UTILITIES
(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.
(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:
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.
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.
(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:
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
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:
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.
(B) Jednom kada skelet paketa bude dostupan,pojedinac može da gradi paket iz komandne linije (Linux/OS X):
$ R CMD build mypackage
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.
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:
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:
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:
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:
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:
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:
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]])