Ohjelmointi T

Link: http://manuals.bioinformatics.ucr.edu/home/programming-in-r

 

Sisalto

1 Kayttoonotto

2 R Perusasiat

3 Koodi Editorit R

4 Integrointi R Vim ja Tmux

5 Loytaa Apua

6 Ohjaus Rakenteet

6.1 Ehdollinen Teloitukset

6.1.1 vertailuoperaattoreita

6.1.2 Loogiset Operaattorit

6.1.3 Jos Lausunnot

6.1.4 Ifelse Lausuntoja

6.2 Silmukoita

6.2.1 Silmukan

6.2.2 , Kun Silmukka

6.2.3 Kayta Silmukka Perhe

6.2.3.1 Kaksi-Ulotteinen Data-Sarjaa: soveltaa

6.2.3.2 Repaleinen Taulukot: tapply

6.2.3.3 Vektorit ja Luettelot: lapply ja sapply

6.2.4 Muut Silmukat

6.2.5 Parantaa Nopeutta, Suorituskykya Silmukoita

7 Toiminnot

8 Hyodyllisia Apuohjelmia

8.1 Debugging Utilities

8.2 Saannollisia Lausekkeita

8.3 Tulkkaus Merkkijono, kuten Ilmaus

8.4 Aika, Paivamaara ja Nukkua

8.5 Soittamalla Ulkoisen Ohjelmiston kanssa Jarjestelma, Komento

8.6 Sekalainen Utilities

9 Kaynnissa T-Ohjelmia

10 olio-Ohjelmointi (OOP)

10.1 Maarittaa S4 Luokat

10.2 Maarittaa Geneeristen laakkeiden ja Menetelmia

11 Rakennus R-Paketit

12 Toistettavissa Tutkimus Integroimalla R Lateksi tai Markdown

13 R-Ohjelmointi Harjoitukset

13.1 Liikunta Dioja

13.2 Nayte Skriptit

13.2.1 Era-Operaatioita Paljon Tiedostoja

13.2.2 laajamittainen Array Analyysi

13.2.3 Graafinen Menettelyja: Ominaisuus Kartalla Esimerkki

13.2.4 Sekvenssin Analyysi Utilities

13.2.5 kaavoja ja Sijoitteluun Jasentamiseen Sekvenssit

13.2.6 Tunnistaa yliedustettuina Jouset Jarjestyksessa Sarjaa

13.2.7 Kaantaa DNA: n osaksi Proteiinia

13.2.8 Subsetting Rakenteen Maarittely Tiedostoja (SDF)

13.2.9 Toimitusjohtaja Latex-BibTeX-Tietokannat

13.2.10 Lainan Maksut ja Poistot Taulukoita

13.2.11 Harjoitustyo: GC Sisaltoa, Kaantaa & Taydentaa

14 Kaannos taman Sivun

Johdanto

Yleiskatsaus

– Yksi tarkeimmista nahtavyydet kayttaa R (http://cran.at.r-project.org) ymparisto on helppous, jolla

kayttajat voivat kirjoittaa omia ohjelmia ja mukautettuja toimintoja. R-koodin syntaksi on erittain helppo oppia, vaikka niille kayttajille, joilla ei ole aikaisempaa

kokemusta ohjelmoinnista. Kun perus R-ohjelmointi control rakenteet ovat ymmartaneet, kayttajat voivat kayttaa R-kielta kuin voimakas ympariston suorittaa

monimutkaisia mukautettuja analyyseja lahes mita tahansa tietoja.

Muodossa taman oppaan

tassa kayttoohjeessa kaikki komennot annetaan koodi laatikot, jossa R-koodi on painettu musta, kommentti-teksti, sininen ja lahto tuottamat R vihrea. Kaikki kommentit/selitykset aloittaa standardin kommentti merkki ‘#’, jotta niita on tulkittu R-komentoja. Talla tavalla sisallon koodin

laatikot voidaan liittaa heidan kommentoida tekstia R console arvioida niiden hyodyllisyytta. Joskus, useita komentoja tulostetaan yksi rivi ja erotetaan toisistaan

puolipisteella ‘;’. Komennot alkavat $ – merkilla taytyy olla teloitettiin alkaen Unix-tai Linux shell. Windows-kayttajat voivat yksinkertaisesti sivuuttaa niita.

R-Perusteet

T & BioConductor kasikirja sisaltaa yleisen johdannon kaytto R-ympariston

ja sen basic command syntax.

Koodi Editorit R

Useita erinomaisia koodi toimittajat ovat kaytettavissa, jotka tarjoavat toimintoja, kuten R-syntaksin korostus, automaattinen koodin sisennys ja apuohjelmat lahettaa

koodi/toiminnot R-konsoliin.
Basic-koodin toimittajat tarjoamia Rguis

RStudio: GUI-pohjainen IDE: T

Vim-R-Tmux: R tyoymparisto perustuu vim ja tmux

Emacs (ESS add-paketti)

gedit ja Rgedit

RKWard

Eclipse

Tinn-R

Notepad++ (NppToR)

Ohjelmointi T kayttaa Vim tai Emacs-Ohjelmointi T kayttaa RStudio

Integrointi R Vim ja Tmux

Kayttajat kiinnostunut integroimalla R vim ja tmux voi haluta kuulla Vim-R-Tmux

asetussivu.

Loytaa Apua

Viite luettelo R-ohjelmointi (valinta)
R Programming for Bioinformatics, Robert Gentleman

Advanced R, Hadley Wickham

S Programming, W. N. Venables ja B. D. Ripley

Programming with Data, John M. Chambers

R Help & R Coding Conventions, Henrik Bengtsson, Lundin Yliopisto

Programming in R  (Vincent

Zoonekynd)

Peter’s R Programming Pages, Yliopisto ja Warwick

Rtips, Paul Jonsson, Yliopisto ja Kansas

R for Programmers Norm Matloff, UC Davis

High-Performance R, Dirk Eddelbuettel opetusohjelma

esitellaan kayttaja-2008

C/C++ level programming for R, Gopi Goswami

Ohjaus Rakenteet

Ehdollinen Teloitukset

vertailuoperaattoreita

  • equal: ==
  • not equal: !=
  • greater/less than: > <
  • greater/less than or equal: >= <=

Loogisia Operaattoreita

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

Jos Lausunnot

Jos lausunnot toimivat pituus-yksi looginen vektorit.

Syntax

if(cond1=true) { cmd1 } else { cmd2 }

Esimerkki

if(1==0) {
print(1)
} else {
print(2)
}
[1] 2

Valta lisaamalla rivinvaihtoja valilla ‘} else’.

