Back to site
Since 2004, our University project has become the Internet's most widespread web hosting directory. Here we like to talk a lot about web servers, web development, networking and security services. 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.

Programiranje u R

Programiranje u R

Autor: Thomas Girke, UC Riverside



UVOD


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


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

  • and: &
  • or: |
  • not: !

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
    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

## 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
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.

      (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"

      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.

      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


      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.

      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:
        (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

        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):

          $ 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.


          (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]])


          Published (Last edited): 28-01-2013 , source: http://manuals.bioinformatics.ucr.edu/home/programming-in-r