Emmanuel Paradis
paradis@isem.univ-montp2.fr
Itzultzaileak:
Gorka Azkune Galparsoro
gorkaazkune@yahoo.es
Yosu Yurramendi Mendizabal
yosu.yurramendi@ehu.es
R HASIBERRIENTZAT
Udako Euskal Unibertsitatea
Bilbo, 2005
© Udako Euskal Unibertsitatea
© Gorka Azkune Galparsoro, Yosu Yurramendi Mendizabal
ISBN: 84-8438-077-7
Argitaratzailea: UEU. Erribera 14, 1. D, 48005 Bilbo. http://www.ueu.org
URL: http://www.ueu.org/ueu/buruxkak.htm
Hizkuntza-zuzenketen arduraduna: Ander Altuna Gabiola
Edizio honen ontzailea:
Udako Euskal Unibertsitatea
http://www.ueu.org
argitalpenak@ueu.org
OHARRA: Galarazita dago dokumentu honen kopia egitea, osoa nahiz zatikakoa,
edozein modutara delarik ere, Copyright-jabearen baimenik gabe. Dokumentu
honen erabilera bakarra Jabego Intelektualaren legeak 31. eta 32. artikuluetan
jasota dakarrena izango da (argitalpen honen edukiak aipatu eta hedatu daitezke,
edozein eratara jatorria aipatuz gero).
Julien Claude, Christophe Declerq, Élodie Gazave, Friedrich Leisch eta
Mathieu Ros eskertu nahi ditut dokumentu honen aurreko bertsioetan egindako
iruzkin eta emandako gomendioengatik. R programatu duen programatzaile-taldea
ere bereziki eskertu nahiko nuke, programa horren garapenean zehar eginiko
esfortzu handiengatik eta "rhelp" eztabaida-gunean erakutsiriko gogoengatik.
Eskerrik asko R erabili ondoren galderak eta iruzkinak bidali dizkidaten guztiei,
beraiei esker idatzi ahal izan baitut "R hasiberrientzat".
© 2002, Emmanuel Paradis (2003ko martxoaren 3an)
Aurkibidea
1. Hitzaurrea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2. Zenbait kontzepturen azalpena hasi aurretik . . . . . . . . . . . . . . . . . . . . . 11
2.1. R-ren funtzionamendua . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2. Objektuen sorkuntza, listatua eta deuseztatzea memorian. . . . . . . . . 13
2.3. Laguntza. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3. Datuen erabilera R-n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.1. Objektuak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2. Artxibo batetik datuak irakurri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3. Datuak gorde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4. Datuak sortu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4.1. Sekuentzia erregularrak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4.2. Ausazko sekuentziak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.5. Objektuen erabilera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.5.1. Objektuak sortu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.5.2. Objektuen bihurketa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.5.3. Eragileak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.5.4. Objektu baten balioak atzitu: sistema indexatua . . . . . . . . . . 33
3.5.5. Izendun objektuen balioak atzitu. . . . . . . . . . . . . . . . . . . . . . 35
3.5.6. Datu-editorea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.5.7. Futzio aritmetiko sinpleak . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.5.8. Kalkuluak matrizeekin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4. Grafikoak R-n. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.1. Grafikoen erabilera. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.1.1. Gailu grafiko anitz ireki. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.1.2. Grafiko baten antolatzea . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.2. Funtzio grafikoak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.3. Behe-mailako komando grafikoak . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
4.4. Parametro grafikoak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.5. Adibide praktiko bat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.6. grid eta lattice paketeak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5. Analisi estatistikoak R-n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.1. Bariantza-analisi baten adibide sinplea . . . . . . . . . . . . . . . . . . . . . . . 63
5.2. Formulak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.3. Funtzio generikoak. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.4. Paketeak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6. Programazio praktikoa R-n. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.1. Begiztak eta bektorizazioa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.2. Nola idatzi programak R-n . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . 75
6.3. Nola eraiki geure funtzio propioak . . . . . . . . . . . . . . . . . . . . . . . . . . 76
7. R-ri buruz aurki daitezkeen bestelako dokumentu eta testuak . . . . . . . 81
6 R hasiberrientzat
1. Hitzaurrea
Dokumentu honen helburua R erabiltzen hasi nahi duten pertsonentzat nolabaiteko
hasiera-puntu bilakatzea da. R-ren oinarrizko erabilera lantzeko asmoz, programa
horren funtzionamenduan sakontzea erabaki dut. R-k eskaintzen dituen aukera-
piloak ikusita, komeni da hasiberriek kontzeptu eta nozio batzuk bereganatzea eta
pixkanaka beren ezagueran aurrera egitea. Bestalde, azalpenak ahalik eta
sinpleenak izan daitezen saiatu naiz, hori bai, xehetasun erabilgarrienak ahaztu
gabe; xehetasun horiek, askotan taulen bidez azalduko ditut.
R analisi estatistiko eta grafikoetara bideraturiko sistema bat da, Ross Ihaka-k
eta Robert Gentleman-ek1 sortua. Sistema honek nolabaiteko izaera bikoitza du:
alde batetik programa bat da, baina bestetik programazio-lengoaia ere bada. Oro
har, R, AT&T Bell laboratorioetan sortu zen S lengoaiaren dialektotzat hartzen da.
Interesa duenarentzat, S, Insightful2 etxeak plazaraturiko S-PLUS programaren
bidez eskura daiteke. R-ren eta S-ren diseinuan ezberdintasun garrantzitsuak topa
daitezke: gai horretan sakondu nahi dutenei Ihaka-k eta Gentleman-ek 1996an
argitaraturiko artikulua irakur dezatela gomendatzen diet, edo bestela R-ri buruzko
Galdera Ohikoenak3 izeneko atala kontsulta dezaten. Azken hori, R programarekin
batera banatzen da.
R doan banatzen da GNUk (General Public Licence4) ezarritako irizpideen
arabera; R-ren Garapenerako Talde Nuklear izenarekin ezagutzen diren estatistiko
batzuk arduratzen dira R-ren banaketaz eta garapenaz.
R hainbat formatan aurki daiteke: alde batetik, ia oso-osorik C lengoaiaz
idatzitako iturburu-kodearen forman (errutina batzuk Fortran lengoaian daude),
batez ere Unix eta Linux sistemetarako, eta bestetik, Windows, Linux (Debian,
Mandrake, RedHat, SuSe), Macintosh eta Alpha Unix sistemetarako aurrekon-
pilaturiko artxibo bitarren forman.
1. Ihaka R. eta Gentleman R. (1996): "R: a language for data analysis and graphics", Journal of
Computational and Graphical Statistics, 5, 299314.
2. Ikusi http://www.insightful.com/products/splus/default.html informazio gehiago eskuratzeko
3. http://cran.r-project.org/doc/FAQ/R-FAQ.html
4. Informazio gehiago http://www.gnu.org/ helbidean
R instalatzeko beharrezkoak diren artxiboak, bai iturburu-kodeak zein
aurrekonpilaturiko bitarrak erabiliz, Interneteko Comprehensive R Archive
Network (CRAN)5 kokalekuan aurki daitezke. Bertan, egokiro instalatzeko
argibideak ere badaude. Linux-en bertsioetarako (Debian, ...), bitarrak eskuarki
R-ren zein Linux-en bertsio eguneratuenetarako topa daitezke; beharrezko
baderitzozu, bisita ezazu CRAN gunea.
R-k analisi estatistiko eta grafikoetarako funtzio asko dauzka; grafikoak egin
bezain laster ikus daitezke dagokien leihoan, baita gorde ere hainbat formatutan
(jpg, png, bmp, ps, pdf, emf, pictex, xfig; eskuragarri dauden formatuak sistema
eragileen arabera zehazten dira). Analisi estatistikoen emaitzak pantailan ikus
daitezke, eta tarteko emaitza batzuk (P- balioak, erregresio-koefizienteak,
hondarrak...) gorde, beste artxibo batera esportatu, edo beste analisi batzuetan
erabil daitezke.
R lengoaiak, adibidez, begiztak ("loops" ingelesez) programatzeko aukera
ematen dio erabiltzaileari, horrek datu-multzoak era jarraian azter ditzan. Programa
bakar batean hainbat funtzio estatistiko konbinatzea ere posible da analisi konple-
xuagoak egiteko. R-ren erabiltzaileek S-rako idatzita dauden hamaikatxo programa
dituzte eskura, guztiak Interneten6; programa gehienak zuzenean R-n erabil
daitezke inongo arazorik gabe.
Hasiera batean R-k oso zaila dirudi aditua ez denarentzat. Hori, ordea, ez da
horrela. R-ren ezaugarri nabarmenena bere malgutasuna da, hain zuzen ere. Pro-
grama klasikoek analisi baten emaitza zuzenean erakusten badute ere, R-k,
"objektu" moduan gordetzen ditu emaitza horiek. Horrela analisi bat egin daiteke,
emaitzak berehala erakusteko beharrik gabe. Azaldu berri duguna nahiko arraroa
gerta dakioke erabiltzaileari, baina ezaugarri hori oso interesgarria izan ohi da, zeren
1. irudia. R-ren funtzionamenduaren ikuspegi eskematikoa
8 R hasiberrientzat
5. http://cran.r-project.org/
6. Adibidez: http://stat.cmu.edu/S/
erabiltzaileak emaitza orokorretik komeni zaizkion zatiak soilik eskura baititzake.
Adibidez, 20 erregresioz osaturiko segida bat korritzen badugu eta erregresio-
koefizienteak konparatu nahi baditugu, R-k, estimaturiko koefizienteak bakarrik
erakutsi diezazkiguke. Era horretara, emaitzak ilara bakar batean erakuts daitezke.
Kontu egin programa klasiko batek 20 leiho irekiko lituzkeela. Aurrerago R-ren
malgutasuna beste programa estatistiko ohikoenekin alderatzen dituzten adibideak
ikusiko ditugu.
Hitzaurrea 9
2. Zenbait kontzepturen azalpena hasi aurretik
R behar bezala instalatu ondoren, nahikoa da dagokion artxibo exekutagarria
martxan jartzea R erabiltzen hasteko. Kurtsoreak (defektuz ">" ikurra da) adie-
razten du programa komando bat hartzeko zain dagoela. Windows-en komando
batzuk menuen bidez exekuta daitezke (adib. laguntza bilatu, artxiboak ireki...).
Baliteke, behin hona iritsita, R lehendabizikoz darabilen batek "eta orain zer egin
behar dut?" galdetzea. R lehenengo aldiz erabili aurretik komeni da bere funtziona-
menduaren inguruko ideia bat edukitzea, eta horixe da, hain zuzen ere, guk orain
egingo duguna. Lehenik eta behin R-k nola funtzionatzen duen ikusiko dugu.
Ondoren, R-n objektuak sortzeko balio duen "esleitu" eragilea deskribatuko dut,
baita memorian sortu ditugun objektu horiek nola maneiatu ere. Azkenik, laguntza
erabiltzen ikasiko dugu. R-n, beste programa askotan ez bezala, laguntza nahiko
erabilgarri eta intuitiboa da.
2.1. R-REN FUNTZIONAMENDUA
R Objektuei Zuzendutako lengoaia da: hitz konplexu horren atzean ezkutatzen da
R-ren sinpletasun eta malgutasun guztia. Baliteke R programazio-lengoaia bat
izateak bere burua programatzailetzat ez daukan jende askorengan atzerakada
sorraraztea. Horrek ez luke horrela izan behar bi arrazoi nagusirengatik. Alde
batetik, R lengoaia interpretatu bat da (Java bezalaxe) eta ez konpilatua (C, C++,
Fortran, Pascal...). Horrek esan nahi du, teklatuan idazten ditugun komandoak
zuzenean exekutatuko direla inongo exekutagarririk sortzeko beharrik gabe.
Bigarren arrazoia R-ren sintaxi sinple eta intuitiboa da. Esaterako, erregresio
lineal bat lm(y ~x)komandoa idatziz exekuta daiteke. Funtzio bat exekutatu
nahi dugun bakoitzean, komandoaren izenaren atzetik beti parentesiak erabili
behar ditugu, nahiz eta barruan ezer ez idatzi (adib. ls()). Funtzioaren izena
parentesirik gabe idazten bada, R-k funtzio horren edukia (kodea) erakutsiko digu.
Dokumentu honetan, testuan zehar bestelakorik adierazten ez den bitartean,
funtzioen izenak parentesiekin idatziko dira beste objektuetatik bereizteko.
Objektuei Zuzendua izateak ondoriotzat dakar aldagaiak, funtzioak, emaitzak,
etab. ordenagailuaren memoria aktiboan izen konkretu bat duten objektu moduan
gordetzea. Erabiltzaileak objektuok aldatu edo manipula ditzake eragileak (aritme-
tikoak, logikoak eta aldarapenezkoak) zein funtzioak erabiliz. Ez ahaztu funtzioak
beraiek ere objektuak direla.
Eragileen erabilera eta funtzionamendua nahiko intuitiboak dira; horien
inguruko xehetasunak aurrerago ikusiko ditugu (32. orria). Funtzio bat R-n
ondoren agertzen den bezala irudika daiteke:
Argumentuak objektuak izan daitezke ("datuak", formulak, espresioak...).
Batzuk funtzioan bertan definituta egon daitezke defektuz, hala ere, argumentu
horiek erabiltzaileak alda ditzake aukera batzuen bitartez. R-n funtzio batek
argumenturik ez izatea posible da, denak defektuz definituta daudelako (eta beren
balioak aukeren bitartez aldatuta), edo funtzioak berak, berez ez duelako
argumenturik. Aurrerago ikusiko dugu funtzioak nola erabili eta eraiki (76. orria).
Oraingoz, eman berri dugun deskripzioa nahikoa da R-ren oinarrizko
funtzionamendua ulertzeko.
R-n ekintza guztiak ordenagailuaren memorian gordetzen diren objektuen
bidez gauzatzen dira, inongo aldi baterako artxiboen beharrik gabe (1. irudia).
Artxiboak bakarrik irakurri eta idazten dira datuen eta emaitzen (grafikoak...)
sarrera-irteeretarako. Funtzioak komando definitu batzuk erabiliz exekuta ditzake
erabiltzaileak. Emaitzak zuzenean pantailan ikus daitezke, objektu gisa gorde edo
diskoan idatz daitezke zuzenean (grafikoen kasuan bereziki). Emaitzak objektuak
direnez azken batean, datutzat jo eta datuak balira bezala azter ditzakegu. Datu-
artxiboak disko gogorretik zuzenean edo sarearen bitartez urrutiko zerbitzari
batetik irakur daitezke.
Eskuragarri dauden funtzio guztiak R_HOME/library liburutegian daude
gordeta (R_HOME da R instalatuta dagoen direktorioa). Direktorio horretan
funtzio-paketeak aurki ditzakegu. Pakete horiek, aldi berean, direktoriotan
egituratuta daude. Bestalde, base izeneko paketea R-ren nukleoa da. Bertan topa
daitezke datuak irakurri eta erabiltzeko lengoaiaren oinarrizko funtzioak, funtzio
grafiko batzuk eta funtzio estatistiko batzuk (erregresio-lineala eta bariantza-
analisia). Pakete bakoitzean R izeneko direktorio bat dago. Direktorio horretan
paketearen izen bera duen artxibo bat ere gordetzen da (esaterako, base paketean
R_HOME/library/base/R/base izeneko artxibo bat dago). Artxibo hori ASCII
formatoan dago eta pakete horrek dituen funtzio guztiak ditu.
12 R hasiberrientzat
Komandorik sinpleena objektu baten izena idaztea da, horrela bere edukia
ikus dezagun. Adibidez, n izeneko objektu batek 10 balioa badu:
> n
[1] 10
1 digituak adierazten du n-ren bistaratzea bere lehen elementutik hasita egiten
dela. Komando horrek print funtzioaren erabilera inplizitua du. Aurreko
adibidea print(n) komandoaren parekoa da (batzuetan print funtzioa
esplizituki erabili behar da, funtzio baten barnean edo begizta batean kasu).
Objektu baten izenak letra batekin hasi behar du (A-Z eta a-z) eta letrak,
digituak (0-9) zein puntuak (.) izan ditzake. R-k letra larrien eta xeheen artean
bereitzen du, beraz x eta X objektu ezberdinak dira (baita Windows sisteman
lanean dihardugunean ere).
2.2. OBJEKTUEN SORKUNTZA, LISTATUA ETA
DEUSEZTATZEA MEMORIAN
Objektu bat sortzeko "esleitu" eragilea erabili behar dugu. Eragile hori gezi baten
bidez adierazten da, ken ikurra eta ">" edo "<" ikurrak erabiliz, objektuaren
esleipenaren norabidearen arabera:
> n <- 15
> n
[1] 15
> 5 -> n
> n
[1] 5
> x <- 1
> X <- 10
> x
[1] 1
> X
[1] 10
Objektua jadanik memorian badago, bere balio zaharra desagertu egingo da
esleipenaren ondoren (aldaketa hori memoriako objektuetan soilik gertatzen da, eta
ez diskoko datuetan). Horrela, esleituriko balioa eragiketa baten edota funtzio
baten emaitza izan daiteke:
> n <- 10 + 2
> n
[1] 12
> n <- 3 + rnorm(1)
> n
[1] 2.208807
Zenbait kontzepturen azalpena hasi aurretik 13
rnorm(1) funtzioak ausazko datu bat sortzen du, batezbestekoa 0 eta
bariantza 1 dituen banaketa normal batean oinarrituz (25. orria). Kontuan hartu
espresio bat idatz dezakegula bere balioa inongo objekturi esleitu gabe; kasu
horretan emaitza pantailaratu egiten da, baina ez da gordetzen memorian:
> (10 + 2) * 5
[1] 60
Hemendik aurrera ez ditugu esleipenak idatziko adibideak ulertzeko
beharrezkoak ez badira.
ls funtzioak memorian dauden objektuak listatu besterik ez du egiten:
beraien izenak bakarrik erakusten ditu.
> name <- "Ainhoa"; n1 <- 10; n2 <- 100; m <- 0.5
> ls()
[1] "m" "n1" "n2" "name"
Ohartu puntu eta koma erabiltzen dela ilara berean komando ezberdinak
bereizteko. Karaktere konkretu bat duten objektuak listatu nahi badira pattern
aukera erabiltzen da (pat bezala labur daiteke):
> ls(pat = "m")
[1] "m" "name"
Zerrendan karaktere konkretu batekin hasten diren objektuak soilik
agertzeko:
> ls(pat = "^m")
[1] "m"
ls.str() funtzioak memorian dauden objektuen hainbat xehetasun
erakusten ditu:
> ls.str()
m : num 0.5
n1 : num 10
n2 : num 100
name : chr "Ainhoa"
pattern aukera era berean erabil daiteke ls.str() funtzioarekin.
Funtzio horrek eskaintzen duen beste aukera interesgarri bat max.level da.
Horren bitartez objektu konposatuen bistaratze-xehetasunak zehatz daitezke.
ls.str() funtzioak, defektuz, memoriako objektuen xehetasun guztiak
erakusten ditu, datu-esparruen ("data frames") zutabeak, matrizeak eta zerrendak
barne. Jokamolde horrek sor dezakeen informazio-piloa ekiditeko, eta beraz
xehetasun horiek guztiak ez erakusteko, max.level = -1 aukera erabil
dezakegu:
14 R hasiberrientzat
> M <- data.frame(n1, n2, m)
> ls.str(pat = "M")
M : `data.frame': 1 obs. of 3 variables:
$ n1: num 10
$ n2: num 100
$ m : num 0.5
> ls.str(pat="M", max.level=-1)
M : `data.frame': 1 obs. of 3 variables:
Memoriako objektuak ezabatzeko rm() funtzioa darabilgu: rm(x)-k x
objektua ezabatzen du, rm(x,y)-k bai x eta bai y ezabatzen ditu eta
rm(list=ls()) idatziz gero, memorian dauden objektu guztiak ezabatzen
dira; ls() funtzioarekin aipatu ditugun aukera berak erabil daitezke ezabatze
hautakor bat egiteko: rm(list=ls(pat="^m")).
2.3. LAGUNTZA
R-ren laguntzak oso informazio erabilgarria ematen du funtzioen erabileraren
inguruan. Funtzio bati buruzko laguntza zuzenean lor dezakegu. Adibidez:
> ?lm
idazten badugu, lm() funtzioaren laguntza azalduko zaigu R barruan (eredu
lineala). help(lm) edo help("lm") komandoek eragin bera dute. Azken
funtzio hori ezohiko karaktereekin laguntza eskatzen dugunean erabili behar da:
> ?*
Error: syntax error
> help("*")
Arithmetic package:base R Documentation
Arithmetic Operators
...
Laguntzari dei egindakoan, leiho edo orri bat agertzen da (sistema eragilearen
arabera). Bertan, lehen lerroan funtzioari buruzko informazio orokorra dago, fun-
tzio edo eragile hori dagoen paketea kasu. Ondoren izenburua agertuko da eta bere
atzetik, funtzioaren inguruko informazio zehatzagoa ematen duten atal batzuk.
Description: deskripzio motza.
Usage: funtzio baten kasuan, bere izena eta onartzen dituen argumentu guztiak
erakusten ditu, baita defektuzko balio posibleak ere (aukerak); eragile baten
kasuan berriz, bere erabilera tipikoa deskribatzen du.
Arguments: funtzio baten argumentu guztiak deskribatzen ditu zehatz-mehatz.
Details: xehetasunez jositako deskripzioa.
Zenbait kontzepturen azalpena hasi aurretik 15
Value: eragile edo funtzioak itzuliko lukeen objektu-mota.
See Also: antzeko funtzio edo eragileak agertzen diren laguntza-orriak.
Examples: eskuarki examples() (laguntza ireki gabe) funtzioa erabiliz exekuta
daitezkeen adibideak.
Examples atala aztertzea oso egokia da R erabiltzen hasi berri direnentzat.
Arguments atala ongi irakurtzea ere oso erabilgarria da. Laguntzan ager
daitezkeen beste atal batzuk Note (ohar gehigarriak), References (bibliografia
erabilgarria) edo Author(s) (egile(ar)en izena(k)) dira.
help funtzioak, defektuz, memorian kargatuta dauden paketeetan soilik
bilatzen du. try.all.packages aukerak (bere defektuzko balioa FALSE
(faltsua) da) eskura dauden pakete guztietan begiratzeko aukera ematen du bere
balioa TRUE (egiazkoa) jarriz gero:
> help("bs")
Error in help("bs") : No documentation for `bs' in specified
packages and libraries:
you could try `help.search("bs")'
> help("bs", try.all.packages=TRUE)
topic `bs' is not in any loaded package
but can be found in package `splines' in library
`D:/rw1041/library'
Laguntza html formatoan ikusteko (Netscape erabiliz esaterako) ondorengo
komandoa idatzi:
> help.start()
Laguntza-mota horrekin bilaketetan gako-hitzak erabil ditzakegu. See Also
atalak beste laguntza-orri batzuetara eramango gaituzten loturak ditu. Gako-hitzen
bidezko bilaketak egiteko help.search funtzioa ere erabil daiteke, baina hori
oraindik azterkizun dago (R 1.5.0).
apropos funtzioak memorian kargatuta dauden paketeetan argumentutzat
emandako hitza duten funtzio guztiak aurkitzen ditu:
> apropos(help)
[1] "help" "help.search" "help.start"
[4] "link.html.help"
16 R hasiberrientzat
3. Datuen erabilera R-n
3.1. OBJEKTUAK
R-k izena eta edukia dituzten objektuekin lan egiten duela ikusi dugu. Baina
objektuek errepresentatzen duten datu-mota zehazten duten atributuak ere
badituzte. Atributu horien erabilera ulertzeko, demagun 1, 2 edo 3 balioak har
ditzakeen aldagai bat dugula: aldagai hori zenbaki oso bat (adibidez, habi batean
dauden arrautza-kopurua) edo aldagai kategoriko bat (esaterako, oskoldun-talde
bateko banakoen sexua: arra, emea edo hermafrodita) izan daiteke.
Agerikoa da aldagai horren azterketa estatistikoaren emaitzak ez direla
berdinak izango kasu bietan: R-n objektuaren atributuek beharrezko informazio
guztia ematen digute. Oro har, eta hitz teknikoagoak erabiliz, objektu bati
aplikatzen zaion funtzio baten eragina objektuaren atributuen menpekoa da.
Objektu orok berezko bi atributu ditu: mota eta luzera. Mota erabiltzen da
adierazteko objektu horren elementuak zein oinarrizko klasetakoak diren; lau mota
dira: zenbakizkoa, karakterea, konplexua7 eta logikoa (FALSE [faltsua] edo TRUE
[egiazkoa]). Badaude bestelako mota batzuk ere, baina ez dituzte datuak
errepresentatzen (funtzioak eta espresioak, adibidez). Luzerak adierazten du
objektuak duen elementu-kopurua. Objektu baten mota eta luzera ikusteko nahikoa
da erabiltzea mode eta length funtzioak:
> x <- 1
> mode(x)
[1] "numeric"
> length(x)
[1] 1
> A <- "Gomphotherium"; compar <- TRUE; z <- 1i
> mode(A); mode(compar); mode(z)
[1] "character"
[1] "logical"
[1] "complex"
7. Dokumentu honetan ez dugu mota konplexua askotan aipatuko.
Datu bat ezin denean eskuratu, NA moduan irudikatzen da (ingelesezko `not
available'), datuaren mota edozein delarik ere. Oso handiak diren zenbakizko
datuak idazkera esponentzialean idatz daitezke:
> N <- 2.1e23
> N
[1] 2.1e+23
R-k egokiro irudikatzen ditu zenbakizko balio ez-finituak: adibidez, ± Inf
eta Inf idazten ditu, edo zenbakizkoak ez diren balioak NaN (ingelesezko `not a
number') bezala irudikatzen ditu.
> x <- 5/0
> x
[1] Inf
> exp(x)
[1] Inf
> exp(-x)
[1] 0
> x - x
[1] NaN
Karaktere motako aldagaiak komatxoen (") bidez mugatzen dira. Komatxoa
bera aldagaiaren barnean sar daiteke \ ikurra jartzen bada aurretik. Bai pantailan
bistaratzeko erabiltzen den cat funtzioak, zein artxiboetan idazteko balio duen
write.table funtzioak bi karaktereok \" batera erabil ditzakete (22. orria, ikus
funtzio horren qmethod aukera).
> cit <- "Hark esan zuen: \"Komatxoak R-ko testuetan jar
daitezke.\""
> cit
[1] "Hark esan zuen: \"Komatxoak R-ko testuetan jar
daitezke.\""
> cat(cit)
Hark esan zuen: "Komatxoak R-ko testuetan jar daitezke."
Ondorengo taulan laburtu ditugu objektu-motak eta berauek irudikatzen
dituzten datuak.
objektua motak mota bat baino gehiago
objektu berean?
bektorea
faktorea
array-a
matrizea
data.frame
ts
zerrenda
zenbakia, karakterea, konplexua edo logikoa
zenbakia edo karakterea
zenbakia, karakterea, konplexua edo logikoa
zenbakia, karakterea, konplexua edo logikoa
zenbakia, karakterea, konplexua edo logikoa
zenbakia, karakterea, konplexua edo logikoa
zenbakia, karakterea, konplexua, logikoa,
funtzioa, espresioa, ...
Ez
Ez
Ez
Ez
Bai
Bai
Bai
18 R hasiberrientzat
Bektorea aldagai bat da, bere esanahirik ohikoenean. Faktorea aldagai
kategoriko bat da. Array bat k dimentsioko taula bat da eta matrizea, berriz, k = 2
duen array bat besterik ez da. Ohartu array edo matrize batean elementu guztiak mo-
ta berekoak direla. `data.frame' bat (datu-base edo datu-esparrua) luzera berekoak
baina mota ezberdinekoak izan daitezkeen bektore edota faktore bat edo gehiagoz
osaturiko taula bat da. `ts' bat denbora-segida bat da eta beraz, atributu gehigarriak
ditu hala nola data eta maiztasuna. Azkenik, zerrenda batek edozein motatako
objektuak izan ditzake, zerrendak ere barne!
3.2. ARTXIBO BATETIK DATUAK IRAKURRI
R-k lan-direktorioa darabil artxiboak irakurri zein idazteko. Direktorio hori zein
den jakiteko, getwd() (get working directory) komandoa erabil daiteke. Lan-
direktorioa aldatzeko setwd() funtzioa darabilgu; adibidez,
setwd("C:/data") edo setwd("/home/paradis/R"). Nahitaezkoa da
artxiboaren helbide (`path') osoa idaztea artxiboa lan-direktorioan ez badago8.
R-k testu-artxibo (ASCII) gisa gordetako datuak irakur ditzake ondoko
funtzioekin: read.table (bere aldaerekin, ikus beherago), scan eta
read.fwf. Beste formatu batzuetan dauden artxiboak ere irakur ditzake R-k
(Excel, SAS, SPSS...), baita SQL datu-baseak atzitu ere. Hala ere, horretarako
behar diren funtzioak ez daude base paketean. Erabiltzaile aurreratuentzat
funtzionalitate hori oso erabilgarria den arren, gu ASCII formatuan dauden
artxiboak irakurtzeko funtzioetara mugatuko gara.
read.table funtzioak datu-esparru (`data.frame') bat sortzen du eta berau
da datuak era tabulatu batean irakurtzeko aukerarik onena. Adibidez, data.dat
izeneko artxibo bat badugu:
> niredatuak <- read.table("data.dat")
komandoa idatziz gero, niredatuak izeneko datu-esparru bat sortuko da eta
aldagai bakoitzak V1, V2,... izena hartuko du defektuz. Aldagai horiek
niredatuak$V1, niredatuak$V2... edo niredatuak["V1"],
niredatuak["V2"]... edo baita niredatuak[,1],
niredatuak[,2]...9 idatzita banan-banan atzi daitezke. Ondorengo taulan
defektuzko balioak dituzten hainbat aukera (R-k darabiltzanak erabiltzaileak ezer
adierazten ez badio) ikus daitezke:
Datuen erabilera R-n 19
8. Windows-en, erabilgarria da Rgui.exe izeneko aliasa sortzea, bere propietateak editatzea eta
direktorioa aldatzea "Comenzar en:" eremuan "Alias" gingilaren azpian: hori izango da hortik aurrera
lan-direktorio berria R alias hori erabiliz exekutatuz gero.
9. Bada ezberdintasun bat: niredatuak$V1 eta niredatuak[,1] bektoreak dira eta
niredatuak["V1"], aldiz, datu-esparru bat. Aurrerago ikusiko ditugu objektuak erabiltzeko
xehetasun gehiago (17. orria).
read.table(file, header = FALSE, sep = "", quote = "\"'", dec
= ".", row.names, col.names, as.is = FALSE,
na.strings = "NA", colClasses = NA, nrows = -1,
skip = 0, check.names = TRUE, fill =
!blank.lines.skip,
strip.white = FALSE, blank.lines.skip = TRUE,
comment.char = "#")
read.table-en aldaerak interesgarriak dira, defektuzko aukera ezberdinak
baitituzte:
read.csv(file, header = TRUE, sep = ",", quote="\"", dec=".",
fill = TRUE, ...)
read.csv2(file, header = TRUE, sep = ";", quote="\"",
dec=",",
fill = TRUE, ...)
read.delim(file, header = TRUE, sep = "\t", quote="\"",
dec=".",
fill = TRUE, ...)
read.delim2(file, header = TRUE, sep = "\t", quote="\"",
dec=",",
fill = TRUE, ...)
file artxiboaren izena ("" artean edo karaktere motako aldagai gisa), ziur aski bere
helbidearekin lan-direktorioan ez badago (\ ikurra onartzen ez denez / ikurra erabili
behar da, Windowsen ere), edo artxiborantz daraman helbide arrotz batekin, URL
(http://...) erako zerbait
header artxiboak aldagaien izenak lehen ilaran dituenentz zehazten duen aldagai logikoa
(FALSE edo TRUE)
sep artxiboan eremu-bereizle gisa erabiltzen den bereizlea; adibidez, sep="\t"
tabulazio bat bada
quote aldagaiak karaktere moduan aipatzeko erabili behar diren karaktereak
dec puntu dezimala irudikatzeko erabili behar den karakterea
row.names karaktere edo zenbaki motako izenak dituzten ilarez osaturiko bektorea (defektuz:
1, 2, 3, ...)
col.names aldagaien izenak agertzen diren bektorea (defektuz: V1, V2, V3, ...)
as.is karaktere motako aldagaiak faktore bihurtzea kontrolatzen du (FALSE bada) edo
karaktere gisa mantentzen ditu (TRUE bada); as.is karaktere gisa mantendu
behar diren aldagaiak markatzen dituen bektore logiko edo zenbakizkoa izan
daiteke
na.strings eskura ez dauden balioak kodetzeko darabilgun balioa (NA defektuz)
colClasses zutabeentzat klaseak sortzen dituen karaktere-bektore bat
nrows irakurri behar den ilara-kopuru maximoa (balio negatiboak ez dira kontuan
hartzen)
skip datuak irakurri aurretik kontuan hartu ez diren ilaren kopurua
check.names TRUE bada, aldagaien izenak R-rentzat egokiak diren aztertzen du
fill TRUE bada eta ilara guztiek aldagai-kopuru bera ez badute, "zuriuneak" gehitzen
ditu
strip.white (sep-en menpe) TRUE bada, soberan dagoen espazioa ezabatzen du karaktere
motako aldagaien aurretik eta ondoren
blank.lines.skip TRUE bada, zuriz dauden ilarak ez ditu kontuan hartzen
comment.char datu-artxiboan iruzkinak definitzen dituen karakterea; karaktere horrekin hasten
diren ilarak ez dira kontuan hartuko irakurketan (aukera hori baliogabetzeko
comment.char ="" idatzi)
20 R hasiberrientzat
scan funtzioa read.table baino malguagoa da. Azken horretan ez
bezala, aldagaien mota zehaztea posible da:
> niredatuak <- scan("data.dat", what = list("", 0, 0))
Adibide horretan, scan-ek data.dat artxiboko hiru aldagai irakurtzen ditu;
lehena karaktere bat da eta hurrengo biak zenbakizkoak. Bada aipatzeko moduko
beste ezberdintasun bat: scan() funtzioak bektore, matrize, datu-esparru,
zerrenda... moduko objektuak sor ditzake. Aurreko adibidean niredatuak hiru
bektorez osaturiko zerrenda bat da. Defektuz, hots, what argumentua baztertzen
bada, scan() funtzioak zenbakizko bektore bat sortzen du. Irakurritako datuak ez
badatoz espero z(ir)en mot(ar)ekin bat (bai defektuz zein what erabiliz zehaztuta),
errore-mezu bat igortzen da. Aukerak ondoren zehazten ditugu:
scan(file = "", what = double(0), nmax = -1, n = -1, sep = "",
quote = if (sep=="\n") "" else "'\"", dec = ".", skip =
0, nlines = 0, na.strings = "NA",flush = FALSE, fill =
FALSE, strip.white = FALSE, quiet = FALSE,
blank.lines.skip = TRUE, multi.line = TRUE,
comment.char = "#")
read.fwf funtzioa formatu finko zabalean dauden artxiboak irakurtzeko erabil
daiteke:
read.fwf(file, widths, sep="\t", as.is = FALSE,
skip = 0, row.names, col.names, n = -1)
file artxiboaren izena ("" artean), ziur aski bere helbidearekin lan-direktorioan ez
badago (\ ikurra onartzen ez denez / ikurra erabili behar da, Windowsen ere) edo
artxiborantz daraman helbide arrotz batekin, URL (http://...) erako zerbait; file
="" bada, datuak teklatutik sartu behar dira (sarrera ilara zuri batekin amaitzen da)
what datuak zein motatakoak diren zehazten du (defektuz, zenbakizkoa)
nmax irakurri behar diren datuen kopuru maximoa, edo what zerrenda motakoa bada,
irakurri behar diren ilaren kopuru maximoa (defektuz, scan-ek amaiera-marka
topatu arte datu guztiak irakurtzen ditu)
n irakurtzeko dauden datuen kopurua (defektuz ez dago mugarik)
sep artxiboan erabiltzen den eremu bereizlea
quote karaktere motako aldagaiak adierazteko erabiltzen den karakterea
dec puntu dezimala irudikatzeko erabili behar den karakterea
skip datuak irakurri aurretik kontuan hartu ez diren ilaren kopurua
nlines irakurri behar den ilara-kopurua
na.string eskura ez dauden balioak kodetzeko darabilgun balioa (NA defektuz)
flush TRUE bada, scan hurrengo ilarara joango da zutabe guztiak irakurri ondoren
(erabiltzaileak iruzkinak gehi ditzake datu-artxiboan)
fill TRUE bada eta ilara guztiek aldagai-kopuru bera ez badute, "zuriuneak" gehitzen
ditu
strip.white (sep-en menpe) TRUE bada, soberan dagoen espazioa ezabatzen du karaktere
motako aldagaien aurretik eta ondoren
quiet FALSE bada, scan-ek irakurri diren eremuak erakusten ditu ilara batean
blank.lines.skip TRUE bada, zuriz dauden ilarak ez ditu kontuan hartzen
multi.line what zerrenda bat bada, artxiboan banako baten aldagaiak ilara bakar batean
dauden adierazten du (FALSE)
comment.char datu-artxiboan iruzkinak definitzen dituen karaktera; karaktere horrekin hasten
diren ilarak ez dira kontuan hartuko irakurketan
Datuen erabilera R-n 21
Eremuen zabalera zehazten duen widths aukera izan ezik, beste
guztiak read.table() funtzioarenak berak dira. Adibidez,
datuak.txt izeneko artxibo batek eskuinean erakusten ditugun datuak
baditu, ondoko komandoarekin irakur daiteke:
> niredatuak <- read.fwf("datuak.txt", widths=c(1, 4, 3))
> niredatuak
V1 V2 V3
1 A 1.50 1.2
2 A 1.55 1.3
3 B 1.60 1.4
4 B 1.65 1.5
5 C 1.70 1.6
6 C 1.75 1.7
3.3. DATUAK GORDE
write.table funtzioak objektu baten edukia artxibo batean gordetzen du.
Objektua, eskuarki, datu-esparru bat da (`data.frame'), baina beste edozein
motatakoa ere izan daiteke (bektorea, matrizea...). Argumentuak eta aukerak
honokoak dira:
write.table(x, file = "", append = FALSE, quote = TRUE, sep = " ",
eol = "\n", na = "NA", dec = ".", row.names = TRUE,
col.names = TRUE, qmethod = c("escape", "double"))
Objektu baten edukia artxibo batean gordetzeko era erraz bat write(x,
file="data.txt") erabiltzea da. Bertan, x, objektuaren izena da (bektorea,
matrizea edo array bat izan daiteke). Funtzio horrek bi aukera ditu: nc (edo ncol)
aukerak artxiboan dagoen zutabe-kopurua definitzen du (defektuz, nc=1 da, x
x esportatu behar den objektuaren izena
file artxiboaren izena (defektuz objektua pantailan azaltzen da)
append TRUE bada, datuak artxibora gehitzen ditu aurretik zeuden datuak zanpatu gabe
quote bektore logiko edo zenbakizkoa: TRUE bada, karaktere eta faktore motako aldagaiak ""
artean idazten ditu; bestela, zenbakizko bektoreak "" artean idatzi beharreko aldagaien
kopurua adierazten du (bi kasuetan aldagaien izenak "" artean idazten dira, baina ez
quote=FALSE bada)
sep artxiboan erabiltzen den eremu bereizlea
eol ilara amaiera adierazten duen karakterea ("\n" `itzulera' da)
na falta diren datuentzat erabili behar den karakterea
dec puntu dezimala irudikatzeko erabili behar den karakterea
row.names artxiboan ilaren izenak idatzi behar diren adierazten duen aukera logikoa
col.names zutabeen izenentzat identifikatzailea
qmethod quote=TRUE bada, komatxo bikoitzak tratatu behar diren era zehazten du karaktere
motako aldagaietan: "escape" (edo "e", defektuz) bada, " bakoitza \" batez ordezkatzen
da; "d" bada, " bakoitza ""-rekin ordezkatzen da
22 R hasiberrientzat
A1.501.2
A1.551.3
B1.601.4
B1.651.5
C1.701.6
C1.751.7
karaktere motakoa bada, eta nc=5 bestela), eta append (logikoa) aukerak, berriz,
artxiboan datuak gehitzen ditu bertan zeuden datuak zanpatu gabe (TRUE) edo
denak ezabatzen ditu (FALSE, defektuzko balioa).
Edozein motatako objektu-multzo bat gordetzeko save(x, y, z,
file="xyz.RData") komandoa erabil daiteke. Makina ezberdinen arteko
datu-transferentzia errazteko ascii = TRUE aukera erabilgarria da. Datuak (R-
ren terminologian workspace edo "lan-espazioa" izenpean) beranduago karga
daitezke memorian load("xyz.RData") komandoa idatziz. Bestalde, aipatu
baita ere save.image() funtzioa save(list=ls(all=TRUE),
file=".RData") komandoa idazteko modu motzagoa dela (memoriako
objektu guztiak .RData artxiboan gordetzen ditu).
3.4. DATUAK SORTU
3.4.1. Sekuentzia erregularrak
Zenbaki osoen sekuentzia erregular bat, 1etik 30era esaterako, ondorengo
eran sor daiteke:
> x <- 1:30
Sortu dugun x bektoreak 30 elementu ditu. Espresio batean, `:' eragileak beste
eragile aritmetikoekiko lehentasuna du:
> 1:10-1
[1] 0 1 2 3 4 5 6 7 8 9
> 1:(10-1)
[1] 1 2 3 4 5 6 7 8 9
seq funtzioak zenbaki errealen sekuentziak sor ditzake:
> seq(1, 5, 0.5)
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
bertan, lehen zenbakiak sekuentziaren hasiera zehazten du, bigarrenak amaiera eta
hirugarrenak sekuentziak izan behar duen hazkundea. Ondorengoa ere erabil
daiteke:
> seq(length=9, from=1, to=5)
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
Balioak zuzenean ere idatz daitezke c funtzioa erabilita:
> c(1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5)
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
Datuen erabilera R-n 23
Nahi izanez gero, balioak zuzenean teklatutik sar daitezke. Horretarako scan
funtzioa erabili behar da, aukerak alde batera utzita:
> z <- scan()
1: 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
10:
Read 9 items
> z
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
rep funtzioak elementu berdin-berdinak dituen bektore bat sortzen du:
> rep(1, 30)
[1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
sequence funtzioak zenbaki osoen sekuentzia-segida bat sortzen du. Ber-
tan, sekuentzia bakoitzak argumentu gisa zehaztutako zenbakia(k) d(it)u amaieran.
> sequence(4:5)
[1] 1 2 3 4 1 2 3 4 5
> sequence(c(10,5))
[1] 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5
gl funtzioa (maila-sortzailea) oso erabilgarria da, faktoreen segida
erregularrak sortzen baititu. Funtzioak gl(k, n) forma du; bertan, k maila-
zenbakia (edo klase-zenbakia) da eta n maila bakoitzean nahi dugun kopia-
kopurua. Bi aukera ditu funtzioak: length aukerak sortu behar den datu-kopurua
zehazten du eta labels faktoreen izenak zehazteko erabiltzen da. Adibideak:
> gl(3, 5)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
Levels: 1 2 3
> gl(3, 5, length=30)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 1 1 1 1 1 2 2 2 2 2 3 3 3 3
3
Levels: 1 2 3
> gl(2, 6, label=c("Arra", "Emea"))
[1] Arra Arra Arra Arra Arra Arra
[7] Emea Emea Emea Emea Emea Emea
Levels: Arra Emea
> gl(2, 10)
[1] 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2
Levels: 1 2
> gl(2, 1, length=20)
[1] 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2
Levels: 1 2
> gl(2, 2, length=20)
[1] 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
Levels: 1 2
24 R hasiberrientzat
Azkenik, expand.grid() funtzioak argumentu gisa emaniko bektoreen
edo faktoreen konbinazio posible guztiak dituen datu-esparru bat sortzen du:
> expand.grid(a=c(60,80), p=c(100, 300), sexua=c("Arra",
"Emea"))
a p sexua
1 60 100 Arra
2 80 100 Arra
3 60 300 Arra
4 80 300 Arra
5 60 100 Emea
6 80 100 Emea
7 60 300 Emea
8 80 300 Emea
3.4.2. Ausazko sekuentziak
Ausazko datuak sortzeko aukera oso interesgarria da estatistikan eta R-k
horretarako gaitasuna du funtzio eta banaketa askorentzat. Funtzio horiek
rfunc(n, p1, p2, ...) forma izan ohi dute; bertan, func-ek banaketa
adierazten du, n sortu nahi dugun datu-kopurua da eta p1, p2... banaketaren
parametroek hartuko dituzten balioak dira. Aurreko taulan banaketa bakoitzaren
xehetasunak agertzen dira, baita parametroek dituzten defektuzko balioak ere
(azaltzen ez bada, parametroa erabiltzaileak zehaztu behar duela adierazi nahi da).
Funtzio horiek guztiak r letra d, p edo q letrez ordezkatuta erabil daitezke.
Horrela, probabilitate-dentsitatea (dfunc(x, ...)), metatutako probabilitate-
dentsitatea (pfunc(x, ...)) eta kuartilaren balioa (qfunc(p, ...), 0
kalkula daitezke oso era errazean.
Banaketa/funtzioa Funtzioa
Gauss (normala) rnorm(n, mean=0, sd=1)
esponentziala rexp(n, rate=1)
gamma rgamma(n, shape, scale=1)
Poisson rpois(n, lambda)
Weibull rweibull(n, shape, scale=1)
Cauchy rcauchy(n, location=0, scale=1)
beta rbeta(n, shape1, shape2)
`Student' (t) rt(n, df)
FisherSnedecor (F) rf(n, df1, df2)
Pearson (2) rchisq(n, df)
binomiala rbinom(n, size, prob)
geometrikoa rgeom(n, prob)
hipergeometrikoa rhyper(nn, m, n, k)
logistikoa rlogis(n, location=0, scale=1)
lognormala rlnorm(n, meanlog=0, sdlog=1)
binomial negatiboa rnbinom(n, size, prob)
uniformea runif(n, min=0, max=1)
Wilcoxon-en estatistikoa rwilcox(nn, m, n), rsignrank(nn, n)
Datuen erabilera R-n 25
3.5. OBJEKTUEN ERABILERA
3.5.1. Objektuak sortu
Aurreko ataletan esleitu eragilea erabiliz objektuak sortzeko era batzuk ikusi
ditugu; era horretara sortutako objektuen mota eta klasea, oro har, era inplizitu
batean finkatzen dira. Hala ere, posible da objektu bat sortzea bere klase, mota,
luzera, etab. zehaztuz. Hurbilketa hori oso interesgarria da objektuen erabileraren
ikuspuntutik. Adibidez, objektu `huts' bat sor daiteke eta ondoren bere elementuak
banan-banan alda daitezke; hori c() funtzioa erabiliz balio guztiak batera kokatzea
baino askoz eraginkorragoa izan daiteke. Baldintza horietan sistema indexatua
erabil daiteke, aurrerago ikusiko dugun bezala (33. orria).
Jadanik sorturik dauden objektuetan oinarrituta beste objektu berri batzuk
sortzea ere oso interesgarria izan daiteke. Adibidez, ereduen segida bat egokitu
nahi bada, formulak zerrenda batean sartu eta ondoren banan-banan atera
ditzakegu lm funtzio batean sartzeko.
R-ren ikaskuntza fase honetan, honako funtzio hauek ikusteak balio praktikoa
ez ezik, didaktikoa ere badu. Objektu baten sorrera esplizituak bere egitura hobeto
ulertzea dakarkigu eta aldez aurretik aipatutako ideietan sakontzen lagun diezaguke.
Bektorea. vector funtzioak (mode eta length argumentuak ditu) zenbaki,
logiko edo karaktere motako elementuak dituen bektore bat sortzen du, mode
argumentuaren balioaren arabera (0, FALSE edo "" hurrenez hurren).
Ondorengo funtzioek gauza bera egiten dute, baina argumentu bakarrarekin
(bektorearen luzera): numeric(), logical() eta character().
Faktorea. Faktore batek aldagai kategoriko baten balioak ez ezik, aldagai horren
maila posibleak ere gordetzen ditu (baita datuetan agertzen badira ere).
factor funtzioak hurrengo aukerak dituen faktore bat sortzen du:
factor(x, levels = sort(unique(x), na.last = TRUE),
labels = levels, exclude = NA, ordered =
is.ordered(x))
levels-ek faktorearen maila posibleak zehazten ditu (defektuz, x-ren balio
bakarrak), labels-ek mailen izenak definitzen ditu, exclude-k maila
bakoitzetik kanporatu beharreko x balioak zein diren zehazten du eta
ordered faktorearen mailak ordenaturik daudenetz adierazten digun argu-
mentu logiko bat da. Gogoan izan x dela zenbaki edo karaktere motakoa.
Adibideak:
26 R hasiberrientzat
> factor(1:3)
[1] 1 2 3
Levels: 1 2 3
> factor(1:3, levels=1:5)
[1] 1 2 3
Levels: 1 2 3 4 5
> factor(1:3, labels=c("A", "B", "C"))
[1] A B C
Levels: A B C
> factor(1:5, exclude=4)
[1] 1 2 3 NA 5
Levels: 1 2 3 5
levels funtzioak faktore baten maila posibleak ateratzen ditu:
> ff <- factor(c(2, 4), levels=2:5)
> ff
[1] 2 4
Levels: 2 3 4 5
> levels(ff)
[1] "2" "3" "4" "5"
Matrizea. Matrize bat, azken batean, atributu gehigarri bat (dim) duen bektorea
besterik ez da. Atributu hori, aldi berean, 2 luzerako zenbakizko bektore bat
da eta matrizearen errenkada- eta zutabe-kopurua definitzen du. Matrize bat
matrix funtzioa erabiliz sor daiteke:
matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE,
dimnames = NULL)
byrow aukerak adierazten du ea data-n dauden balioek zutabeak (defektuz)
edo errenkadak (TRUE bada) bete behar dituzten. dimnames aukerak,
berriz, errenkada eta zutabeei izenak jartzeko aukera ematen digu.
> matrix(data=5, nr=2, nc=2)
[,1] [,2]
[1,] 5 5
[2,] 5 5
> matrix(1:6, 2, 3)
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> matrix(1:6, 2, 3, byrow=TRUE)
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
Datuen erabilera R-n 27
dim atributuari balio egokiak emanez matrize bat sortzeko beste era bat dugu
(hasiera batean NULL balioa du):
> x <- 1:15
> x
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
> dim(x)
NULL
> dim(x) <- c(5, 3)
> x
[,1] [,2] [,3]
[1,] 1 6 11
[2,] 2 7 12
[3,] 3 8 13
[4,] 4 9 14
[5,] 5 10 15
Datu-esparrua. Jada ikusi dugu read.table funtzioarekin datu-esparru
(`data.frame') bat sortzen dela era inplizituan; data.frame funtzioarekin
ere gauza bera egin dezakegu. Argumentu gisa jarritako bektoreek luzera bera
izan behar dute, edo baten bat besteak baino motzagoa bada, hainbat aldiz
"birziklatzen" da:
> x <- 1:4; n <- 10; M <- c(10, 35); y <- 2:4
> data.frame(x, n)
x n
1 1 10
2 2 10
3 3 10
4 4 10
> data.frame(x, M)
x M
1 1 10
2 2 35
3 3 10
4 4 35
> data.frame(x, y)
Error in data.frame(x, y) :
arguments imply differing number of rows: 4, 3
Datu-esparruan faktore bat sartu nahi bada, bektore(ar)en luzera bera izan
behar du. Zutabeen izenak aldatzea posible da data.frame(A1=x,
A2=n) idatziz. Errenkaden izenak ere zehatz daitezke row.names
aukerarekin. Hori, noski, datu-esparruak dituen errenkada adinako luzera
duen karaktere motako bektore bat izango da. Azkenik, kontuan izan datu-
esparruek matrizeen dim atributuaren antzeko atributu bat dutela.
28 R hasiberrientzat
Zerrenda. Zerrenda bat datu-esparru baten antzera sortzen da, list funtzioa
erabiliz. Edozein objektu-mota sar daiteke zerrendetan. data.frame()
funtzioarekin ez bezala, objektuen izenak ez dira defektuz hartzen; aurreko
adibidetik x eta y bektoreak hartuko ditugu:
> L1 <- list(x, y); L2 <- list(A=x, B=y)
> L1
[[1]]
[1] 1 2 3 4
[[2]]
[1] 2 3 4
> L2
$A
[1] 1 2 3 4
$B
[1] 2 3 4
> names(L1)
NULL
> names(L2)
[1] "A" "B"
Denbora-segidak. ts funtzioak "ts" motako (denbora-segida) objektu bat
sortzen du, bektore batean (aldagai bakarreko denbora-segida) edo matrize
batean (aldagai anitzeko segida) oinarrituta. Era honetako objektu batek
dituen aukerak ondorengoak dira:
ts(data = NA, start = 1, end = numeric(0), frequency = 1,
deltat = 1, ts.eps = getOption("ts.eps"), class, names)
data bektore edo matrize bat
start lehen behaketaren denbora, zeina zenbaki bat zein bi
osokoz osaturiko bektore bat izan daitekeen (ikus beheko
adibidea)
end azken behaketaren denbora. start bezalaxe zehazten
da
frecuency denbora unitateko eginiko behaketa-kopurua
deltat ondoz-ondoko behaketen arteko laginketa-denboraren
alderantzizkoa (adb. 1/12 hileko datuetarako); deltat
ala frecuency zehaztu behar da soilik
ts.eps segidak konparatzeko erabili behar den tolerantzia.
Maiztasunak berdintzat hartzen dira, beraien arteko
kendura ts.eps baino txikiagoa bada
class objektuari esleitu behar zaion klasea; oro har, "ts"
izango da aldagai bakarreko denbora-segida bada eta
c("mts", "ts") aldagai anitzeko segida bada
Datuen erabilera R-n 29
names aldagai anitzeko segida baten kasuan, segida bakoitzaren
izenak dituen karaktere motako bektore bat; defektuz,
data-ren zutabeen izenak, edo Serie1, Serie2,...
ts() funtzioarekin sortutako denbora-segida batzuen adibideak:
> ts(1:10, start = 1959)
Time Series:
Start = 1959
End = 1968
Frequency = 1
[1] 1 2 3 4 5 6 7 8 9 10
> ts(1:47, frequency = 12, start = c(1959, 2))
Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
1959 1 2 3 4 5 6 7 8 9 10 11
1960 12 13 14 15 16 17 18 19 20 21 22 23
1961 24 25 26 27 28 29 30 31 32 33 34 35
1962 36 37 38 39 40 41 42 43 44 45 46 47
> ts(1:10, frequency = 4, start = c(1959, 2))
Qtr1 Qtr2 Qtr3 Qtr4
1959 1 2 3
1960 4 5 6 7
1961 8 9 10
> ts(matrix(rpois(36, 5), 12, 3), start=c(1961, 1),
frequency=12)
Series 1 Series 2 Series 3
Jan 1961 8 5 4
Feb 1961 6 6 9
Mar 1961 2 3 3
Apr 1961 8 5 4
May 1961 4 9 3
Jun 1961 4 6 13
Jul 1961 4 2 6
Aug 1961 11 6 4
Sep 1961 6 5 7
Oct 1961 6 5 7
Nov 1961 5 5 7
Dec 1961 8 5 2
Espresioa. Espresio motako objektuek garrantzia handia dute R-n. Espresio bat
R-k ulertzen duen karaktere segida bat da. Komando baliagarri bakoitza
espresio bat da. Komando bat teklatuan idazten denean, R-k ebaluatu eta
baliagarria bada, exekutatu egiten du. Ebaluatu gabeko espresioak sortzea
oso erabilgarria izan daiteke askotan: horixe bera egiten du expression
funtzioak. Noski, posible da espresio hori ondoren ebaluatzea eval()
funtzioarekin.
30 R hasiberrientzat
> x <- 3; y <- 2.5; z <- 1
> exp1 <- expression(x / (y + exp(z)))
> exp1
expression(x/(y + exp(z)))
> eval(exp1)
[1] 0.5749019
Espresioak, esaterako, grafikoetan ekuazioak sartzeko erabil daitezke (47.
orria). Espresio bat karaktere motako aldagai batean oinarrituz sor daiteke.
Funtzio batzuek espresioak darabiltzate argumentutzat; adibidez, deribatu
partzialak kalkulatzen dituen D() funtzioa:
> D(exp1, "x")
1/(y + exp(z))
> D(exp1, "y")
-x/(y + exp(z))^2
> D(exp1, "z")
-x * exp(z)/(y + exp(z))^2
3.5.2. Objektuen bihurketa
Irakurlea honezkero ohartu da objektu batzuen arteko ezberdintasuna oso
txikia dela; beraz, objektu baten mota aldatzea nahiko erraza izan beharko
litzateke, esaterako, atributu batzuk aldatuta. Bihurketa horiek as.zerbait
funtzioen bidez egin daitezke. R-k (1.5.1 bertsioa) mota honetako 77 funtzio ditu
base paketean, beraz, ez dugu askoz gehiago landuko gai hau.
Bihurketa horren emaitza, noski, bihurtu dugun objektuaren atributuen menpe
dago. Bihurketek, eskuarki, oso arau intuitiboak erabiltzen dituzte. Hurrengo taulak
moten bihurketak jasotzen ditu.
Bihurketa Funtzioa Arauak
Zenbakizko motara as.numeric FALSE 0
TRUE 1
"1", "2",... "1", "2", ...
"A", ... NA
Mota logikora as.logic 0 FALSE
beste zenbakiak TRUE
"FALSE", "F" FALSE
"TRUE", "T" TRUE
beste karaktereak NA
Karaktere motara as.character 1, 2, ... "1", "2", ...
FALSE "FALSE"
TRUE "TRUE"
Datuen erabilera R-n 31
Klase ezberdineko objektuen arteko bihurketak egiten dituzten funtzioak ere
badaude (as.matrix, as.data.frame, as.ts, as.expression...).
Funtzio horiek, mota ez ezik beste atributu batzuk ere alda ditzakete bihurketa
gauzatzean. Beste behin, bihurketaren emaitzak intuitiboak dira oro har. Faktoreak
zenbakizko balio bihurtzea, adibidez, ohiko eragiketa bat da. Kasu horretan, R-k
faktorearen mailen zenbakizko kodifikazioa darabil (eta ez faktorearen beraren
balio literalak) bihurketa egiteko:
> fac <- factor(c(1, 10))
> fac
[1] 1 10
Levels: 1 10
> as.numeric(fac)
[1] 1 2
Bihurketa egitean faktorearen balio literalak mantentzea nahi bada, lehenbizi
faktorea karakterera bihurtu behar da, eta ondoren zenbakizkora.
> as.numeric(as.character(fac))
[1] 1 10
Jokabide hori oso erabilgarria izan daiteke artxibo batean balio ez-zenba-
kizkoak dituen zenbakizko aldagai bat badugu. Lehenago ikusi dugun bezala,
read.table() funtzioak, defektuz, zutabea faktore bezala irakurriko du.
3.5.3. Eragileak
Jada esan dugun bezala, R-n10 hiru motatako eragileak daude. Hona hemen
zerrenda.
Konparaziozko eragileek eta eragile aritmetikoek bi elementurekin egiten
dute lan (x+y, a
dute eragina, baina baita aldagai logikoetan ere; kasu horretan, balio logikoak zen-
bakizko baliotzat hartzen dira. Konparaziozko eragileak, berriz, edozein motatako
aldagaietan aplika daitezke eta balio logiko bat edo gehiago itzuliko dizkigute.
Eragileak
Aritmetikoak Konparaziozkoak Logikoak
+ batuketa
- kenketa
* biderketa
/ zatiketa
^ potentzia
% % modulua
%/% osoen zatiketa
< txikiagoa
> handiagoa
<= txikiagoa edo berdin
>= handiagoa edo berdin
== berdin
!= ezberdin
!x EZ logikoa
x&y ETA logikoa
x&&y ETA logikoa
x|y EDO logikoa
x || y EDO logikoa
xor(x, y) EDO esklusiboa
32 R hasiberrientzat
10. Karaktere hauek ere eragileak dira R-n: $, [, [[, :, ?, <-.
Eragile logikoek objektu logiko batean (!) edo bitan eragin dezakete eta balio
logiko bat edo gehiago itzul ditzakete. "ETA" eta "EDO" eragileak bi formatan
aurkezten dira: alde batetik, forma sinplea, non eragileak objektuaren elementu
guztiak konparatzen dituen eta egin dituen konparazioak adina balio logiko
itzultzen dituen. Bestetik forma bikoitza dugu; hor, eragileak objektuen lehen
elementuak bakarrik konparatuko ditu.
0
erabiltzea. Aurreko ezberdintza horrela idatziko genuke R-n: 0
0
eragileak mota berdinekoak direnez, ezkerretik eskuinera hurrenez hurren
exekutatuko baitira. Lehendabizi 0
1ekin konparatuko du (TRUE edo FALSE <1): kasu horretan, balio logikoa
zenbakizko balio bihurtuko da inplizituki (1 edo 0 <1).
Konparaziozko eragileek eragigaitzat dituzten objektuen elementu guztiak
konparatzen dituzte (txikienen balioak birziklatuz behar izanez gero) eta tamaina
bereko objektu bat itzultzen dute. Bi objektu "guztiz" konparatu ahal izateko,
identical funtzioa erabili behar da nahitaez:
> x <- 1:3; y <- 1:3
> x == y
[1] TRUE TRUE TRUE
> identical(x, y)
[1] TRUE
3.5.4. Objektu baten balioak atzitu: sistema indexatua
Sistema indexatua objektu baten elementuak nahi bezala atzitzeko era malgu
eta eraginkorra da. Adibidez, x bektore baten hirugarren elementua atzitu nahi
badugu, x[3] idatzi besterik ez dugu. x matrize edo datu-esparru bat bada, i.
errenkada eta j. zutabea atzitzeko x[i, j] idaztea nahikoa da. Hirugarren
zutabeko balio guztiak aldatzeko, berriz:
> x[, 3] <- 10.2
Errenkada adierazten ez dugunean, guztiak hartzen ditugu. Sistema indexatua
bi dimentsio baino gehiagoko matrizeentzat oso erraz heda daiteke (esaterako hiru
dimentsioko matrize bat: x[i, j, k], x[, , 3], ...). Ez ahaztu indexazioa
egiteko kortxete errektangeluarrak erabili behar direla eta parentesiak funtzio baten
argumentuak zehazteko ditugula:
> x(1)
Error: couldn't find function "x"
Datuen erabilera R-n 33
Indexazioa errenkada edo zutabe bat edo gehiago ezabatzeko erabil daiteke.
Adibidez, x[-1, ] komandoak lehen errenkada ezabatzen du, eta x[-c(1,
15), ] komandoak gauza bera egingo du lehen eta hamabosgarren errenkadekin.
Bektore, matrize edo array baten balioak atzitzeko, konparaziozko espresio
bat erabil daiteke indize gisa:
> x <- 1:10
> x[x >= 5] <- 20
> x
[1] 1 2 3 4 20 20 20 20 20 20
> x[x == 1] <- 25
> x
[1] 25 2 3 4 20 20 20 20 20 20
Indexazio logikoaren aplikazio praktiko bat ondorengoa da: demagun osoen
bektore baten zenbaki bikoitiak soilik aukeratu nahi ditugula:
> x <- rpois(40, lambda=5)
> x
[1] 5 9 4 7 7 6 4 5 11 3 5 7 1 5 3 9 2 2 5 2
[21] 4 6 6 5 4 5 3 4 3 3 3 7 7 3 8 1 4 2 1 4
> x[x %% 2 == 0]
[1] 4 6 4 2 2 2 4 6 6 4 4 8 4 2 4
Beraz, sistema indexatuak konparaziozko eragileek itzulitako balioak
darabiltza. Balio horiek lehenago kalkula daitezke eta behar izanez gero, birziklatu
ere egin daitezke:
> x <- 1:40
> s <- c(FALSE, TRUE)
> x[s]
[1] 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40
Aurreko kasuan, x bektoreari s baldintza aplikatu diogunez, lehen elementua
ez da aukeratzen (FALSE), bigarrena bai (TRUE), hirugarrena ez (FALSE), etab.
Hori, hautazko indexazioa egiteko era trinko eta boteretsu bat da, begiztarik erabili
gabe.
Indexazio logikoa datu-esparruekin ere erabil daiteke, hori bai, esparruaren
zutabe bakoitza mota ezberdinekoa izateak gehitzen duen zailtasuna kontuan hartu
behar da.
Zerrendetan, berriz, elementuak atzitzea oso erraza da (elementuak edozein
motatakoak izan daitezke). Horretarako kortxete errektangeluar bikoitzak erabili
behar ditugu; adibidez, my.list[[3]] idatziz gero my.list-eko hirugarren
34 R hasiberrientzat
elementua atzituko dugu. Emaitza bera ere indexa dezakegu bektore, matrize, eta
abarrentzat azaldu dugun eran. Hirugarren objektu hori bektore bat bada, bere
balioak my.list[[3]][i] idatzita alda ditzakegu, hiru dimentsioko matrize
bat bada my.list[[3]][i, j, k], ...
3.5.5. Izendun objektuen balioak atzitu
izen kontzeptua behin baino gehiagotan azaldu zaigu jada. Izenak, atributuak
dira eta mota askotakoak daude (names, colnames, rownames, dimnames). Izenen
inguruko ideia oso sinpleen inguruan jardungo dugu orain, batez ere, objektuen
elementuak atzitzeko duten erabilerarekin erlazionatutako ideien inguruan.
Objektu baten elementuek izena badute, izen horiek indizetzat erabilita atera
daitezke. Elementuak era horretara ateraz gero, jatorrizko objektuaren atributuek
bere horretan jarraituko dute. Adibidez, DF datu-esparru batek x, y eta z aldagaiak
baditu, DF["x"] komandoak x soilik duen datu-esparru bat aterako du;
DF[c("x", "y")] komandoak bi aldagai horiek dituen datu-esparru bat
aterako du. Honek zerrendekin ere funtzionatzen du elementuek izenak badituzte.
Irakurlea ohartu den bezala, hemen erabili dugun indizea karaktere motako
bektore bat da. Lehenago deskribatu ditugun zenbakizko bektore edo bektore
logikoekin bezala, bektore hori bere baitan defini daiteke eta geroago erabili
elementuak ateratzeko.
Datu-esparru batetik bektore edo faktore bat ateratzeko $ ikurra erabil daiteke
(ad. DF$x). Prozedura hori zerrendetan ere aplika daiteke.
3.5.6. Datu-editorea
Zenbakizko objektu bat editatzeko, kalkulu-orri baten antzeko editore grafiko
bat erabil daiteke. Adibidez, X matrize bat bada, data.entry(X) komandoak
editore grafiko bat irekiko du; bertan, matrizearen balioak aldatu edo zutabe zein
errenkada berriak gehi ditzakegu.
data.entry funtzioak argumentutzat emaniko objektua zuzenean aldatzen
du bere emaitza esleitzeko inongo beharrik gabe. de funtzioak, berriz, argumen-
tutzat emaniko objektuak zerrenda batean itzultzen ditu, gehienetan aldatuta.
Emaitza hori, defektuz, pantailan erakusten da, baina beste funtzio askorekin
bezala, beste objektu bati eslei dakioke.
Datu-editorearen xehetasunak sistema eragilearen menpe daude (editorea
oraindik ez da inplementatu sistema guztientzat).
Datuen erabilera R-n 35
3.5.7. Funtzio aritmetiko sinpleak
R-n, datuak manipulatzeko funtzio-piloa dago. Errazena jada ikusi dugu: c.
Horrek, parentesi artean idatzitako objektuak kateatzen ditu. Adibidez:
> c(1:5, seq(10, 11, 0.2))
[1] 1.0 2.0 3.0 4.0 5.0 10.0 10.2 10.4 10.6 10.8 11.0
Bektoreak espresio aritmetiko klasikoekin manipula daitezke:
> x <- 1:4
> y <- rep(1, 4)
> z <- x + y
> z
[1] 2 3 4 5
Luzera ezberdineko bi bektore gehi ditzakegu. Kasu horretan bektore
motzena birziklatu egiten da. Adibideak:
> x <- 1:4
> y <- 1:2
> z <- x + y
> z
[1] 2 4 4 6
> x <- 1:3
> y <- 1:2
> z <- x + y
Warning message:
longer object length
is not a multiple of shorter object length in: x + y
> z
[1] 2 4 4
Ikus daitekeenez, R-k prebentzio-mezu bat igorri du eta ez errore bat; beraz,
eragiketa gauzatu du. Bektore bateko elementu guztiei balio bat gehitu (edo
biderkatu) nahi badiegu:
> x <- 1:4
> a <- 10
> z <- a * x
> z
[1] 10 20 30 40
R-n eskuragarri ditugun funtzioak hainbeste dira, ezen ezinezkoa zaigun
guztiak zerrenda batean aurkeztea. Funtzio matematiko sinple guztiak aurki
daitezke (log, exp, log10, log2, sin, cos, tan, asin, acos, atan, abs,
sqrt, . . . ), funtzio bereziak (gamma, digamma, beta, besselI, . . .), eta
estatistikan oso erabilgarriak diren hainbat funtzio. Funtzio horietariko batzuk
hurrengo taulan zehazten ditugu:
36 R hasiberrientzat
Funtzio horiek guztiek balio bakarra itzultzen dute (1 luzerako bektore bat).
Badira salbuespenak: range() funtzioak 2 luzerako bektore bat itzultzen du, eta
var(), cov() eta cor() funtzioek, berriz, matrizeak itzul ditzakete. Hurrengo
funtzioek bektore konplexuagoak itzul ditzakete:
round(x, n) x-ren elementuak n hamartarreko zenbakietara biribiltzen ditu
rev(x) x-ren elementuak atzekoz aurrera jartzen ditu
sort(x) x-ren elementuak goranzko ordenan jartzen ditu; beheranzko ordenan jartzeko:
rev(sort(x))
rank(x) x-ren elementuak lerrokatzen ditu
log(x, base) "base" oinarriko x-ren logaritmoa kalkulatzen du
scale(x) x matrize bat bada, datuak zentratu eta gutxitu egiten ditu; zentratzea bakarrik nahi
bada sacale=FALSE erabili, gutxitzeko soilik center=FALSE (defektuz,
center=TRUE, sacale=TRUE)
pmin(x,y,...) i. elementua x[i], y[i], ... elementuen arteko minimoa duen bektore bat
pmax(x,y,...) aurrekoa bezalakoa baina maximoarekin
cumsum(x) i. elementua x[1]-etik x[i]-rako elementuen batura duen bektore bat
cumprod(x) aurrekoa bezalakoa baina biderkadurarentzat
cummin(x) aurrekoa bezalakoa baina minimoarentzat
cummax(x) arrekoa bezalakoa baina maximoarentzat
match(x, y) x bektorearen luzera bera duen bektore bat itzultzen du; bertan, x-n dauden
elementuetatik y-n ere agertzen direnak egongo dira (NA y-n ez badago)
which(x == a) x-ren indizeek osaturiko bektore bat itzultzen du eragiketaren emaitza TRUE bada
(adibide honetan, x[i] == a egiten duten i-ren balioak). Funtzio honen
argumentuak aldagai logiko bat izan behar du
choose(n, k) n errepikapenetan k gertaeren konbinazio guztiak kalkulatzen ditu = n!/[(n-k)!k!]
na.omit(x) NA balioa duten datuak ezabatzen ditu (x matrize edo datu-esparru bat bada,
errenkada osoa ezabatzen du)
na.fail(x) errore-mezu bat igortzen du x-k gutxienez NA bat badu
unique(x) x bektore edo datu-esparru bat bada, antzeko objektu bat itzultzen du, baina
errepikatzen ziren elementuak ezabatuta
table(x) x-ren balio ezberdinen kopuruaz osaturiko taula bat itzultzen du (tipikoki osoentzat
eta faktoreentzat)
subset(x, ...) Zehazten zaion irizpidearen araberako x-ren aukeraketa bat itzultzen du (... oro har,
konparazio bat izaten da irizpidea: x$V1 <10); x datu-esparru bat bada, select
aukerak zein aldagai mantendu nahi ditugun adieraziko du (- jarriz gero, zein
aldagai arbuiatu nahi ditugun)
sample(x, size) x-ren size elementuak ausaz lagintzen ditu, baina ordezkapenak egin gabe;
replace=TRUE aukera jarriz gero, laginketa ordezkapenekin egiten du
sum(x) x-ren elementuen batura
prod(x) x-ren elementuen biderketa
max(x) x objektuaren balio maximoa
min(x) x objektuaren balio minimoa
which.max(x) x-ren elementu maximoaren indizea itzultzen du
which.min(x) x-ren elementu minimoaren indizea itzultzen du
range(x) x-ren heina edo c(min(x), max(x))
length(x) x-ren elementu-kopurua
mean(x) x-ren elementuen arteko batezbestekoa
median(x) x-ren elementuen arteko mediana
var(x) o cov(x) x-ren elementuen bariantza (n-1 erabiliz kalkulatzen da); x matrize edo
datu-esparru bat bada, bariantza-kobariantza matrizea kalkulatzen da
cor(x) x-ren korrelazio-matrizea, x matrize edo datu-esparrua bada (1 x bektorea
bada)
var(x, y) o cov(x, y) x eta y-ren arteko kobariantza, edo x eta y-ren zutabeen arteko kobariantza
x eta y matrizeak edo datu-esparruak badira
cor(x, y) x eta y-ren arteko korrelazio lineala, edo korrelazio-matrizea x eta y
matrizeak edo datu-esparruak badira
Datuen erabilera R-n 37
3.5.8. Kalkuluak matrizeekin
R-k erraztasunak ematen ditu matrizeak manipulatu eta beraiekin eragiketak
egiteko. rbind() eta cbind() funtzioek matrizeak elkartzen dituzte beraien
errenkada edo zutabeekiko, hurrenez hurren:
> m1 <- matrix(1, nr = 2, nc = 2)
> m2 <- matrix(2, nr = 2, nc = 2)
> rbind(m1, m2)
[,1] [,2]
[1,] 1 1
[2,] 1 1
[3,] 2 2
[4,] 2 2
> cbind(m1, m2)
[,1] [,2] [,3] [,4]
[1,] 1 1 2 2
[2,] 1 1 2 2
Bi matrizeren biderketa egiteko `%*%' eragigaia erabiltzen da. Adibidez, m1
eta m2 bi matrize hartuta:
> rbind(m1, m2) %*% cbind(m1, m2)
[,1] [,2] [,3] [,4]
[1,] 2 2 4 4
[2,] 2 2 4 4
[3,] 4 4 8 8
[4,] 4 4 8 8
> cbind(m1, m2) %*% rbind(m1, m2)
[,1] [,2]
[1,] 10 10
[2,] 10 10
Matrize baten transposizioa t funtzioarekin egiten da; funtzio horrek datu-
esparruekin ere funtzionatzen du.
diag funtzioa matrize baten diagonala atera edo aldatzeko, edo matrize-
diagonal bat sortzeko erabil daiteke:
> diag(m1)
[1] 1 1
> diag(rbind(m1, m2) %*% cbind(m1, m2))
[1] 2 2 8 8
> diag(m1) <- 10
> m1
[,1] [,2]
[1,] 10 1
[2,] 1 10
> diag(3)
[,1] [,2] [,3]
38 R hasiberrientzat
[1,] 1 0 0
[2,] 0 1 0
[3,] 0 0 1
> v <- c(10, 20, 30)
> diag(v)
[,1] [,2] [,3]
[1,] 10 0 0
[2,] 0 20 0
[3,] 0 0 30
> diag(2.1, nr = 3, nc = 5)
[,1] [,2] [,3] [,4] [,5]
[1,] 2.1 0.0 0.0 0 0
[2,] 0.0 2.1 0.0 0 0
[3,] 0.0 0.0 2.1 0 0
R-k matrizeekin kalkuluak egiteko funtzio batzuk ere baditu. Aipatzeko
modukoak dira honoko hauek: solve() matrize bat alderantziz jartzeko, qr()
deskonposaketarako, eigen() berezko balio eta bektoreak kalkulatzeko eta
svd() deskonposaketa singularrak egiteko.
Datuen erabilera R-n 39
4. Grafikoak R-n
R-k mota askotako grafikoak eskaintzen ditu. Ideia bat izatearren, idatz ezazu
demo(graphics) komandoa. Ezinezkoa zaigu, benetan, R-k grafikoak egiteko
orduan eskaintzen dituen aukera guztiak hemen zehaztea. Funtzio grafiko
bakoitzak milaka aukera ditu R-n. Horrek izugarrizko malgutasuna ematen du
grafikoak sortzeko, eta beste edozein pakete grafikori alde handia ateratzen dio.
Funtzio grafikoen erabilera dokumentu honen hasieran azaldu ditugun trazen
nahiko ezberdina da. Konkretuki, funtzio grafiko baten emaitza ezin zaio objektu
bati esleitu11, gailu grafiko batera eramaten baita. Gailu grafiko bat leiho grafiko
edo artxibo bat da.
Bi motatako funtzio grafikoak ikus ditzakegu: alde batetik grafiko berriak
sortzeko balio duten goi-mailako funtzio grafikoak, eta bestetik, jada eginda
dauden grafikoei elementu berriak gehitzeko erabiltzen diren behe-mailako funtzio
grafikoak. Grafikoak defektuz definituta dauden parametro grafiko batzuen arabera
sortzen dira. Parametro horiek par funtzioarekin alda daitezke.
Lehenik eta behin, grafiko eta gailu grafikoak erabiltzen ikasiko dugu;
ondoren, funtzio grafiko batzuk eta beraien parametroak ikusiko ditugu xehetasun
handiz. Azkenik, grid eta lattice paketeak azalduko zaizkigu. Horien funtziona-
mendua R-ko funtzio grafiko `arruntena' bezalakoa da.
4.1. GRAFIKOEN ERABILERA
4.1.1. Gailu grafiko anitz ireki
Funtzio grafiko bat exekutatzean, R-k leiho berri bat irekitzen du grafikoa
erakusteko, aurretik beste gailu bat ireki ez badugu. Gailu grafiko bat funtzio
egokia erabilita irekitzen da. Eskuragarri dauden gailu grafikoen mota sistema
11. Badira salbuespenak: hist() eta barplot() funtzioek zerrenda eta matrize motako
emaitzak ere sortzen dituzte.
eragilearen araberakoa da. Leiho grafikoek x11 izena dute Unix/Linux-en,
windows Windows-en eta macintosh Mac-en. Unix/Linux-en eta Windows-en
x11() komandoa idatziz leiho grafiko bat ireki daiteke, Windows-en
windows() komandora jotzen duen alias bat definitzen baita. Ireki nahi den
gailu grafikoa artxibo bat bada, artxibo-mota horren araberako funtzioak erabili
behar dira: postscript(), pdf(), png(), ... Eskura dauden gailu grafikoen
zerrenda ?device komandoarekin lor daiteke.
Irekitako azken gailua gailu aktibo bihurtuko da. Horrek esan nahi du sortzen
ditugun grafikoak gailu horretan marrR Hasiberrientzat (itzulpena)