Ifelse Lausunnot

Ifelse lausunnot toimivat vektorien pituus vaihtelee.

Syntax

ifelse(test, true_value, false_value)

Esimerkki

x <- 1:10 # Creates sample data
ifelse(x<5 | x>8, x, 0)
[1]  1  2  3  4  0  0  0  0  9 10

Vyolenkit

Yleisimmin kaytetty loop-rakenteet T ovat, kun ja soveltaa silmukoita. Harvinaisempia ovat toista silmukoita. Tauko-toiminto on kaytossa murtautua ulos silmukkaa, ja

seuraava pysahdyksia kasittely nykyisen iteraation ja ennakot silmukoiden indeksi.

Loop

Silmukoita ohjataan silmukoiden vektori. Jokaisen iteraation silmukan yksi arvo kiehkura, vektori on maaritetty muuttuja, joka voidaan kayttaa lausuntoja elin

silmukan. Yleensa, maara silmukan toistojen on maaritelty joukko arvoja tallennetaan kiehkura, vektori, ja ne kasitellaan samassa jarjestyksessa kuin ne on tallennettu

silmukoiden vektori.

Syntax

for(variable in sequence) {
statements
}

Esimerkki

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

Esimerkki: kunto*

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

Esimerkki: pysayta kunnossa ja tulostaa virheilmoituksen

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

Kun Silmukka

Samanlainen silmukka, mutta toistojen ohjataan ehdollinen lausunto.

Syntax

while(condition) statements

Esimerkki

z <- 0
while(z < 5) {
z <- z + 2
print(z)
}
[1] 2
[1] 4
[1] 6

Kayta Silmukka-Perhe –

Two-Ulotteinen Data-Sarjaa: soveltaa

Syntax

apply(X, MARGIN, FUN, ARGs)

X: matriisi, matriisi tai tietoja.runko; MARGINA: 1 rivia, 2 saraketta, c(1,2) seka; FUN: yksi tai useampia toimintoja; ARGs: mahdolliset perustelut toiminto

Esimerkki

## 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
## Sama kuin edella, mutta yhdella rivilla koodia
levita(kuten.matriisi(x), 1, function(x) { jos (x<5) { x-1 } muu { x/x } })[1] 0 1 2 3 1 1 1 1 1 1

Varten Ragged Arrays: tapply

Koskee toiminto array luokat muuttuja pituudet (Ragged array). Ryhmittely on maaritelty tekija.

Syntax

tapply(vector, factor, FUN)

Esimerkki

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

Vektorit ja Luettelot: lapply ja sapply

Seka soveltaa funktio, vektor tai luettelo esineita. Toiminto lapply palauttaa listan, kun sapply yrittaa palata yksinkertaisin data-objekti, kuten

vektor tai matrix sijaan list.

Syntax

lapply(X, FUN)
sapply(X, FUN)

Esimerkki

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

Muut Silmukat

Toista Silmukka

Syntaksi

repeat statements

Silmukka toistetaan, kunnes tauko on maaritelty. Tama tarkoittaa, siella taytyy olla toinen lausunto testata, onko tai ei taukoa silmukka.

Esimerkki

z <- 0
repeat {
z <- z + 1
print(z)
if(z > 100) break()
}

Parantaa Nopeutta, Suorituskykya Silmukoita

Silmukoiden yli erittain suuria tietomaaria voi tulla hidas R. Kuitenkin, tama rajoitus voidaan ratkaista poistamalla tiettyja operaatioita silmukoita tai valttaa

silmukoita yli data-intensiivinen ulottuvuuden esine kokonaan. Jalkimmainen voidaan saavuttaa suorittamalla paaasiassa vektori–vecor tai matriisi-matriisi laskelmat,

jotka kulkevat usein yli 100 kertaa nopeammin kuin for() tai apply() silmukoita R. Tata tarkoitusta varten, voidaan kayttaa olemassa olevaa nopeus-optimoitu R-

toiminnot (esim: rowSums, rowMeans, table, tabulate) tai yksi voi suunnitella mukautettuja toimintoja valttaa kalliita R silmukoita kayttamalla vektori

– tai matriisi-pohjainen lahestymistapoja. Vaihtoehtoisesti voidaan kirjoittaa ohjelmia, jotka suorittavat kaikki aikaa vievaa laskelmat on C-tasolla.

(1) Nopeus vertailu for silmukoita kanssa append vs. pistaa vaihe:

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.559results <- 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

pistaa lahestymistapa on 20-50 kertaa nopeammin kuin append-versio.

(2) Nopeus vertailu apply silmukka vastaan rowMeans computing tarkoittaa kunkin rivin suuri matriisi:

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 lahestymistapa on yli 200 kertaa nopeammin kuin soveltaa silmukka.

(3) Nopeus vertailu apply silmukka vastaan vektoroitua lahestymistapa computing keskihajonta kunkin rivin:

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.3005428system.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

vektori-pohjainen lahestymistapa viimeinen vaihe on yli 200 kertaa nopeammin kuin apply silmukka.

(4) Esimerkki computing tarkoittaa mukautettuja valinta sarakkeet tinkimatta nopeus suorituskyky:

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

Toiminnot

Erittain hyodyllinen ominaisuus R-ymparistossa on mahdollisuus laajentaa olemassa olevia toimintoja ja helposti kirjoittaa mukautettuja toimintoja. Itse asiassa,

suurin osa R-ohjelmistolla voidaan tarkastella sarjana R-toiminnot.

Syntax maaritella toimintoja

myfct <- function(arg1, arg2, …) {
function_body
}

palautettu arvo, jonka funktio on funktion arvo elin, joka on yleensa maarittamattomat lopullinen ilme, esim: paluu()

Syntax soittaa toimintoja

myfct(arg1=…, arg2=…)

Syntax Saannot Toimintoja

Yleiset

Toiminnot ovat maaritelty (1) tehtavan kanssa avainsanan toiminto, (2) ilmoitus vaitteet/muuttujat (arg1, arg2, …) ja (3) maaritellaan operaatiot (function_body),

joka suorittaa laskelmat on tarjonnut argumentteja. Funktion nimi on maaritetty soittaa toiminto (katso alla).

Nimeaminen

funktioiden nimet voi olla melkein mita tahansa. Kuitenkin, kaytto nimia nykyisia toimintoja tulisi valttaa.

Perustelut

– Se on usein hyodyllista tarjota oletusarvot argumentteja (esim.:arg1=1:10). Nain heidan ei tarvitse olla saadetty toiminto soittaa. Vaite lista voi olla myos

tyhja (myfct <- function() { fct_body }) kun toiminto on odotettavissa palauttaa aina saman arvon(s). Vaite ‘…’ voidaan kayttaa sallia yksi toiminto siirtaa

argumentti asetukset toiseen.

– Toiminto kehon

todellinen ilmaisuja (komennot/toiminnot) maaritellaan funktio elin, jonka pitaisi olla suljettu henkselit. Yksittaiset komennot erotetaan toisistaan puolipisteella

tai uusia riveja (ensisijainen).

Soittamalla toiminnot

Toiminnot ovat nimeltaan nimen jalkeen suluissa, jotka sisaltavat mahdollinen argumentti nimet. Tyhja sulkeisiin funktion nimen jalkeen tulee aiheuttaa

virheilmoituksen, kun toiminto vaatii tiettyja argumentteja toimittamien kayttaja. Funktion nimi yksin tulostaa maaritelma funktio.

Laajuus

Muuttujat luotu sisalla toiminto olemassa vain elaman ajan funktiona. Nain ollen ne eivat ole kaytettavissa ulkopuolella toiminto. Pakottaa muuttujien toimintoja

olemassa maailmanlaajuisesti, yksi voi kayttaa tata erityista sijoitusoperaattori: ‘<<-‘. Jos globaali muuttuja on kaytetty funktio, niin globaali muuttuja on

naamioitu vain sisalla toiminto.

Esimerkki: – Toiminnon perusasiat

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 25myfct(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

Esimerkki: – Toiminto valinnaiset argumentit

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.0myfct2(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

Ohjaus utilities toiminnot: return, warning ja stop

Return

arviointi flow-toiminto voidaan paattaa milloin tahansa vaiheessa return toiminto. Tama on usein kaytetaan yhdessa ehdollinen arvioinnit.

Stop
lopettaa toiminnan funktio ja tulostaa error ilmoituksen, yksi voi kayttaa stop toiminto.
Warning
tulosta varoittava viesti odottamattomissa tilanteissa ilman keskeytetaan arvioinnin flow-toiminto, voidaan kayttaa toimintoa 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 > 0myfct(x1=-2)
Error in myfct(x1 = -2) : This function did not finish, because x1 < 0

Hyodyllisia Apuohjelmia

Virheenkorjaus Apuohjelmia

Useat virheenkorjaus apuohjelmia ovat kaytettavissa R. tarkein utilities ovat: traceback(), browser(), options(error=recover), options(error=NULL) and debug(). Debugging R sivu tarjoaa yleiskatsauksen kaytettavissa olevista resursseista.

Saannollisia Lausekkeita

R on saannollinen lauseke utilities tyota samanlainen kuin muilla kielilla. Opetella kayttamaan niita R, yksi voi kuulla tarkein ohje sivu taman aiheen kanssa ?regexp.

Seuraavassa annetaan muutamia esimerkkeja.

Myos grep toimintoa voidaan kayttaa loytaa malleja jouset, tassa kirje vektori month.name.

month.name[grep(“A”, month.name)]
[1] “April”  “August”

Esimerkiksi kayttamalla saannollisia lausekkeita korvaava malli, jota toinen kayttaa sub/gsub toiminnon kanssa takaisin viittaus. Muista: yksi karkaa ‘\’ taytyy olla

kaksinkertainen pakeni ‘\\’ R.

gsub(“(i.*a)”, “xxx_\\1”, “virginica”, perl = TRUE)
[1] “vxxx_irginica”

Esimerkiksi split ja paste toiminnot

x <- gsub(“(a)”, “\\1_”, month.name[1], perl=TRUE) # performs substitution with back reference which inserts in this example 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”liita(rev(unlist(strsplit(x, NULL))), collapse=””) # kaantaa merkkijono jakamalla ensin kaikki merkit osaksi vektorin kentat ja sitten romahtaa niita

liittaa
[1] “yr_aun_aJ”

Esimerkiksi tuovan erityisia linjat-tiedoston kanssa saannollinen lauseke. Seuraava esimerkki osoittaa, haku erityisia linjat ulkoisen tiedoston kanssa saannollinen

lauseke. Ensimmainen, ulkoinen tiedosto on luotu kissa toiminto, kaikki linjat tama tiedosto tuodaan vektori kanssa readLines, tiettyja elementteja (lines) ovat sitten

retieved kanssa grep-toiminto, ja tuloksena linjat on jaettu vektori kentat 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”

Tulkkaus Merkkijono kuten Ilme

Esimerkki

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

Aika, Paivamaara ja Nukkua

Esimerkki

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)

Soittamalla Ulkoisen Ohjelmiston kanssa, Jarjestelma-Komento

jarjestelma-komennon avulla voit soittaa mihin tahansa komentorivin ohjelmisto sisalla R-Linux -, UNIX ja mac OSX jarjestelmat.

system(“…”) # provide under ‘…’ command to run external software e.g. Perl, Python, C++ programs

Liittyvat utilities Windows-kayttojarjestelmissa

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

Sekalaiset Apuohjelmat

(1) – Eran tuonti ja vienti useita tiedostoja.
Seuraavassa esimerkissa kaikki tiedostojen nimet paattyy *.txt-hakemistossa on ensin osoitettu list (“$”merkki on kayttaa ankkuri ottelun loppuun merkkijono).

Toiseksi, tiedostot tuodaan yksi kerrallaan kayttaen for-silmukan, jossa alkuperaiset nimet on maaritetty tuottaman tiedon kehykset assign toiminto. Ota apua ??

read.table ymmartaa argumentteja row.names=1 ja comment.char = “A”. Kolmanneksi, tiedot kehykset on viety kayttaen niiden nimia, tiedoston nimeaminen ja liittamalla

laajennus *.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) Kaynnissa Web-Sovelluksia (perusasiat suunnittelu web client/indeksoinnin/kaavinta skriptit R)
Esimerkki saamiseksi MW-arvot peptidi sekvenssit EXPASY’s pI/MW Tool web-sivun.

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

Kaynnissa R Ohjelmat

(1) – ikkunan R script R-konsoli

source(“my_script.R”)

(2.1) Syntax kaynnissa R ohjelmia komentorivilta. Vaatii in ensimmainen rivi my_script.R seuraavan lausunnon: #!/usr/bin/env Rscript

$ Rscript my_script.R # or just ./myscript.R after making file executable with ‘chmod +x

my_script.R’

Kaikki komennot alkavat $ – merkilla taytyy olla teloitettiin alkaen Unix tai Linux shell.


(2.2) Vaihtoehtoisesti voit kayttaa seuraavaa syntaksia ajaa R ohjelmia BATCH komentorivilta.

$ R CMD BATCH [options] my_script.R [outfile]

Tuotoksen tiedosto luettelot komentoja script file ja niiden tuotokset. Jos ei outfile on maaritetty, nimi, jota kaytetaan on, etta infile ja .Rout on liitteena

outfile. Lopettaa kaikki tavanomaiset R command line tietoja on kirjoitettu outfile, lisaa tama ensimmainen rivi my_script.R tiedosto: options(echo=FALSE). Jos komento

on ajaa kuin tama R CMD BATCH –no-save my_script.R, niin mitaan ei tallenneta .Rdata tiedosto, joka voi saada usein hyvin suuri. Lisaa tasta loytyy ohje-sivut: $ R

CMD BATCH –help or ?BATCH

(2.3) Toinen vaihtoehto kaynnissa R ohjelmia niin hiljaa kuin mahdollista.

$ R –slave < my_infile > my_outfile

Argumentti –slave tekee R juosta niin “hiljaa” kuin mahdollista.
(3) Kulkee komentorivin Argumentteja T Ohjelmat
Luo R kasikirjoitus, nimeltaan test.R, kuten tama:

######################
myarg <- commandArgs()
print(iris[1:myarg[6], ])
######################

Sitten ajaa se komentorivilta nain:

$ Rscript test.R 10

Tassa esimerkissa numero 10 valitetaan komentorivilta argumenttina R-skripti, joka on tapana palata STDOUT ensimmainen 10 rows iris naytteen tiedot. Jos useita

argumentteja annetaan, ne on tulkittava siten, etta yksi merkkijono, joka pitaa jakaa se T kanssa strsplit toiminto.

(4) Lahetetaan R komentosarjan Linux-klusterin kautta Vaantomomentti
Luo seuraava shell-skripti my_script.sh

#################################
#!/bin/bash
cd $PBS_O_WORKDIR
R CMD BATCH –no-save my_script.R
#################################

Tama skripti ei tarvitse olla suoritettavan kayttooikeudet. Kayta seuraavia qsub komento lahettaa taman shell script Linux-klusteri hakemistosta, jossa R script

my_script.R sijaitsee. Kayttaa useita Suorittimia Linux-klusteri, yksi voi jakaa lahtotiedot useisiin pienempiin osajoukkoja ja suorittaa kunkin osajoukon erillinen

prosessi omistettu hakemistoon.

$ qsub my_script.sh

Tassa on lyhyt R-skripti, joka luo tarvittavat tiedostot ja hakemistot automaattisesti ja toimittaa tyopaikkoja solmut: submit2cluster.R. Lisatietoja, katso myos tama. Tutorial on

Parallel Programming in R’ by Hanna Sevcikova

(5) Lahettamista tyopaikkoja kirista tai muita jonotuksen/aikataulutus jarjestelman kautta BatchJobs paketti. Tama paketti sisaltaa yksi pisimmalla resursseja lahettamista tyopaikkoja jonotus

jarjestelmien sisalla R. liittyva paketti on. BiocParallel Bioconductor, joka

ulottuu monia toimintoja BatchJobs genomin data-analyysi. Hyodyllisia asiakirjat BatchJobs: Technical Report, GitHub pageSlide ShowConfig samples.

library(BatchJobs)
loadConfig(conffile = ".BatchJobs.R")
## Loads configuration file. Here .BatchJobs.R containing just this line:
## cluster.functions <- makeClusterFunctionsTorque("torque.tmpl")
## The template file torque.tmpl is expected to be in the current working
## director. It can be downloaded from here:
## https://github.com/tudo-

r/BatchJobs/blob/master/examples/cfTorque/simple.tmpl

getConfig() # Returns BatchJobs configuration settings
reg <- makeRegistry(id=”BatchJobTest”, work.dir=”results”)
## Constructs a registry object. Output files from R will be stored under directory “results”,
## while the

standard objects from BatchJobs will be stored in the directory "BatchJobTest-files".
print(reg)
## Some test function
f <- function(x) {
system(“ls –(delete please these bald signs)al >> test.txt”)
x
}

## Adds jobs to registry object (here reg)
ids <- batchMap(reg, fun=f, 1:10)
print(ids)
showStatus(reg)

## Submit jobs or chunks of jobs to batch system via cluster function
done <- submitJobs(reg, resources=list(walltime=3600, nodes=”1:ppn=4″, memory=”4gb”))

## Load results from BatchJobTest-files/jobs/01/1-result.RData
loadResult(reg, 1)

Objek-Suuntautunut Ohjelmointi (OOP/OSU)

R-tukee kahta jarjestelmat olio-ohjelmointi (OOP). Vanhempi S3-jarjestelma ja enemman askettain S4-jarjestelma. Jalkimmainen on enemman muodollista, tukee useita

perinto, multiple dispatch ja itsetutkiskelua. Monet naista ominaisuuksista eivat ole kaytettavissa vanhemmissa S3-jarjestelma. Yleensa OOP lahestymistapa R on

erillinen luokka tekniset tiedot tekniset tiedot yleiset toiminnot (toiminto-keskeinen jarjestelma). Seuraavat kayttoonotto on rajoitettu S4-jarjestelma, koska se on

nykyaan ensisijainen OOP menetelma R. Lisatietoja OOP T loytyvat seuraavat esittelyt:  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 and R Programming for Bioinformatics by Robert

Gentleman.

Maarita S4 Luokat

() Maarita S4 Luokat setClass() ja 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([email protected])!=”matrix”) {
return(paste(“expected matrix, but obtained”, class([email protected])))
} else {
return(TRUE)
}
}
)
setClass toiminto maarittelee luokat. Sen tarkeimmat argumentit ovat:

Class: luokan nimi

representation: lahto, etta uusi luokka pitaisi olla ja/tai muiden luokkaa, etta taman luokan ulottuu.

prototype: kohde tarjoaa oletuksena tiedot lahto.

contains: luokkaa, etta taman luokan ulottuu.

validity, access, version: ohjaus argumentteja mukana yhteensopivuus S-Plus.

where: ymparisto kayttaa tallentaa tai poistaa maaritelma metatietona.

(B) toiminto new uusi esiintyma luokan (tassa 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

Sen argumentit ovat:

Class: luokan nimi

…: Data ovat uuden objektin perustelut mukaan lahto-luokan maaritelma.

(C) yleisempi tapa luoda luokan ilmentymia on maaritella alustuksen menetelma (tiedot alla)

setMethod("initialize", "myclass", function(.Object, a) {
[email protected] <- 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) Kaytto ja auttaja toimintoja

[email protected] # 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) Perinto: avulla voidaan maaritella uusia luokkia, jotka perivat kaikki ominaisuudet (esim. data lahto, menetelmat) niiden olemassa olevien vanhempi

luokat

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”



Vaite contains avulla voit laajentaa olemassa oleviin luokkiin; tama etenee kaikki lahto vanhempi luokat.

(F) Pakottaa esineita toiseen luokkaan

setAs(from="myclass", to="character", def=function(from) as.character(as.matrix([email protected])))
as(myobj, "character")
[1] "1"  "2"  "3"  "4"  "5"  "6"  "7"  "8"  "9"  "10" "11" "12" "13" "14" "15"
...

(G) Virtuaalinen luokat ovat konstruktioita, joista ei ole tapauksia tulee tai voidaan luoda. Niita kaytetaan yhdistavat luokat, jotka voivat olla erillisia

esityksia (esim. ei peri toisiaan), mutta joka haluaa tarjota samanlaisia toimintoja. Usein se on haluttu luoda virtuaalisen luokan ja sitten on useita muita luokat

laajentaa sita. Virtuaalinen luokat voidaan maaritella jattamalla pois edustus argumentti tai kuten luokan VIRTUAL

setClass("myVclass")
setClass("myVclass", representation(a = "character", "VIRTUAL"))
(H) Toiminnot introspect luokat
  • getClass(“myclass”)
  • getSlots(“myclass”)
  • slotNames(“myclass”)
  • extends(“myclass2”)

Maarita Generics ja Menetelmat

Maarita geneeristen laakkeiden ja menetelmia setGeneric() ja setMethod()() Accessor toiminto (valttaa kayttoa ‘@’)

setGeneric(name="acc", def=function(x) standardGeneric("acc"))
setMethod(f="acc", signature="myclass", definition=function(x) {
return([email protected])
})
acc(myobj)
[,1] [,2] [,3] [,4] [,5]
[1,]    1   11   21   31   41
[2,]    2   12   22   32   42
...
(B. 1) Korvaava menetelma kayttamalla mukautettuja accessor toiminto (acc <-)
setGeneric(name="acc<-", def=function(x, value) standardGeneric("acc<-"))
setReplaceMethod(f="acc", signature="myclass", definition=function(x, value) {
[email protected] <- 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) Korvaava menetelma kayttaa “[” operaattori ([<-)

setReplaceMethod(f="[", signature="myclass", definition=function(x, i, j, value) {
[email protected][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) Maarita kayttaytymista “[” subsetting operaattori (ei generic tarvita!)

setMethod(f="[", signature="myclass",
definition=function(x, i, j, ..., drop) {
[email protected] <- [email protected][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) Maarita tulosta kayttaytyminen

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) Maarita tiedot tietyn toiminnon (tassa satunnaista rivi jarjestyksessa)

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) Maarita graafisen piirto-toiminto, ja anna kayttajan kayttaa sita generic juoni toiminto

setMethod(f="plot", signature="myclass", definition=function(x, ...) {
barplot(as.matrix(acc(x)), ...)
})
plot(myobj)

(G) Toiminnot tarkastaa menetelmia

  • showMethods(class=”myclass”)
  • findMethods(“randomize”)
  • getMethod(“randomize”, signature=”myclass”)
  • existsMethod(“randomize”, signature=”myclass”)

Rakennus R-Paketeista

Saada perehtynyt rakenne -, rakennus-ja toimitusprosessi R paketteja, kayttajien tulee huolellisesti lukea asiakirjoja tasta aiheesta saatavilla naita sivustoja:Kirjoittaminen R Extensions, R-web-sivusto

Lyhyt Katsaus Paketti Rakennus Prosessi
() Automaattinen paketti rakennus, jossa package.skeleton toiminto:

package.skeleton(name="mypackage", code_files=c("script1.R", "script2.R"))

Huomautus: tama on valinnainen, mutta erittain kateva toiminto aloittaa uuden paketin. Esimerkissa luo hakemiston nimelta mypackage sisaltavat luuranko paketti kaikki

funktiot, metodit ja luokat on maaritelty R-skripti(s) siirtaa code_files argumentti. Perusrakenne paketti hakemisto on kuvataan. Paketti hakemisto sisaltaa myos tiedoston nimelta ‘Read-and-delete-me’ seuraavat tayttoohjeet paketti:

  • Muokkaa ohje-tiedosto luurankoja man, mahdollisesti yhdistamalla auttaa tiedostoja useita toimintoja.
  • Muokkaa vienti NAMESPACE, ja lisaa tarpeen tuonti.
  • Laittaa minka tahansa C/C++/Fortran-koodin src.
  • Jos sinulla on kaannetty koodi, lisata useDynLib() direktiivin NAMESPACE.
  • Run R-CMD build rakentaa paketin pakettia.
  • Run R CMD check tarkistaa paketin pakettia.
  • Lue Writing R Extensions lisatietoja.

(B) Kun paketti luuranko on saatavilla yksi voi rakentaa paketin komentorivilta (Linux/OS X):

$ R CMD build mypackage

Tama luo tarrapallon paketista ja sen versio numero on koodattu tiedoston nimi, esim.: mypackage_1.0.tar.gz.
Taman jalkeen paketti tarrapallon on tarkistettava virheet:

$ R CMD check mypackage_1.0.tar.gz
Kaikki kysymykset-paketin lahdekoodin ja dokumentaation pitaisi olla osoitettu, kunnes R CMD check palautus ei ole virhe tai varoitus viesteja enaa.

(C) Asentaa paketin lahde:

Linux:

install.packages("mypackage_1.0.tar.gz", repos=NULL)

OS X:

install.packages("mypackage_1.0.tar.gz", repos=NULL, type="source")

Windows vaatii zip-arkisto asentaminen R paketteja, jotka voidaan katevasti luoda komentorivilta (Linux/OS X) asentamalla paketin paikalliseen hakemistoon (tassa

tempdir) ja sitten luoda zip-arkisto asennetun paketin hakemistoon:

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

– Tama menettely toimii vain paketit, jotka eivat ole riippuvaisia kaannetty koodi (C/C++). Ohjeet taysin rakentaa R-paketti, Windows voi olla taalta ja taalla.

(D) Huolto/laajentaa olemassa olevan package:Lisata uusia toimintoja, menetelmia ja luokat script files ./R hakemiston paketti

Lisata nimet NAMESPACE tiedosto paketti

Tiedostojen *.Rd auttaa malleja voidaan tuottaa prompt*() toiminnot, kuten tama:

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

Tuloksena *.Rd apua tiedostoja voi muokata tekstieditorissa ja asianmukaisesti sulatettu ja katsella sisalla R, kuten tama:

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) Laheta paketti julkiseen arkistoon

paras tapa jakaa R-paketti, jossa yhteison on toimitettava se yksi tarkeimmista R paketti arkistot, kuten CRAN tai Bioconductor. Tietoja jattamista prosessi on

esitetty vastaava arkistoon toimittamista sivut:

Toistettavissa Tutkimus Integroimalla R Lateksi tai Markdown

R-Ohjelmointi Harjoitukset

Liikunta Dioja

Lataa edella liikunta-tiedostoja, sitten alkaa editointi tama R lahde tiedoston kanssa ohjelma tekstieditori kuten Vim, Emacs tai yksi R GUI

tekstinkasittelyohjelmilla. Tassa on HTML-versiossa koodin

kanssa syntaksin varitys.

Nayte Skriptit

eratoiminnot useita Tiedostoja

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

laajamittainen Array Analyysi

Nayte script suorittaa laajamittainen ilmaisu array analyysi monimutkaisia kyselyt: lsArray.R. Demo mita kasikirjoituksen tekee, ajaa se, kuten tama:

source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/lsArray.R")

Graafinen Menettelyja: Ominaisuus Map-Esimerkki

Kasikirjoituksen juoni ominaisuus karttoja geenit tai kromosomit: featureMap.R. Demo mita kasikirjoituksen tekee, ajaa se, kuten tama:

source(“http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/featureMap.txt”)

Sekvenssin Analyysi Utilities

Sisaltaa jarjestyksessa eran tuonti, sub-asetus, kaavoja, AA Composition, NEEDLE, PHYLIP, jne. Kasikirjoitus ‘sequenceAnalysis.R‘ osoittaa, miten R voidaan kayttaa

tehokas tyokalu hallita ja analysoida suuria maaria biologiset sekvenssit. Tama esimerkki osoittaa myos, kuinka helppoa on integroida R EMBOSS projekti tai muita ulkoisia ohjelmia. Kasikirjoitus sisaltaa seuraavat toiminnot:Eran jarjestyksessa

tuonti T tiedot runko

Motiivi haku osuma tilastot

Analyysi jarjestyksessa koostumus

Kaikki-vastaan-kaikki jarjestyksessa vertailuja

Sukupolven fylogeneettisia puita

Osoittaa utilities kasikirjoituksen, kayttajat voivat yksinkertaisesti suorittaa sen R seuraavasti lahde komento:

source(“http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/sequenceAnalysis.txt”)

kaavoja ja Sijoitteluun Jasentamiseen Sekvenssit

Toiminnot tuontia sekvensseja T, hakeminen kaanteinen ja taydennetaan nukleotidin sarjoissa, kuvio etsimista, asentohuimaus jasentamiseen ja vientia haun tulokset

HTML-muodossa: patternSearch.R. Demo mita kasikirjoituksen

tekee, ajaa se, kuten tama:

source(“http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/patternSearch.R”)

Tunnistaa yliedustettuina Jouset Jarjestyksessa Sarjaa

Toiminnot loytaa yliedustettuina sanoja eri DNA: ta, RNA tai proteiini sekvenssit: wordFinder.R. Demo mita kasikirjoituksen tekee, ajaa se, kuten

tama:

source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/wordFinder.R")

Kaantaa DNA: ta, Proteiineja

Script ‘translateDNA.T‘ kaantamiseen NT-sekvensseja AA-

sekvenssit (vaaditaan codon table). Demo mita kasikirjoituksen

tekee, ajaa se, kuten tama:

source(“http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/translateDNA.R”)

Subsetting Rakenteen Maarittely Tiedostoja (SDF -Structure Definition Files)

Kasikirjoitus tuonti ja subsetting SDF-tiedostot: sdfSubset.R.

Demo mita kasikirjoituksen tekee, ajaa se, kuten tama:

source(“http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/sdfSubset.R”)

Toimitusjohtaja Latex-BibTeX-Tietokannat

Kasikirjoituksen tuominen BibTeX-tietokannat R, haetaan yksittaisia viittauksia kanssa koko tekstin haku-toiminto ja katsella tuloksia R tai HubMed: BibTex.R. Demo mita kasikirjoituksen tekee, ajaa se, kuten tama:

source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/BibTex.R")

Lainan Maksut ja Poistot Taulukoita

Tama skripti laskee kuukausittain ja vuosittain kiinnitys tai lainan maksut, luo poistot taulukoita ja tontteja tulokset: mortgage.R. Demo mita kasikirjoituksen tekee, ajaa se, kuten tama:

source("http://faculty.ucr.edu/~tgirke/Documents/R_BioCond/My_R_Scripts/mortgage.R")

Harjoitustyo: GC Sisaltoa, Kaantaa & Taydentavat

Kayta ylla tietoa kirjoittaa funktio, joka laskee joukko DNA-sekvensseja heidan GC sisaltoa ja

luo niiden kaanteinen ja taydennetaan. Tassa on joitakin hyodyllisia komentoja, jotka voidaan sisallyttaa tama tehtava:

## Generate an example 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]])

Leave a Reply