1. LIMBAJUL RRRR 1.1. De ce R?

R este un mediu integrat de facilităţi software care permite analiza statistică şi

reprezen-tarea grafică a datelor. Acesta include un limbaj simplu de programare, limbajul S, care permite utilizarea pachetelor existente şi construirea de pachete noi de programe destinate analizei statistice şi reprezentării grafice a datelor.

Există un număr mare de programe cu ajutorul cărora se efectuează analize statistice şi reprezentări grafice. Întrebarea firească ce se pune este: de ce să utilizăm R şi nu alte sisteme? Există un număr mare de argumente în favoarea utlizării sistemului R. Amintim aici doar două dintre cele mai importante:

s R poate fi obţinut gratuit de pe site-ul oficial al proiectului R (http://www.r-project.org) şi este uşor de instalat pe aproape orice computer disponibil;

s R permite utilizatorului efectuarea unui număr extrem de mare de analize statistice, înce-pând cu cele mai simple şi terminând cu cele mai complexe. Aceasta inseamnă că utilizatorul va găsi intotdeauna metodele cele mai adecvate pentru analiza propriilor date.

Pe lângă aceste avantaje, R dispune de capcităţi excelente de programare şi de reprezentare grafică, astfel încât acesta poate fi utilizat nu numai în scopuri de cercetare, dar şi în scopuri didactice. Un alt avantaj major al utilizarii sistemului R este existenţa unui număr impresionant de pachete de programe de analiză a datelor ce pot fi descărcate imediat şi gratuit de pe internet.

Textul principal al acestei cărţi prezintă modul în care se instalează şi se lansează în execuţie sistemul R, noţiunile teoretice şi funcţiile corespunzătoare pentru analiza statistică şi reprezentarea grafică a datelor în R precum şi modul în care rezultatele acestor analize pot fi salvate în fişiere de diferite tipuri. Problemele simple prezentate odată cu introducerea unei noţiuni noi ajută la înţelegerea principiilor care stau la baza sistemului R şi oferă o bază solidă pentru utilizarea pe viitor a unor pachete de analiză statistică mai complexe scrise în acest limbaj. PROBLEME + + + + 1. Vizitaţi site-ul oficial al proiectului R de la adresa http://www.r-project.org. Enumeraţi câteva manuale de utilizare ale lui R existente pe acest site.

Soluţie Manualele de introducere în R disponibile pe acest site la data de 14 Septembrie,

2010 sunt:

- An Introduction to R #prezintă o introducere în R - R language definitions #prezintă detalii ale procesului de evaluare

a expresiilor în limbajul R. - Writing R extensions #prezintă modul în care un utilizator

poate crea propriile pachete de programe în R.

- R Data Import/Export #descrie facilităţile de import şi export ale sistemului R.

- R Installation and Administration #instrucţiuni de instalare şi administrare - R Internals #ghid al structurilor R interne şi standardele

echipei care lucrează la proiectul R. - The R Reference Index #conţine fişierele “help” ale programelor standard

din R şi ale pachetelor de programe recomandate.

Trebuie menţionat faptul că aceste manuale sunt disponibile la data precizată mai sus. Aceste manuale pot fi actualizate sau şterse. Este posibilă apariţia unor manuale noi la această adresă. + + + + 2. Ce este CRAN?

Soluţie CRAN este abrevierea de la Comprehensive R Archive Network (http://cran.r-

project.org/). Această arhivă conţine diferitele variante ale sistemului R, ale pachetelor şi ale seturilor de date asociate. 1.2. Instalarea sistemului R

Dacă nu aveţi R instalat trebuie să îl descărcaţi (download) de la adresa

http://www.r-project.org şi să îl instalaţi pe calculatorul dumneavoastră. La această adresă, care este site-ul oficial al proiectului, se află stocate diferite versiuni ale sistemului R. Deoarece acest sistem se dezvoltă continuu, este indicat să descărcaţi ultima variantă disponibilă.

Instrucţiunile de instalare sunt furnizate tot pe acest site. R poate fi instalat sub Windows, Unix, Linux şi versiunea 10 a sistemului de operare Macintosh. Odată cu R se descarcă şi o serie de pachete de programe şi seturi de date care, în ultimele variante, sunt parte integrantă a sistemului R. Pe lângă acestea, există şi pachete de programe sau seturi de date care se descarcă opţional. Acestea sunt disponibile pe site-ul CRAN de la adresa menţionată mai sus sau de la oglinzi ale acestuia.

Cei mai mulţi utilizatori de Windows instalează R acţionând ,,click” pe iconiţa ce apare pe desktop odată ce versiunea executabilă (binară) a fost descărcată de pe pagină oficială a acestui proiect. Un program de instalare va ghida utilizatorul în acest proces. Instalarea, folosind opţiunea default, va genera o iconiţă pe desktopul calculatorului dumneavoastră. Sistemul R poate fi lansat acţionând ,,click” de două ori pe această iconiţă. Rezultatul va fi apariţia pe ecran a unui text de tipul: R version 2.11.1 (2010-05-31) Copyright (C) 2010 The R Foundation for Statisticăl Computing ISBN 3-900051-07-0 R is free software and comes with ABSOLUTELY NO WARRANTY.

You are welcome to redistribute it under certain conditions. Type 'license()' or 'licence()' for distribution details. Natural language support but running în an English locale R is a collaborative project with many contributors. Type 'contributors()' for more information and 'citation()' on how to cite R or R packages în publications. Type 'demo()' for some demos, 'help()' for on-line help, or 'help.start()' for an HTML browser interface to help. Type 'q()' to quit R

În acest moment, aţi deschis o sesiune R. Aşa cum am menţionat, limbajul R are

la bază un set de comenzi (command-driven). În regim interactiv aceste comenzi sunt scrise după prompterul “>”. Comenzile pot fi de asemenea scrise în fişiere şi executate folosind funcţia source() sau scrise după prompterul “>” cu ajutorul schemei copy-and-paste.

Părăsirea sesiunii R se face utilizînd comanda >q( )

Pe ecran va aparea o întrebare referitoare la salvarea sau nu a sesiunii de lucru. Sesiunea de lucru se poate salva într-un fişier, pentru a fi redeschisă mai târziu, sau se poate renunţa definitiv la aceasta.

Atunci când utilizăm R sub Windows este indicat să creăm un director de lucru iar calea acestui director să fie setată în câmpul “Start In” din scurtătura (shortcut) lui R. Fişierele din acest director vor putea fi accesate din R fără a mai preciza întreaga cale. În mod similar, fişierele create într-o sesiune R vor fi stocate în acest director de lucru. Conţinutul directorului de lucru (numele fişierelor) se obţin cu comanda dir(). Directorul de lucru poate fi schimbat interactiv cu comanda setwd(). Calea directorului de lucru este returnată de funcţia getwd().

Dacă utilizăm R sub Unix sau Linux se procedează similar. În primul rând se creează un director de lucru pe care îl denumim, spre exemplu, “work”. În acest director vor fi stocate fişierele ce vor fi utilizate în sesiunea interactivă a lui R. Directorul se creează cu comanda $mkdir work

Se intră în acel director cu comanda $cd work.

Odată ajunşi în directorul “work” se tastează comanda $R

În acest mod se lansează o sesiune R. Pe ecran se va deschide o fereastră cu prompterul “>” ceea ce indică faptul că sesiunea R interactiva este deschisă. PROBLEME + + + + 1. Instalaţi ultima variantă executabilă (binară) a sistemului R pe calculatorul dumneavoastră. Creaţi directorul “C:/LUCRU” şi faceţi ca acest director să fie director de lucru al sistemului R pe care tocmai l-aţi instalat.

Soluţie Primul pas este accesarea site-ului oficial al proiectului R (http://www.r-

project.org/) şi de aici acţionând “click” pe CRAN (stânga mijloc) se obţine o pagină cu linkurile de unde se poate descărca (download) sistemul R. Alegeţi de exemplu adresa de la Berkeley (http://cran.cnr.berkeley.edu/) şi daţi “click” pe Download R 2.11.1 for Windows. Alegând opţiunea SAVE, varianta binară (executabilă) a lui R va fi încarcată pe calculatorul dumneavoastră. După terminarea salvării pe Desktopul calculatorului dumneavoastră va apărea o iconiţă cu numele R-2.11.1.win32.exe. Daţi “clik”de două ori pe aceasta şi urmaţi instrucţiunile de instalare. Este de dorit să alegeţi de fiecare dată opţiunea “default”. La sfârşitul acestui proces, pe ecran se va creea iconiţa R 2.11.1. Acţionînd “click” de două ori pe această iconiţă se deschide o sesiune R interactivă.

Pentru punctul doi al problemei se crează mai întâi directorul LUCRU pe discul C (C:/LUCRU). Se acţionează apoi “click” cu butonul din dreapta al mause-ului pe iconiţa R 2.11.1, şi apoi pe Properties. În căsuţa Start care apare se scrie “C:/LUCRU” şi se închide fereastra. În acest fel “C:/LUCRU” devine directorul de lucru pentru sesiunea R lansată cu ajutorul acestei iconiţe. + + + + 2. Deschideţi o sesiune R interactivă folosind programul R instalat în problema precedentă. Părăsiţi această sesiune fără a o salva.

Soluţie Se acţionează “click” de două ori pe iconiţa sistemului R de pe desktop.

Rezultatul este apariţia pe ecran a mesajului prezentat în text şi al prompterului “>”. Pentru a părăsi sesiunea, se dă comanda >q() şi apoi se acţionează “click”pe opţiunea No a căsuţei ce apare pe ecran. 1.3. Comanda help()

R dispune de funcţii care permit obţinerea rapidă de informaţii referitoare la

funcţiile şi facilităţile sistemului R instalat pe calculatorul dumneavoastră. Pentru a obţine informaţii despre o anumită funcţie, de exemplu read.table(), se execută comanda >help(read.table).

O comandă alternativă este >?read.table.

Pentru funcţiile specificate prin caractere speciale, ca de exemplu for, if sau function, argumentele trebuie incluse între ghilimele (“…“). În caz contrar, argumentele nu sunt interpretate ca şiruri de caractere. Pentru a obţine informaţii despre facilităţile oferite de funcţia help(), din R se execută comanda help.start(). Această comandă va lansa un Web browser cu o serie de pagini conţinând diferite linkuri care permit accesarea informaţiilor legate de sistemul R şi instalarea acestuia.

Exemple pentru o anumită topică pot fi obţinute prin executarea comenzii >example(topic).

Versiunea Windows a lui R permite accesarea ,,help”-ului cu comanda >?help

Funcţia help.search() se apelează cu comanda >help.search(pattern, .....)

unde pattern este un şir de caractere, iar “…” alte argumente. Această funcţie permite compararea şirului de caractere precizat cu şirurile de caractere care formează nume de fişiere, titluri etc, din “help”-ul sitemului R. Numele şi titlurile compatibile sunt afişate pe ecran. Această comandă poate ajuta utilizatorul să identifice obiectele R căutate. Dacă calculatorul este conectat la internet se poate utiliza funcţia RsiteSearch() pentru căutarea online a unor cuvinte cheie sau a unor fraze dorite de utilizator în manualelele R disponibile online, în paginile “help” sau în arhivele de liste de emailuri ale sistemului R. Această funcţie are ca argument parametrul restrict care permite limitarea căutarii doar la o colecţie de informaţii de un anumit tip. Pentru detalii se poate utiliza funcţia help(RsiteSearch). PROBLEME + + + + 1. Care este comanda prin care obtineţi informaţii despre funcţia help() din R?

Soluţie Informaţiile solicitate se obţin cu comanda

>help(help) sau >?help + + + + 2. Care este comanda pentru obţinerea de informaţii despre funcţia read.table(). Dar despre funcţiile if(), for() şi function()?

Souluţie Se folosesc comenzile

>help(read.table) >help(“if”) >help(“for”) >help(“function”)

De notat prezenţa ghilimelelor în interiorul parantezelor la ultimele trei comenzi. + + + + 3. Utilizaţi funcţia help.search() pentru a identifica funcţiile cu ajutorul cărora se poate efectua analiza cluster.

Soluţie Comanda este

>help.search("cluster") Pe ecran vor fi afişate o serie de informaţii care permit identificarea funcţiilor sau

pachetelor de programe cu ajutorul cărora se efectuează analiză cluster în R. De exemplu, într-una din liniile afişate pe ecran este scris: stats::kmeans K-Means Clustering.

Aceasta indică faptul ca funcţia kmeans, disponibilă în pachetul stats permite efectuarea analizei cluster folosind metoda K-Means Clustering. Informaţii detaliate referitoare la această funcţie se obţin cu comanda >help(kmeans)

1.4. Alte caracteristici ale sistemului R

Odată cu lansarea sistemului R, se încarcă automat o serie de arhive (repositories or databases) în care acesta caută obiectele necesare evaluării unei anumite comenzi. Spaţiul de lucru (Globalenv) este primul din această listă de căutare. Astfel comanda ls(pos=1) este echivalentă cu ls(). Comanda ls(pos=2) listează obiectele din a doua listă de căutare şi aşa mai departe. Căile de căutare pot fi extinse cu ajutorul funcţiilor attach() or library(). Funcţia attach() permite accesul la tablouri de date sau liste de obiecte R în timp ce funcţia library() permite accesul la bibliotecile de funcţii şi seturile de date asociate din diferite pachete de programe. Detalii referitoare la aceste funcţii se pot obţine cu help(attach) şi help(library).

Comenzile în R sunt separate fie de simbolul punct şi virgulă (semi-colon) (“;”) fie sunt scrise pe linii diferite. Comenzile elementare pot fi grupate într-o expresie comună cu ajutorul acoladelor ({“comenzi”}).

Orice şir de caractere precedat de simbolul “#” este interpretat ca fiind un comentariu. Comentariile pot fi plasate oriunde în interiorul programului. Dacă o comandă nu este completă la sfârşitul unei linii, R va lansa un prompter nou, de obicei simbolul “+”, în linia sau în liniile următoare. Acest simbol dispare când comanda este completă.

În R se face distincţie între literele mari şi cele mici (sunt entităţi distincte) ca dealtfel şi în UNIX. De exemplu caracterele M, şi m sunt interpretate distinct.

Aşa cum am menţionat anterior, comenzile pot fi lansate în regim interactiv prin scrierea lor după prompterul “>” şi apoi apăsarea tastei ENTER. Este uneori mai comod să scriem aceste comenzi într-un fişier text şi să le executăm folosind funcţia source(). Presupunem că fişierul care conţine comenzile ce urmează a fi executate se numeşte test_com.txt şi se află în directorul de lucru, în cazul nostru în C:/LUCRU. Comanda >source(”test_com.txt”) va avea ca efect încărcarea în spaţiul de lucru şi executarea comenzilor conţinute în fişierul test_com.txt.

R dispune de un mecanism de rechemare a comenzilor executate. Prin apăsarea tastei de deplasare pe verticală în sus, situată în partea dreapta de jos a tastaturii, se pot obţine comenzile scrise anterior. Acestea pot fi reexecutate sau modificate şi apoi executate.

Entităţile pe care R le poate creea sau manipula poartă denumirea de obiecte R sau, pe scurt, obiecte. Acestea pot fi variabile, tablouri de numere, şiruri de caractere, funcţii sau structuri create cu aceste funcţii. Într-o sesiune R obiectele sunt create şi identificate cu ajutorul numelor. Comanda >objects() sau comanda alternativă >ls() poate fi utilizată pentru a lista pe ecran numele obiectelor care sunt disponibile în sesiunea de lucru. Mulţimea obiectelor disponibile la un moment dat într-o sesiune R formează spaţiul de lucru (workspace). Aceste obiecte pot fi şterse cu ajutorul funcţiei rm(). Dacă, de exemplu, dorim să ştergem vectorii x şi y din spaţiul de lucru, atunci folosim comanda >rm(x,y)

Pentru ştergerea tuturor obiectelor din spaţiul de lucru al unei sesiuni R se foloseşte comanda >rm(list=ls())

Toate obiectele create în timpul unei sesiuni R pot fi salvate într-un fişier şi pot fi utilizate în sesiunile viitoare. Obiectele aflate la un moment dat în spaţiul de lucru pot fi salvate cu ajutorul funcţiei save(). Aceste obiecte pot fi apoi încărcate pentru a fi utilizate într-o altă sesiune cu ajutorul funcţiei load(). Alte câteva funcţii utile în manipularea obiectelor din spaţiul sau directorul de lucru sunt enumerate mai jos.

file.choose() #aleg un fişier interactiv sessionInfo #afişez pe ecran informaţii despre R si pachetele ataşate R.home #calea directorului in care R este instalat .Library #calea bibliotecilor R corespunzătoare opţiunii default Sys.getenv() #setările variabilelor din spaţiul de lucru La sfârşitul fiecărei sesiuni se pot salva toate obiectele din spaţiul de lucru. Aceste

obiecte se salvează, de obicei, într-un fişier numit “.Rdata” din directorul de lucru iar şirul comenzilor utilizate în sesiune în fişierul “.Rhistory” din acelaşi director. Pentru salvarea întregului spaţiu de lucru se poate utiliza funcţia save.iamge(). Când R este lansat având acelaşi director de lucru asociat, obiectele şi comenzile din aceste fişiere se încarcă automat. Este recomandat să se utilizeze directoare de lucru separate pentru fiecare nouă sesiune R. În acest fel se evită suprapunerea obiectelor sau funcţiilor cu acelaşi nume. Amestecarea necontrolată a obiectelor din diferite sesiuni poate crea probleme majore şi trebuie evitată. PROBLEME + + + + 1. Pentru scrierea pe ecran a şirului de caractere “numele meu este Popescu” se foloseşte funcţia print(). Utilizaţi funcţia help() pentru a obţine informaţii despre utilizarea funcţiei print(). Scrieţi această comandă în fişierul “test_com.txt” din directorul de lucru şi folosiţi funcţia source() pentru executarea acestei comenzi.

Soluţie Rezolvăm problema mai întâi în modul interactiv. Se vor executa următoarele

comenzi: >help(print) #informaţii despre forma funcţiei print >print(“numele meu este Popescu”) #printare folosind opţiunile default [1] "numele meu este Popescu" #rezultat

Dacă comenzile sunt scrise în fişierul “test_com.txt” din fişierul de lucru, atunci se execută comanda: >source(“comanda.txt”) #apelarea comenzilor din fişierul comanda.txt [1] "numele meu este Popescu" #rezultat + + + + 2. R poate fi utilizat şi ca un calculator de buzunar. Efectuaţi următoarele calcule aritmetice: 7.2+4.1; 5.3-8.21; 8.25*2.25; 7.25/8.42 şi radical din 2.13.

Soluţie >7.2+4.1 #adunare [1] 11.3 #rezultat

>5.3-8.21 #scădere [1] -2.91 #rezultat >8.25*2.25 #înmulţire [1] 18.5625 #rezultat >7.25/8.42 #împărţire [1] 0.8610451 #rezultat >sqrt(2.13) #radical [1] 1.459452 #rezultat

În mod similar se pot efectua toate operaţiile aritmetice permise de un calculator de buzunar. + + + + 3. În problema precedentă numerele reale rezultate din calculele aritmetice au fost scrise cu şase zecimale. Utilizaţi funcţia options() pentru a scrie pe ecran rezultatul împărţirii numărului 7.25 la 8.42 ca un număr cu două zecimale.

Soluţie >options(digits=2) #trunchez la două zecimale >7.25/8.42 #împărţire [1] 0.86 #rezultat + + + + 4. Presupunem că într-o sesiune R în spaţiul de lucru se află doar vectorul numeric x=(7,9,12,15). Salvaţi acest obiect in directorul “C:/LUCRU1” folosind functia save(). Încărcaţi acest obiect intr-o sesiune nouă folosind funcţia load().

Soluţie Se lansează sistemul R acţionând ,,click” pe iconiţa corespunzătoare de pe

desktop. După apariţia prompterului “<” se vor executa comenzile de mai jos. >x<-c(7,9,12,15) #creez vectorul x >save(x,file=”C:/LUCRU1/x.Rdata”) #salvez vectorul x in fisierul x.Rdata >q() #părăsesc sesiunea R

Deschid o nouă sesiune R. >load((C:/LUCRU1/x.Rdata”) #încarc fişierul x.Rdata >x #afişez conţinutul lui x [1] 7 9 12 15 #rezultat

2. ELEMENTELE DE BAZĂ ALE LIMBAJULUI RRRR 2.1. Calcule simple. Numere şi vectori

În acest capitol vom prezenta elementele de bază ale limbajului R prin

intermediul unor exemple simple. Abordări mai complexe pot fi găsite în manualele specializate destinate învăţării limbajului R. 2.1.1. Construirea interactivă şi operaţii simple cu vectori numerici

R operează cu structuri de date. Cele mai simple structuri sunt vectorii numerici,

adică succesiuni de numere aranjate într-o anumită ordine. Aceste structuri pot fi create interactiv sau importate din fişiere. În continuare, vom prezenta prin intermediul câtorva exemple modul în care vectorii numerici se pot crea şi manipula interactiv.

Vectorul x format din numerele 1,2,3 şi 4 se crează cu ajutorul comenzii >x<-c(1,2,3,4) unde c() este funcţia de concatenare. Această funcţie este larg utilizată în R pentru “agregarea” diferitelor obiecte. Simbolul “<-“ este echivalentul semnului egal. Acelaşi rezultat se obţine dacă se foloseşte funcţia assign() prin comanda >assign(“x”,c(1,2,3,4))

Aşa cum se observă mai sus, operatorul “<-“ este practic scurtătura (short-cut) funcţiei assign().

Pentru a afişa pe ecran elementele vectorului x se execută comanda >x [1] 1 2 3 4 #rezultat

Limbajul R permite efectuarea interactivă a diferitelor operaţii cu vectori. De exemplu, comanda >y<-1/x are ca efect crearea vectorului y de aceeaşi lungime ca vectorul x ale cărui elemente sunt 1/x. Conţinutul vectorului y este afişat pe ecran prin comanda >y [1] 1 0.50 0.33 0.25 # rezultat

Utilizând funcţia de concatenare c() se pot construi vectori de dimensiuni mai mari prin concatenarea mai multor vectori de dimensiuni mai mici.

De exemplu, vectorul z obţinut prin concatenarea vectorilor x şi y se obţine cu comanda >z<-c(x,y) #concatenez vectorii x şi y >z #afişez elementele vectorului z [1] 1 2 3 4 1 0.50 0.33 0.25 #rezultat

Elementele vectorilor numerici sunt numerele reale. Aceşti vectori pot fi utilizaţi în expresii aritmetice. Fiecare element al acestui vector este calculat din elementele corespunză-toare ale vectorilor care intră în expresia aritmetică. Vectorii care apar într-o

anumită expresie aritmetică trebuie să aibă aceeaşi lungime. Dacă lungimile sunt diferite operaţiunea se efectuează dar rezultatul, care este însoţit de un mesaj de eroare, este greu de interpretat.

Operaţiile aritmetice cu vectori acceptate de limbajul R sunt adunarea (+), scăderea (-), impărţirea (/), şi ridicarea la putere (^). În plus, vectorilor numerici li se pot aplica funcţiile cunoscute cum ar fi logaritmul (log), exponentiala (exp), funcţiile trigonometrice sinus (sin), cosinus (cos), tangenta (tan), radicalul (sqrt) etc.

Există funcţii definite care se pot utiliza pentru a determina unele caracteristici ale vectorilor numerici. Dacă x este un vector atunci funcţia length(x) returnează dimensiunea (lungimea) lui x. Funcţiile min(x) şi max(x) returnează cel mai mic şi respectiv cel mai mare element al lui x. Funcţiile prod(x) şi sum(x) returnează produsul şi respectiv suma tuturor elementelor lui x. Funcţiile mean(x) şi var(x) returnează media şi respectiv varianţa lui x. Funcţia sort(x) returnează un vector de aceeaşi dimensiune ca x dar cu elemente aranjate în ordine crescătoare. PROBLEME + + + + 1. Construiţi interactiv vectorii numerici x=(1,3,5), y=(10,12,14) şi z=(20,21,22). Apoi construiţi şi vizualizaţi vectorul w obtinut prin concatenarea vectorilor x, y şi z definiţi anterior.

Soluţie >x=c(1,3,5) #creez vectorul x >y=c(10,12,14) #creez vectorul y >z=c(20,21,22) #creez vectorul z >w=c(x,y,z) #creez vectorul w >w #afişez pe ecran w [1] 1,3,5,10,12,14,20,21,22 #rezultat + + + + 2. Fie vectorul x=(4,8) şi y=(2,4). Calculaţi x+y, x/y, x*y,x-y şi x^y.

Soluţie >x=c(4,8) #creez vectorul x >y=c(2,4) #creez vectorul y >x+y #adun x cu y şi afişez pe ecran rezultatul [1] 6 8 #rezultat >x/y #împart y la x şi afişez rezultatul [1] 2 2 #rezultat >x*y #înmultesc x cu y şi afişez pe ecran [1] 8 32 #rezultat >x-y #scad y din x şi afişez pe ecran [1] 2 4 #rezultat + + + + 3. Fie vectorul x=(1,2,7,4). Determinaţi valoarea minimă, maximă, lungimea, produsul, suma, media şi varianţa. Soluţie

>max(x) #determin valoarea maximă şi o afişez pe ecran [1] 7 #rezultat >min(x) #determin valoarea minima şi o afişez pe ecran [1] 1 #rezultat >length(x) #determin lungimea vectorului şi o afişez pe ecran [1] 4 #rezultat >sum(x) #determin suma elementelor lui x şi o afişez pe ecran [1] 14 #rezultat >mean(x) #determin media şi o afişez pe ecran [1] 3.5 #rezultat >var(x) #determin varianţa şi o afişez pe ecran [1] 7 #rezultat 2.1.2. Generarea secvenţelor regulate

R dispune de o serie de facilităţi pentru generarea secvenţelor de numere

organizate ca vectori sau matrice. Prezentăm aceste facilităţi prin intermediul câtorva exemple.

Vectorul v conţinând numerele de la 1 la 30 se generează cu comanda >v<-1:30

În mod similar, comanda >v<-30:1 generează secvenţa numerelor de la 30 la 1 cu pasul 1 şi salvează această secvenţă în vectorul v. În mod similar se pot genera secvenţe variate de numere care apoi pot fi utilizate în diferite calcule. De exemplu succesiunea de comenzi de mai jos generează vectorul v ale cărui elemente sunt numerele de la unu la 9. >n<-10 #n=10 >v<-1:n-1 #generez secvenţa 1-9 >v #vizualizez vectorul v [1] 1 2 3 4 5 6 7 8 9 #rezultat

Funcţia seq() se foloseşte pentru a genera secvenţe de numere. Această funcţie se apelează cu comanda >seq(from, to, by ...)

Primele două argumente specifică începutul şi sfârşitul secvenţei (from şi to) iar ultimul specifică pasul (by). Funcţii înrudite cu seq() sunt seq.int(),şi seq_len(). Mai jos sunt câteva exemple de utilizare a funcţiei seq(). >v5<-seq(2,10) #generez secvenţa de numere de la 2 la 10 şi o afişez pe ecran [1] 2 3 4 5 6 7 8 9 10 #rezultat >seq(from=2,to=10) #generez secvenţa de numere de la 2 la 10 şi o afişez pe ecran [1] 2 3 4 5 6 7 8 9 10 #rezultat >seq(-5,5,by=2) #generez secvenţa de la -5 la 5 cu pasul 2 şi o afişez pe ecran [1] -5 -3 -1 1 3 5 #rezultat

O funcţie înrudită cu seq() este rep(). Această funcţie se utilizează pentru a replica un obiect în diferite moduri. De exemplu, vectorul y obţinut prin repetarea de două ori a vectorului x=(1,2,3) se obţine cu secvenţa de comenzi de mai jos. >x=c(1,2,3) #creez vectorul x >y=rep(x,times=2) #creez vectorul y prin repetarea lui x de două ori >y #vizualizez y pe ecran [1] 1 2 3 1 2 3 #rezultat

O altă posibilitate este de a repeta fiecare element al lui x de un anumit număr de ori. De exemplu, vectorul care conţine elementele lui x fiecare repetate de două ori se obţine cu comanda >y<-rep(x, each=2) #creez vectorul y >y #afişez pe ecran elementele lui y [1] 1 1 2 2 3 3

Este important să putem identifica anumite secvenţe în şirurile de date. Operatorul ’’%in%’’ care testează existenţa unei secvenţe într-un şir de numere este deosebit de util în acest scop. De exemplu >x<-rep(1:5,rep(3,5)) #creez secvenţa regulată de numere >x #afişez pe ecran [1] [1] 1 1 1 2 2 2 3 3 3 4 4 4 5 5 #rezultat >x[x%in%c(2,4)] #testez existenţa cifrelor 2 si 4 în x [1] 2 2 2 4 4 4 #rezultat

Pentru a vedea care elemente ale lui x sunt 2 sau 4 şi care nu se utilizează funcţiile match() şi nomatch(). De exemplu comanda >match(x,c(2,4),nomatch=0) [1] 0 0 0 1 1 1 0 0 0 2 2 2 0 0 0 #rezultat are ca efect atribuirea cifrei 1 poziţiilor ocupate de 2, a cifrei 2 a celor ocupate de 4 si 0 în rest. PROBLEME + + + + 1. Să se creeze vectorul x=(1,7,8). Folosind funcţia rep() să se creeze vectorii y1=(1,7,8,1,7,8), y2=(1,1,7,7,8,8) şi y3=(1,7,8,0,1,1,8).

Soluţie >x<-c(1,7,8) #creez vectorul x >y1=rep(x,times=2) #creez vectorul y1 >y2=rep(x,each=2) #creez vectorul y2 >y3=c(x,0,x) #creez vectorul y3

Se vizualizează pe ecran rezultatul prin scrierea numelui fiecărui vector în linia de comandă şi apoi apăsarea tastei ENTER. + + + + 2. Să se genereze secvenţa de numere de la -30 la 30 cu pasul 10 şi de la -15 la 15 cu pasul 5. Secvenţele rezultate să fie concatenate într-un singur vector. Care este lungimea acestuia?

Soluţie

>x1<-seq(-30,30,by=10) #generez vectorul x1 >x2<-seq(-15,15,by=5) #generez vectorul x2 >y <-c(x1,x2) #concatenez x1 şi x2 >y #afişez y pe ecran [1] -30 -20 -10 0 10 20 30 -15 -10 -5 0 5 10 15 #rezultat >length(y) #calculez lungimea lui y şi o afişez pe ecran [1] 14 + + + + 3. Construiţi secvenţa de numere 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5. Folosind operatorul “%in%” extrageţi elementele egale cu 2 si 4 si puneţi-le în vectorul y. Creaţi vectorul z care sa aibă 0 pe poziţiile unde nu avem 2 si 4.

Soluţie >x<-rep(1:5,rep(3,5)) #creez secvenţa >y<-x[x%in%c(2,4)] #calculez vectorul y >y [1] 2 2 2 4 4 4 #rezultat >z=match(x,c(2,4),nomatch=0) >z [1] 0 0 0 1 1 1 0 0 0 2 2 2 0 0 0 #rezultat 2.1.3. Vectori logici

Elementele unui vector logic sunt succesiuni de TRUE (adevărat), FALSE (fals)

şi NA (not available-nedisponibil). Deseori TRUE se abreviază cu T iar FALSE cu F. Este de dorit utilizarea lui TRUE şi FALSE în loc de T şi F deoarece este posibil ca T sau F să fie variabile deja definite.

Vectorii logici sunt generaţi atunci când se impun anumite condiţii. De exemplu, dacă punem condiţia ca elementele vectorului x =(-2,7,9) să fie pozitive, putem genera vectorul logic FALSE,TRUE, TRUE cu secvenţa de comenzi de mai jos. >x<-c(-2,7,9) >y<-x>0

Primul element al lui x este mai mic decât zero şi condiţia nu este îndeplinită (FALSE) iar ultimele două sunt pozitive şi deci condiţia este îndeplinită (TRUE).

Pe lângă operatorul “mai mare” (simbolul “>”), din exemplul de mai sus, mai pot fi folosiţi şi alţi operatori logici cum ar fi “ <” (mai mic), “<=” (mai mic sau egal), “==” (identic) sau “!=”(diferit). Dacă c1 şi c2 sunt expresii logice, atunci “c1&c2” reprezintă intersecţia lor (and) iar “c1|c2” este reuniunea lor (or) iar “!c1” este negaţia lui c1. Informaţii suplimentare despre operatorii menţionaţi mai sus şi alţi operatori logici pot fi obţinute cu comenzile help(Logic), help(Comparison) sau help(Syntax).

Vectorii logici pot fi utilizaţi în operaţii aritmetice. În acest caz, ei se transformă în vectori numerici, FALSE devenind 0 iar TRUE devenind 1. Funcţia utilizată în acest scop este as.numeric(). PROBLEME

+ + + + 1. Creaţi vectorul x=(-1,7,4,-2,9). Determinaţi vectorul logic corespunzator condiţiei ca elementele lui x să fie pozitive.

Soluţie >y<-x>0 #creez vectorul logic y >y #afişez pe ecran pe y [1] FALSE TRUE TRUE FALSE TRUE #rezultat + + + + 2. Creaţi vectorul logic asociat condiţiei x diferit de -2, unde x este vectorul numeric din problema precedentă.

Soluţie >y<-x!=(-2) #creez vectorul logic y >y #afişez pe ecran vectorul y [1] TRUE TRUE TRUE FALSE TRUE #rezultat 2.1.4. Valori nedefinite

În anumite cazuri, componentele unui vector nu sunt cunoscute în totalitate. Când

un element al unui vector nu este “disponibil” sau este “nedefinit” în sens statistic, în locul lui se pune o valoarea speciala NA (not available). În general, orice operaţie cu NA generează tot un NA. Există însă şi funcţii care pot fi calculate chiar dacă datele de intrare conţin valori nedefinite.

Funcţia is.na(x) generează un vector logic de aceeaşi lungime ca x cu valoarea TRUE dacă şi numai dacă elementul corespunzator al lui x este NA. Un exemplu de utilizare a funcţiei is.na() este dat mai jos: >z<-c(1:3,NA) #creez vectorul z > ind<-is.na(z) #creez vectorul logic ind >ind #afişez pe ecran vectorul ind [1] FALSE FALSE FALSE TRUE #rezultat

Un alt tip de “valoare nedefinită” este NaN (not a number). Ea apare de exemplu în cazul operaţiilor de tipul 0/0 sau când rezultatul unei expresii este infinit (Inf). is.na(x) generează TRUE atât pentru NA cât şi pentru NaN. is.nan(x) generează TRUE doar pentru NaN. PROBLEME + + + + 1. Se dă vectorul x1=(1,0,1) şi vectorul x2=(0,0,1). Generaţi vectorul y1=x1/x2 şi y2=x2/x1. Utilizaţi funcţiile is.na() şi is.nan() pentru a determina câte valori nedefinite NA şi NaN conţin vectorii y1 şi y2.

Soluţie >x1<-c(1,0,1) #creez vectorul x1 >x2<-c(0,0,1) #creez vectorul x2 >y1<-x1/x2 #creez vectorul y1

>y2<-x2/x1 #creez vectorul y2 >y1 #afişez y1 [1] Inf NaN 1 #rezultat >is.na(y1) #afişez vectorul logic al valorilor nedefinite [1] FALSE TRUE FALSE #rezultat >y2 #afişez y2 [1] 0 NaN 1 #rezultat >is.na(y2) #afişez vectorul logic al valorilor nedefinite [1] FALSE TRUE FALSE #rezultat + + + + 2. Se dă vectorul x=(1,6,2,NA). Creaţi vectorul logic ale cărui elemente sunt TRUE pe poziţia ocupată de NA şi FALSE în rest. Înlocuţi NA cu -999. Creaţi vectorul z de aceiaşi lungime cu x ale cărui elemente sunt NA.

Soluţie >x<-c(1,6,2,NA) #creez vectorul x >y <-is.na(x) #vectorul logic >y [1] FALSE FALSE FALSE TRUE #rezultat >x[is.na(x)]<--999 #înlocuiesc NA cu -999 >x [1] 1 6 2 -999 #rezultat >z<-x==NA #toate elementele lui z sunt NA >z [1] NA NA NA NA #rezultat + + + + 3. Atribuiţi elementelor mai mari decât 4 ale vectorului x=(1,NA,6,2,10) valorile 101 si respectiv 102. Ce se întâmplă dacă pe poziţia lui NA din vectorul x incercăm să atribuim una dintre aceste valori?

Soluţie > x[!is.na(x)& x>4] <-c(101,102) #atribui 101 şi 102 >x [1] 1 NA 101 2 102 #rezultat Dacă se execută comanda >x[x>4]=c(101,102) se obţine mesajul de eroare: Error in x[x > 4] = c(101, 102): NAs are not allowed in subscripted assignment 2.1.5. Vectori de tip caracter

Vectorii de tip caracter sunt utilizaţi frecvent în aplicaţii grafice sau tabele. Ei sunt

secvenţe de caractere delimitate de ghilimele “ “. De exemplu, “x-values“, “new iterations“ sunt vectori de tip caracter. Caracterele sunt introduse utilizând fie simbolul “

sau simbolul ‘. În general secvenţa de caractere se termina cu simbolurile “\“sau “\\“. Pot fi utilizate însă şi simbolurile “\n“ (linie nouă), “\t“ (tab) sau “\b“ (backspace).

Vectorii de tip caracter pot fi concatenaţi utilizând funcţia c(). Funcţia paste() poate lua un număr arbitrar de argumente pe care le concatenează unul câte unul. Orice număr este transformat în caracter. Argumentele sunt separate de un singur caracter blanc. Caracterul blanc poate fi schimbat cu un şir de caractere prin intermediul argumentului sep. De exemplu, comanda >labs<-paste(c("X","Y"), 1:10,sep="") generează vectorul caracter labs= "X1" "Y2" "X3" "Y4" "X5" "Y6" "X7" "Y8" "X9" "Y10"

Funcţia strsplit() permite extragerea unor caractere dintr-un vector caracter utilizat ca argument. De exemplu, daca dorim să împărţim vectorul ‘abracadabra’ în subşiruri delimitate de caracterul ‘r’, se folosim comanda >strsplit(“abracadabra”, “r”) având ca rezultat vectorii caracter „ab”, “acadab” şi “a”. Funcţia ncar() permite determinarea numerelor de caractere din care este alcătuit un vector caracter. Funcţia sort() aranjază elementele unui vector caracter în ordine alfabetică. De interes este şi funcţia is.caracter() care ne permite să vedem dacă un anumit vector este de tip caracter. PROBLEME + + + + 1. Numele unei persoane este Popescu iar prenumele Ion. Scrieţi întregul nume într-un singur şir de caractere folosind funcţia paste ().

Soluţie. >nume<-“Popescu” #creez vectorul caracter nume >prenume<-”Ion” #creez vectorul caracter prenume >numeintreg<-paste(nume,prenume) #creez numele intreg >numeintreg #afişez numele intreg [1] “Popescu Ion” #rezultat + + + + 2. Numele a patru studenţi participanţi la un concurs sunt Vasile, Radu, Ilinca şi Aron. Aranjaţi aceste nume în ordine alfabetica folosind funcţia sort().

Soluţie >nume<-c(“Vasile”,”Radu”,”Ilinca”,”Aron”) #vectorul nume >sort(nume) [1] "Aron" "Ilinca" "Radu" "Vasile" #rezultat 2.1.6. Selectarea elementelor vectorilor. Vectori index

Submulţimi de elemente pot fi selectate prin asocierea vectorilor de tip index.

Aceştia pot fi de patru tipuri: logici, de numere întregi pozitive, de numere întregi

negative şi de tip caracter. Vectorii index trebuie să aibă aceeaşi lungime ca vectorii corespunzători ale căror elemente trebuie selectate.

Vectorii index logici au ca elemente şirurile de caractere TRUE şi FALSE. Valorile corespunzătoare lui TRUE sunt selectate iar cele lui FALSE sunt omise. De exemplu, pentru a selecta valorile definite ale vectorului x şi a le salva în vectorul y se foloseşte comanda >y<-x[!is.na(x)]

De asemenea, comanda >(x+1)[(!is.na(x))&x>0]->z generează un vector z care conţine elementele vectorului x+1 pentru care elementele corespunzătoare ale lui x sunt definite (NA or NaN sunt excluse) şi pozitive.

Vectorii index care au ca elemente numere întregi şi pozitive sunt des utilizaţi în R. Valorile vectorului index trebuie să fie în domeniul {1,2,…,length(x)}. Elementele cores-punzătoare vectorului sunt selectate şi concatenate în această ordine în vectorul rezultant. De exemplu, x[6] este al şaselea element al lui x iar x[1:10] primele 10 elemente ale lui x. De asemenea, comanda >c(“x”,”y”)[rep(c(1,2,2,1),times=4)] generează un vector de tip caracter de lungime 16 format din “x”,”y”,”y”,”x” repetat de patru ori.

Vectorii index pot conţine şi numere întregi negative. În acest caz sunt excluse elementele aflate pe aceeaşi poziţie cu numerele întregi şi negative din vectorul index. Astfel, comanda >y<-x[-(1:5)] generează vectorul y care conţine elementele lui x în afara de primele 5.

Vectorii index de caractere se aplică doar la obiecte care au nume atribuite pentru a identifica componentele lor. În acest caz un sub-vector al vectorului de nume poate fi utilizat în acelaşi mod ca numerele întregi pozitive din exemplul discutat anterior. Exemplul de mai jos arată modul în care se utilizează acest tip de vectori de tip index.: >fructe<-c(5,10,1,20) #generez interactiv vectorul fructe >nume(fructe)<-c(“portocale”,”banane”,”mere”,”piersici”) #numele fructelor >prinz<-fructe[c(“mere”,”portocale”)] #asociez numele

Exemplul de mai sus evidenţiază avantajul utilizării numelor sub formă alfanumerică în locul formei numerice. Este mai dificil să ţinem minte ca la prânz vom mânca fructele 1 şi 5 decât ca vom mânca mere şi portocale.

Vectorii de tip index pot fi utilizaţi şi în combinaţie cu diferite expresii. Aceaste expresii trebuie să fie de forma vector[index_vector]. Vectorul asociat trebuie să aibă aceiaşi lungimea ca vectorul index asociat. Dacă vectorul asociat este de tip logic atunci el trebuie să fie de aceeaşi lungime ca vectorul ce îl indexează. De exemplu, comanda >x[is.na(x)]<-0 înlocuieşte orice valoare nedefinită a lui x cu zero. Comanda >y[y<0]<-y[y<0]

are acelaşi efect ca >y<-abs(y) PROBLEME + + + + 1. Fie vectorul x=(1,NA,2,NA). Să se creeze vectorul y care conţine doar elementele definite ale lui x.

Soluţie >x<-c(1,NA,2,NA) #creez vectorul x >y<-x[!is.na(x)] #selectez valorile definite şi le scriu în y >y #afişez y [1] 1 2 #rezultat + + + + 2. Se dă vectorul x=(-7,1,NA,NA,8). Creaţi vectorul y care conţine elementele definite ale lui x plus valoarea 5.

Soluţie >x<-c(-7,1,NA,NA,8) #creez vectorul x >(x+5)[(!is.na(x)) & x>0] ->y #creez vectorul y >y #afişez y [1] -2 13 #rezultat + + + + 3. Creaţi vectorul x ce conţine numerele de la 1 la 30 în ordine crescătoare. Afişaţi pe ecran elementul 10 al lui x şi elementele de la poziţia 11 la poziţia 15.

Soluţie >x<-seq(1:30) #creez vectorul x >x[10] #afişez al 10-lea element [1] 10 #rezultat >x[11:15] #afişez elementele de la 11 la 15 [1] 11 12 13 14 15 #rezultat + + + + 4. Se dă vectorul numeric x=(3,11,8,15,12). Creaţi vectorii y1 care să conţină elementele lui x de pe poziţia 2 şi 4 şi vectorul y2 care să nu conţină elementele lui x de pe aceste poziţii.

Soluţie :x<-c(3,11,8,15,12) #creez vectorul x >y1<-x[c(2,4) #vectorul y1 >y1 [1] 11 15 #rezultat >y2<-x[-c(2,4)] #vectorul y2 >y2 [1] 3 8 12 #rezultat

+ + + + 5. Elementele vectorilor pot fi specificate şi prin şiruri de caractere. De exemplu, vectorul v=(100,200,300) poate fi scris astfel: v=(a=100,b=200,c=300). Extrageţi al doilea şi al treilea element al lui v si scrieţi aceste elemente în vectorul numeric v1.

Soluţie >v=c(a=100,b=200,c=300) >v1=v[c(‘’b’’,’’c’’)] >v1 b c 200 300 #rezultat 2.2. Modul, lungimea şi clasa obiectelor limbajului R

Entităţile limbajului R sunt referite, din punct de vedere tehnic, ca obiecte.

Vectorii numerici, logici sau de tip caracter, definiţi în sectiunea precedentă, sunt exemple de obiecte R. În R pot fi definiti şi vectori de numere complexe. Pe lângă vectori, matricele, factorii, listele, tablourile (data frames) şi funcţiile sunt obiecte utilizate uzual în R.

Vectorii trebuie să conţină elemente de acelaşi tip (mod). Acestea pot fi numere (reale, întregi sau complexe), caractere sau simboluri logice. Nu este permis amestecul acestor tipuri în cadrul unui singur vector. Singura excepţie de la această regulă este simbolul NA (not available) or NaN (not a number). Un vector poate să conţină doar blank-uri şi să aibă totuşi un mod. De exemplu, funcţia character() generează un vector caracter care conţine doar blank-uri. În mod similar funcţia numeric() crează un vector numeric care conţine de asemenea blank-uri.

Listele sunt alte obiecte din R care operează sub modul list. Acestea sunt secvenţe ordonate de obiecte care individual pot fi de orice tip. Listele sunt cunoscute ca “recursive” şi nu ca “structuri atomice” cum sunt vectorii. Componentele listelor pot fi ele însele liste.

Funcţiile şi expresiile sunt de asemenea structuri recursive ale limbajului R. Funcţiile predefinite sunt obiecte care fac parte din sistemul R. Funcţiile scrise de utilizator sunt de asemenea obiecte R.

O proprietate importantă a unui obiect R este lungimea sa. Funcţiile length (object) sau mode (object) pot fi utilizate pentru a găsi modul şi lungimea unei anumite structuri. De exemplu, dacă x este un vector format din 100 de numere reale, atunci funcţia mode(x) returnează şirul de caractere “numeric” iar funcţia length(x) numărul 100. Există posibilitatea de a transforma un obiect de un anumit mod într-un obiect de alt mod folosind funcţii de forma as.something(). De exemplu, vectorul numeric x, poate fi transformat într-un vector de tip caracter folosind funcţia as.character(x). Există o colecţie mare de funcţii atât pentru transformarea modului unui obiect R cât şi pentru investirea obiectelor R cu atribute pe care nu le poseda încă.

Un obiect R care conţine doar blank-uri (empty object) poate avea o lungime definită. De exemplu, comanda >e<-numeric() crează vectorul numeric e care conţine doar blank-uri (empty). În mod similar comanda >v<-character()

crează vectorul caracter v care conţine de asemenea blank-uri (empty). Odată un obiect creat, se pot crea noi componente adăugând un indice în afara intervalului în care a fost iniţial definit. De exemplu, dacă e este vectorul numeric “vid” creat anterior comanda >e[3]<-7 va atribui celei de-a treia componente a lui e valoarea 7 iar primelor două valoarea NA. Această regulă se aplică la orice structură, cu condiţia ca acele componente adiţionale să fie de acelaşi tip cu ale obiectului iniţial. Această ajustare automată a lungimii unui obiect se utilizează foarte des atunci când folosim funcţia input scan ().

Pentru a trunchia mărimea unui obiect este necesară doar o simpla asociere a unui indice.

De exemplu dacă x este un obiect de lungime 10, atunci comanda >x<-x[1:5] transforma x într-un vector de lungime 5 care conţine elementele de la 1 la 5 ale vechiului vector x. În mod similar putem reţine primele 5 valori ale lui x cu comanda >length(x)<- 5

Funcţia attributes(object) returnează lista tuturor atributelor asociate la un moment dat unui obiect R. Funcţia attr(object.name) poate fi utilizată pentru a selecta un atribut specific.

De exemplu, dacă x este un vector numeric de 10 elemente, secvenţa urmatoare de comenzi >x <- 1:10 >attr(x,"dim") <- c(2, 5) transformă x într-o matrice cu două linii şi cinci coloane. În mod similar se pot transforma atributele diferitelor obiecte din R.

Toate obiectele din R aparţin unei anumite clase. Pentru vectorii simpli clasa poate fi numeric, caracter sau logic. Listele sunt un alt exemplu de clasă. Clasa unui obiect se determină cu funcţia class() care returnează caractere precum “matrix”, “array”, “factor” sau “data.frame”. Obiectele R pot avea şi clase definite cu ajutorul anumitor funcţii. De exemplu funcţia lm() produce obiecte de clasa lm.

Cunoaşterea clasei obiectului este utilă pentru programarea orientată pe obiecte . De exemplu dacă un obiect are clasa “data.frame”, el va fi interpretat într-un anumit mod de către funcţia plot(). De asemenea funcţia summary() va reacţiona în acord cu clasa obiectului.

Pentru a anula efectele funcţiei class() se utilizează funcţia unclass(). PROBLEME + + + + 1. Creaţi vectorul x=(1.1, -7.2, 1.9, -3.4) folosind funcţia de concatenare c(). Determinaţi modul şi lungimea vectorului x.

Soluţie >x=c(1.1, -7.2, 1.9, -3.4) #creez vectorul x >length(x) # determin lungimea lui x [1] 4 #rezultat >y=as.character(x) #construiesc vectorul character y cu elementele lui x >y #afişez pe ecran

[1] "1.1" "-7.2" "1.9" "-3.4" #rezultat + + + + 2. Transformaţi vectorul numeric x din problema precedentă într-un vector care să conţină partea întreagă a elementelor lui x.

Soluţie >x=c(1.1, -7.2, 1.9, -3.4) #creez vectorul x >y=as.integer(x) #construiesc vectorul de nr întregi >y #afişez pe ecran [1] 1 -7 1 -3 #rezultat + + + + 3. Creaţi vectorul numeric x ale cărui elemente sunt blank-uri. Atribuiţi lui x[6] valoarea 5. Care este lungimea lui x? Care sunt componentele acestui vector? Reduceţi lungimea lui x la 3. Ce componente obtineţi?

Soluţie >x<-numeric() #creez vectorul “vid” x >x[6]=5 #atribui valorea 5 lui x(6) >x #afişez vectorul x [1] NA NA NA NA NA 6 #rezultat >length(x) #determin lungimea lui x [1] 6 #rezultat >x<-x[1:3] #reduc lungimea lui x la 3 >x #afişez pe x [1] NA NA NA #rezultat + + + + 4. Construiţi vectorul x care conţine şirul numerelor întregi de la 1 la 10. Transformaţi vectorul x într-o matrice de două linii şi 5 coloane.

Soluţie >x<-seq(1:10) #creez vectorul x >attr(x,"dim") <- c(2, 5) #transform x în matrice >x #afişez x [,1] [,2] [,3] [,4] [,5] #rezultat [1,] 1 3 5 7 9 [2,] 2 4 6 8 10

Observaţi ordinea în care elementele vectorului au fost trasformate. Se completează coloanele în ordine crescătoare. + + + + 5. Creaţi vectorul x=(1,7,2,9) cu ajutorul funcţiei c(). Determinaţi clasa lui x cu ajutorul funcţiei class().

Soluţie >x<-c(1,7,2,9) #creez vectorul x >class(x) #determin clasa lui x [1] “numeric” #rezultat + + + + 6. Creaţi vectorul x=(1,8,5,4) cu ajutorul funcţiei c(). Determinaţi clasa vectorilor y1=as.integer(x), y2=as.character(x), y3=as.data.frame(x).

Soluţie >x=c(1,8,5,4) #creez vectorul x >y1=as.integer(x) #creez y1 >y2=as.character(x) #creez y2 >y3=as.data.frame(x) #creez y3 >class(y1) #determin clasa lui y1 [1] “integer” #rezultat >class(y2) #determin clasa lui y2 [1] “character” #rezultat >class(y3) #determin clasa lui y3 [1] “data frame” #rezultat 2.3. Factori

Conceptual, factorii in R sunt variabile care iau un numar limitat de valori diferite. Factorii sunt des utilizaţi în modelarea statistică. Factorii în R sunt reprezentaţi intern ca valori întregi 1,2,3,...k, unde k este numărul de niveluri. Funcţia factor() este folosită pentru a crea obiecte R de tip factor. Atât variabilele numerice cât şi cele de tip caracter pot fi transformate în factori. Nivelurile unui factor sunt întotdeauna şiruri de caractere. Factorii pot fi utilizaţi atât pentru ordonarea cât şi pentru dezordonarea elementelor vectorilor. Neordonarea este necesară atunci când vrem să aranjăm elementele unui vector după o anumită funcţie de distribuţie.

Introducem noţiunea de factor printr-un exemplu specific. Presupunem că la o anumită facultate avem 10 studenţi care platesc taxe de studii. Aceşti studenţi sunt identificaţi prin numele localitaţii de unde provin, nume care sunt componetele vectorului de tip caracter nume creeat cu comanda >nume<-c("buc","bras","const","buc","buc","tim","gal","tim","gal","ias")

Presupunem că dorim să ştim din câte localităţi distincte provin studenţii consideraţi în analiza noastră. În acest scop utilizăm funcţia factor() care selectează elementele distincte ale unui vector, numite nivelurile acelui vector. În exemplul nostru comanda >numef<-factor(nume) generează obiectul de clasa “factor” numef. Conţinutul lui numef se afişează pe ecran cu comanda >-numef având ca rezultat: [1] buc bras const buc buc tim gal tim gal ias Levels: bras buc const gal ias tim Comanda >levels(numef) generează lista localitatilor în ordine alfabetică [1] "bras" "buc" "const" "gal" "ias" "tim"

Aranjarea şirurilor de caractere în ordine alfabetică se poate face şi cu funcţia sort().

De o importanţă deosebită în manipularea factorilor este funcţia tapply(). Introducem această funţie printr-un exemplu simplu. Presupuneam că studenţii a căror localitate de origine este dată de vectorul >nume=c("buc","bras","const","buc","buc","tim","gal","tim","gal","ias") beneficiază de bursele menţionate în vectorul >bursa=c(60,49,40,61,64,60,59,54,62,69).

Presupunem că suntem interesaţi să ştim valoarea burselor medii şi erorilor standard corespunzătoare fiecărui oraş în parte. În acest scop se foloseşte funcţia tapply(). Mai întâi, se calculează numef=factor(nume) şi apoi se determină bursa medie cu comanda >bursamedie<-tapply(bursa,numef,mean)

Rezultatul este bras buc const gal ias tim #nivelurile (oraşele distincte în ordine alfabetică) 49.00 61.66 40.00 60.50 69.00 57.00 #bursele medii corespunzătoare

Funcţia tapply() este utilizată aici pentru a aplica o funcţie, aici mean(), pentru a grupa componentele primului argument, aici bursa, definită de nivelurile celei de-a doua componente, aici numef, ca şi cum ar fi structuri vectoriale separate. Rezultatul este un vector de lungime egală cu numărul nivelurilor. Dacă vrem să calculăm mai departe eroarea standard a mediei burselor pe oraşe, determinăm varianţa cu funcţia var() şi calculăm eroarea standard cu >stderr<-function( x ){sqrt(var(x))/length(x)} Comanda >bursaster<-tapply(bursa,numef,stderr) generează obiectul bursaster al cărui conţinut este prezentat mai jos. bras buc const gal ias tim #nivelurile (oraşe distincte) NA 0.69 NA 1.06 NA 2.12 #eroarea standard

Valorile NA corespund cazului în care calculul erorii standard nu a fost posibil deoarece numărul studenţilor a fost mai mic sau egal cu unu. Ca un exerciţiu se poate calcula nivelul de semnificaţie al burselor medii. Trebuie utilizate încă o dată funcţiile tapply( ) şi length() precum şi funcţia qt() pentru a găsi procentul punctelor distribuţiei t corespunzătoare.

Funcţia tapply() poate fi utilizată pentru a efectua operaţii cu vectori cu structuri mult mai complicate. Putem complica exemplul de mai sus prin separarea studenţilor după sex şi localitate sau după alte criterii. Pentru fiecare nivel în parte se calculează apoi diferite mărimi statistice. Factorii ordonaţi (ordered factors) se obţin practic prin ordonarea nivelurilor. Pentru a creea un factor ordonat, sau pentru a ordona un factor existent se utilizează funcţia ordered(). Nivelurile unui factor ordonat specifică poziţia acestora pe o scară ordinară. Pe lângă factorii ordonaţi se utilizează şi factorii de contrast (factor contrasts). Aceştia din urmă se utilizează deseori în contextul fitării modelelor matriciale. PROBLEME + + + + 1. Creaţi vectorul caracter nume=(Ion”, “Vasile”, “Gelu”, “Grigore”). Ordonaţi alfabetic elementele acestui vector.

Soluţie

> nume=c(Ion”, “Vasile”, “Gelu”, “Grigore”) #creez vectorul nume >numes=sort(nume) #ordonez alfabetic >numes #afişez pe ecran [1] "Gelu" "Grigore" "Ion" "Vasile" #rezulatul + + + + 2. Studenţii participanţi la o conferinţă ştiinţifică internaţională provin din ţările precizate în vectorul tari=(“rom”,”rom”,”bul”,”bul”,”usa”,”rom”,”rus”,”mol”,”rus”,”mol”,”ung”). Cu ajutorul funcţiei factor(), determinaţi numărul de ţări distincte din care provin participanţii la conferinţă.

Soluţie >tari=c("rom","rom","bul","bul","usa","rom","rus","mol","rus","mol","ung”) #creez vectorul >tarif<-factor(tari) #creez factorul >levels(tarif) #listez nivelurile [1] "bul" "mol" "rom" "rus" "ung" "usa" #rezultat + + + + 3. Presupunem ca la un concurs sportiv participă 10 sportivi din România (rom), Bulgaria (bul) şi Ungaria (ung). Ordinea intrării în concurs este ord=(“rom”, “rom”, “ung”,”bul”, “bul”,”ung”,”bul”,”rom”,”ung”,”bul”) iar punctele corespunzătoare câştigate puncte =(10,12,1,7,9,8,10,2,9,1). Calculaţi punctajul mediu pe fiecare ţară.

Soluţie >ord=c("rom", "rom", "ung","bul", "bul","ung","bul","rom","ung","bul") #creez vectorul cu care sportivii intră în concurs >puncte=c(10,12,1,7,9,8,10,2,9,1) #punctele obţinute >ordf=factor(ord) #calculez factorul >punctemedie=tapply(ordf,puncte,mean) #calculez media de puncte pe tara >punctemedie #afişez punctele medii bul rom ung #rezultatul 6.75 8.00 6.00 + + + + 4. Stresul la care este supus un grup de pacienţi dintr-un spital se încadrează in trei clase: jos, mediu si inalt. Folosind funcţia rep() creaţi factorul nivel.stress=(‘jos’,’mediu’, ‘inalt’,’jos’,’mediu’,’inalt’). Creaţi factorul ordonat din factorul nivel.stress folosind funcţia ordered().

Soluţie >nivel.stress<-rep(c("jos","mediu","inalt"),2) #creez nivel.stress >ord.stress=ordered(nivel.stress,levels=c("jos","mediu","inalt")) #creez factorul ordonat >ord.stress [1] jos mediu inalt jos mediu inalt #rezultat Levels: jos < mediu < inalt > ord.stress>="mediu" #stress mai mare sau egal cu nivelul mediu [1] FALSE TRUE TRUE FALSE TRUE TRUE #rezultat

> ord.stress<"mediu" #nivel stress mai mic ca mediu [1] TRUE FALSE FALSE TRUE FALSE FALSE #rezultat 2.4. Matrice

O matrice este un tablou bidimensional ale cărui elemente sunt numere. O matrice de

n linii şi m coloane are dimensiunea n x m. Dimensiunea unei matrice se obţine cu funcţia dim(). Funcţiile ncol() şi nrow() returnează numărul de coloane şi respectiv numărul de linii al unei matrice. Funcţia diag() depinde de argument. Dacă v este un vector, diag(v) produce o matrice cu elementele lui v pe diagonală şi zero în rest. Dacă X este o matrice diag(X) produce un vector cu elementele diagonalei lui M. Dacă k este o valoare numerică diag(k) este matricea identitate de dimensiune k x k.

Matricele pot fi construite din vectori cu funcţiile rbind() şi cbind(). cbind() formează matrice unind vectorii pe orizontală (unul lângă celălalt), ori pe coloane, iar rbind() pe verticală (unul sub celălalt), sau pe linii. Aceste funcţii pot fi utilizate de asemenea pentru a adauga coloane sau linii noi la matrice deja existente sau pentru a compacta matricile între ele. Rezultatul aplicării funcţiilor rbind() şi cbind() este întotdeauna o matrice.

Elementele unei matrice pot fi extrase individual prin specificarea liniei şi a coloanei corespunzătoare. De exemplu, dacă X este o matrice de dimensiune n x m elementul de pe poziţia (i,j) se extrage cu comanda >a=X[i,j] #atribui X[i,j] lui a

Toate elementele unei anumite coloane, j, se pot scrie într-un vector folosind comanda >v=X[,j] #elementele coloanei j sunt scrise în vectorul v

În mod similar elementele liniei i se scriu în vectorul v cu comanda >v=X[i,] #elementele liniei i sunt scrise în vectorul v

Se pot extrage şi blocuri ale matricei X care apoi sunt scrise în matrice de dimensiuni mai mici. De exemplu, comanda >XX=X[i1:i2,j1:j2] generează matricea de dimensiune (i2-i1+1 x j2-j1+1) ale cărei elemente sunt elementele matricei X din liniile i1, i1+1, ..i2 şi j1. j1+1,...j2.

Elementele unei matrice pot fi manipulate cu ajutorul funcţiei array(). Următorul exemplu ne ajută să înţelegem modul de utilizare al acestei funcţii. Fie X o matrice de 4 linii şi 5 coloane. Presupunem că vrem să extragem elementele X[1,3], X[2,2], şi X[3,1] şi să le punem într-un vector y iar în locul lor în matricea X să punem valoarea 0. Generăm mai întâi matricea X. >X<-array(1:20, dim=c(4,5)) iar apoi vectorul de selecţie, >i<-array(c(1:3,3:1),dim=c(3,2))

Elementele dorite ale lui X, adică X[1,3], X[2,2], şi X[3,1], se extrag simplu cu comanda >X[i]

Elementele extrase ale lui X se completeaza apoi cu zero. >X[i]<-0

Nu sunt permişi indici negativi. Liniile indexate cu zero sunt ignorate.

Limbajul R permite efectuarea operaţiilor cu matrice. Mai jos sunt listate câteva operaţii matematice care se pot efectua în R cu două matrice oarecare, A şi B, de dimensiuni compatibile. >A%*%B #produsul (după definiţia din algebra liniară) >A*B #produsul element cu element >A+B #suma element cu element >A-B #diferenţă element cu element >A/B #împarţire element cu element

În cursul acestor operaţii pot rezulta elemente de tipul NA, NaN or Inf. Acestea pot fi identificate cu funcţii specializate cum ar fi is.na().

Inversa unei matrice se calculează simplu, folosind funcţia solve(). Dacă A este o matrice pătratică nesingulară, atunci inversa AI se determină cu comanda >AI=solve(A)

Se pot rezolva uşor ecuaţii matriceale folosind funcţia solve(). Vectorii şi valorile proprii ale unei matrice simetrice se calculează cu ajutorul

funcţiei eigen(). Rezultatul acestei funcţii este o listă care conţine vectorii şi valorile proprii ale matricei analizate. Un exemplu de calcul al vectorilor şi valorilor proprii ai unei matrice simetrice SM este dat de secvenţa de comenzi de mai jos. >e=eigen(SM) #calculez vectorii şi valorile proprii ai lui SM (şi rezultatul este pus în lista e) >eva=e$val #extrag din listă vectorul valorilor proprii >eve=e$vec #extrag din listă matricea vectorilor proprii

Alternativ, se pot calcula direct valorile sau vectorii proprii cu urmatoarea secvenţă de comenzi: >eva<-eigen(SM)$values #valorile proprii >eve<-eigen(SM)$vec #vectorii proprii

Pentru matrice mari este bine să evităm calcularea vectorilor proprii dacă nu este strict necesară. În acest caz se utilizează comanda >eva<-eigen(SM,only.values=TRUE)$values

Descompunerea în valori singulare (SVD-singular value decomposition) este o altă operaţie care se poate efectua în R. Funcţia svd(M) calculează SVD-urile matricei M. Acestea constau dintr-o matrice ortonormală U cu acelaşi număr de coloane ca M, o matrice ortonormală V în care numărul de coloane este egal cu numărul de linii ale lui M şi o matrice diagonală D de numere pozitive astfel incât M=U%*%D%*%t(V). Funcţia svd() returnează un vector ce conţine elementele diagonalei matricii D.

Există multe alte operaţii cu matrice care se pot efectua uşor în R. Acestea vor fi prezentate gradual în contextul analizei statistice a diferitelor date. PROBLEME + + + + 1. Se dă vectorul x=(1,2,3,4,5,6). Folosind funcţia dim() transformaţi vectorul x într-o matrice de 2 linii şi 3 coloane. Scrieţi elementele coloanei 1 într-un vector y1 şi elementele liniei 2 într-un vector y2 şi afişaţi conţinutul acestor vectori pe ecran. Soluţie >dim(x)<-c(2,3) #transform vectorul x în matrice 2x3 >y1=x[,1] #scriu prima coloana în vectorul y1

>y2=x[2,] #scriu prima coloana în vectorul y1 >y1 #afişey y1 [1] 1 2 #rezultat >y2 #afişey y2 [1] 2 4 6 #rezultat + + + + 2. Fie vectorul x ale cărui componente sunt numerele întregi de la 1 la 16 în ordine crescătoare. Transformaţi vectorul x într-o matrice cu patru linii şi patru coloane folosind funcţia dim(). Scrieţi elementele x[1,1], x[1,4], x[4,1] şi x[4,4] într-o matrice de dimensiune 2x2. Soluţie >x=seq(1:16) #construiesc vectorul x >dim(x)=c(4,4) #transform x în matrice 4x4 >vc=c(1,4) #vectorul selectie coloana >vl=c(1,4) #vectorul selectie linie >m=x[vl,vc] #selectez elementele specificate în vl şi vc >m #listez m [,1] [,2] #rezultat [1,] 1 13 [2,] 4 16

+ + + + 3. Se dă matricea

=

6251

A şi

=

8473

B. Compactaţi A şi B utilizând funcţiile

cbind() şi rbind(). Soluţie >C<-rbind(A,B) #concatenez A şi B pe linii >C #afişez C [,1] [,2] #rezultat [1,] 1 5 [2,] 2 6 [3,] 3 7 [4,] 4 8 >D=cbind(A,B) #concatenez A şi B pe coloane >D #afişez D [,1] [,2] [,3] [,4] #rezultat [1,] 1 5 3 7 [2,] 2 6 4 8

+ + + + 4. Se dă matricea

=

6251

A. Adăugaţi o coloană la A care să conţină numărul 10.

Adăugaţi o linie la A care să conţină numărul 20. Soluţie >B=cbind(10,A) #se adaugă o coloana cu cifra 10 >B #afişez rezultatul [,1] [,2] [,3] #rezultat

[1,] 10 1 5 [2,] 10 2 6 >C=rbind(20,A) #se adaugă o linie cu cifra 20 >C #afişez rezultatul [,1] [,2] #rezultat [1,] 10 10 [2,] 1 5 [3,] 2 6 + + + + 5. Generaţi matricea X de 10 linii şi 10 coloane conţinând numerele de la 1 la 100 folosind funcţia dim(). Creaţi un vector care să conţină elementele X[1,3], X[2,2] şi X[3,1]. Soluţie >X<-seq(1:100) #creez şirul 1-100 >dim(X)=c(10,10) # transform X în matrice >i<-array(c(1:3,3:1),dim=c(3,2)) #vectorul de ordine >y=X[i] #creez vectorul cu elementele extrase >y #afişez pe ecran selecţia [1] 21 12 3 #rezultatul + + + + 6. Utilizând funcţia matrix() generaţi matricele A, B şi C de două linii şi trei coloane conţinând numerele de la 1 la 6, 11 la 16 şi respectiv 101 la 106. Calculaţi 2*A*B+C+10. Soluţie >x1=seq(1,6) #creez x1 >x2=seq(11,16) #creez x2 >x3=seq(101,106) #creez x3 >A=matrix(x1,2,3) #matricea A >B=matrix(x2,2,3) #matricea B >C=matrix(x3,2,3) #matricea C >D=2*A*B+C+10 #efectuez inmultirea element cu element >D #scriu rezultatul pe ecran [,1] [,2] [,3] #rezultat [1,] 133 191 265 [2,] 160 226 308 + + + + 7. Se dă vectorul de date x=(1.2,-2.5,-2.5,1.2). Transformaţi acest vector într-o matrice de două linii şi două coloane şi calculaţi vectorii şi valorile proprii ale acestei matrice. Soluţie >m=matrix(x,2,2) #creez matricea m >e=eigen(m) #calculez vectorii şi valorile proprii >eva=e$val #vectorul valorilor proprii >eva #afişez valorile proprii [1] 3.7 -1.3 #rezultat >evec=e$vec #vectorul valorilor proprii

>evec #afişez vectorii proprii [,1] [,2] #rezultat [1,] -0.7071068 -0.7071068 [2,] 0.7071068 -0.7071068 + + + + 8. Calculaţi inversa matricei din problema precedentă. Soluţie >mi=solve(m) #calculez inversa lui m >mi #afişez rezultatul [,1] [,2] #rezultat [1,] -0.2494802 -0.5197505 [2,] -0.5197505 -0.2494802 + + + + 9. Să se transforme vectorul x=(1,2,3,4,5,6) într-o matrice de 3 linii şi 2 coloane folosind funcţia matrix(). Soluţie >m<-matrix(x,3,2) #creez matricea m >m #afişez m [,1] [,2] [1,] 1 4 [2,] 2 5 [3,] 3 6 2.5. Tablouri de numere

Tablourile de numere (arrays) sunt generalizări ale matricelor la dimensiuni mai

mari sau egale cu trei. De exemplu, dacă vectorul x are 1500 elemente comanda >dim(x)<-c(3,5,100) generează un tablou tridimensional de numere de dimensiune 3 x 5 x 100 ale cărui elemente sunt componentele vectorului x. Ordinea de parcurgere a elementelor unui tablou de numere este cea utilizată în FORTRAN, adică primul indice mergând cel mai repede şi ultimul cel mai încet. De exemplu dacă vectorul x cu 24 de elemente este transformat într-un tablou de numere, notat cu m, de dimensiune dimensiune(3,4,2) ordinea elemetelor în m este m[1,1,1]=a[1], m[2,1,1]=a[2]....m[3,4,2]=a[24].

Vectorii pot fi transformaţi în tablouri şi cu ajutorul funcţiei array(). Presupunem că X este un tablou numeric pe care vrem să îl construim din vectorul numeric data_vector. În acest scop vom utiliza comanda >X<-array(data_vector,dim_vector) unde dim_vector este dimensiunea tabloului. De exemplu, dacă vectorul v are 24 de componente, comanda >X<-array(v,dim=c(3,4,2)) va aranja elementele vectorului v într-un tablou format din 3 matrice de dimensiune 4 x 2. Dacă lungimea lui v este exact 24, atunci rezultatul este echivalent cu acela al comenzii >dim(X)<-c(3,4,2)

Dacă lungimea vectorului v este mai mica decât 24 atunci valorile vor fi ciclate până când toate cele 24 de poziţii vor fi completate. Comanda >X<-array(0,c(3,4,2)) generează un tablou de dimensiune (3,4,2) ale cărui elemente sunt egale cu zero.

Tablourile pot fi utilizate în diferite operaţii aritmetice, multe dintre acestea fiind similare celor descrise pentru matrice. Se pot efectua de asemenea operaţii între tablouri numerice şi alte obiecte R cum ar fi vectorii sau matricele. Dacă A şi B sunt două tablouri numerice atunci produsul lor exterior (outer product) va fi un tablou numeric ale cărui elemente se obtin prin formarea tuturor combinaţiilor posibile ale elementelor lui A şi B. Simbolul pentru acest tip de produs este “%0%”. >AB<-A%0%B sau echivalent >AB<-outer(A,B,”*”)

De remarcat că produsul definit de simbolul “%*%” este diferit de produsul reprezentat prin simbolul %0%.

Funcţia aperm() poate fi utilizată pentru a permuta dimensiunile unui tablou numeric. Argumentul perm este o permutare de numere întregi {1,2,…,k} unde k este numărul de indici ai tabloului numeric. Rezultatul acestei funcţii este un tablou numeric de aceeaşi dimensiune dată de perm[j] care devine noua j-dimensiune. Cel mai uşor este să vedem această instrucţiune ca pe o transpusă generalizată. Dacă A este o matrice atunci, >B<-aperm(A,c(2,1)) este transpusa lui A. Pentru acest caz simplu există funcţia t() care transpune direct matricea A >B<-t(A) PROBLEME

+ + + + 1. Utilizând funcţia array() generaţi tabloul numeric de dimensiune (3,3,2) din vectorul x care conţine numerele de la 1 la 18 în ordine crescătoare. Soluţie >x<-seq(1,18) #creez vectorul x >X<-array(x,dim=c(3,3,2)) #creez tabloul X >X #afişez pe ecran conţinutul , , 1 #rezultat [,1] [,2] [,3] [1,] 1 4 7 [2,] 2 5 8 [3,] 3 6 9 , , 2 [,1] [,2] [,3] [1,] 10 13 16 [2,] 11 14 17 [3,] 12 15 18

+ + + + 2. Se dă vectorul x=(1,2,3,4,5,6). Cu ajutorul funcţiei dim() transformaţi acest vector într-o matrice de 2 linii şi trei coloane. Soluţie >x<-c(1,2,3,4,5,6) #creez vectorul x >dim(x)=c(2,3) #transform x în matrice 2x3 >x #afişez x [,1] [,2] [,3] #rezultat [1,] 1 3 5 [2,] 2 4 6 + + + + 3. Să se transforme vectorul numeric x=(1,2,3,4,5,6,7,8) într-un tablou de dimensiune 2x2x2. Soluţie >x=c(1,2,3,4,5,6,7,8) #creez vectorul x >t<-array(x,dim=c(2,2,2)) #creez tabloul t de dim 2x2x2 >t #afişez t , , 1 #rezultat [,1] [,2] [1,] 1 3 [2,] 2 4 , , 2 [,1] [,2] [1,] 5 7 [2,] 6 8 + + + + 4. Fie vectorii x=(1,2,3,4) şi y=(5,6,7,8). Transformaţi aceşti vectori în matrice de două linii şi două coloane cu ajutorul funcţiei dim(). Calculaţi x%*%y şi x*y. Soluţie. >x=c(1,2,3,4) #creez vectorul x >y=c(5,6,7,8) #creez vectorul y >dim(x)=c(2,2) #creez matricea x >dim(y)=c(2,2) #creez matrice y >p1=x%*%y #produsul lui x cu y >p1 #scriu pe ecran rezultatul [,1] [,2] #rezultat [1,] 23 31 [2,] 34 46 >p2=x*y #produsul (element cu element) al lui x cu y >p2 #afişez pe ecran rezultatul [,1] [,2] #rezultat [1,] 5 7 [2,] 6 8 + + + + 5. Se dau vectorul x=(1,2,3,4,5,6,7,8) şi vectorul y=(9,10,11,12,13,14,15,16). Să se transforme aceşti vectori în tablouri de dimensiune 2x2x2 cu ajutorul funcţiei array(). Efectuaţi produsul t1*t2 şi t2*t1.

Soluţie >t1=array(x,dim=c(2,2,2)) #creez t1 >t2=array(y,dim=c(2,2,2)) #creez t2 >p1=t1*t2 #produsul element cu element >p1 #afişez rezultatul , , 1 #rezultat [,1] [,2] [1,] 9 33 [2,] 20 48 , , 2 [,1] [,2] [1,] 65 105 [2,] 84 128 >p2=t2*t1 #produsul t2 cu t1 >p2 #este egal cu p1 + + + + 6. Se dă vectorul x=(1,2,3,4,5,6,7,8,9). Transformaţi acest vector într-o matrice de dimensiune 3x3 şi într-un tablou numeric de dimensiune 1x3x3. Calculaţi transpusa matricei cu funcţia t() şi a tabloului numeric cu aperm(). Soluţie >m=matrix(x,3,3) #construiesc matricea >b=t(m) #transpusa >b #afişez pe ecran [,1] [,2] [,3] #rezultat [1,] 1 2 3 [2,] 4 5 6 [3,] 7 8 9 >t=array(x,dim=c(1,3,3)) #creez tabloul >b=aperm(t) #transpun >b #afişez pe ecran , , 1 #rezultat [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6 [3,] 7 8 9 2.6. Liste şi tablouri de date

O listă în R este o colecţie de obiecte ordonată după anumite criterii. Aceste obiecte se numesc componentele listei. Componentele unei liste nu sunt în mod necesar de aceeaşi clasă. Acestea pot fi vectori numerici, logici sau caracter, matrice, funcţii etc. Exemplul următor arată modul în care se poate crea o listă.

Presupunem că familia Popescu este formată din cinci membri, tatăl Ion, soţia Maria şi trei copii Ion, Vasile şi Andrea în vârstă de 4, 7 şi respectiv 9 ani. Această informaţie poate fi stocată în lista Lst construită cu ajutorul comenzii

>Lst<-list(nume=”Ion”, sotie=”Maria”, nr.copii=3, virsta.copii=c(4,7,9)) Componentele listei sunt întotdeauna numerotate şi pot fi identificate după

indicele corespunzator. În cazul nostru Lst este numele unei liste cu patru componente care pot fi identificate individual prin Lst[[1]], Lst[[2]], Lst[[3]] şi Lst[[4]]. Dacă Lst[[4]] este un vector, de exemplu, atunci Lst[[4]][1] este primul element al acestui vector.

Lungimea listei, adică numărul de obiecte din lista respectivă, se obţine cu funcţia >length(nume_lista) #nume_lista este Lst în cazul nostru

Componentele listei pot fi de asemenea denumite. Ele pot fi apelate fie după nume, care sunt şiruri de caractere între două paranteze pătrate, fie prin expresii de forma > nume_lista$numele_componentei_listei

A doua variantă este cel mai des utilizată. În cazul exemplului de mai sus Lst$nume este echivalent cu Lst[[1]] şi este şirul de caractere “Ion”. Lst$sotie este echivalent cu Lst[[2]] şi este şirul de caractere “Maria”. Lst$virsta.copii[1] este echivalent cu Lst[[4]][1] şi este numărul 4. Se poate de asemenea utiliza numele componentelor listelor scrise între paranteze patrate. De exemplu, Lst[[“nume”]] este echivalent cu Lst$nume.

Este important să facem distincţie între Lst[[1]] şi Lst[1]. Operatorul “[[..]]” este utilizat pentru a selecta un singur element în timp ce “[..]” este un operator de indexare general. Astfel, “[[..]]” este o componentă a listei Lst. “[..]” este o sublistă a listei Lst constând doar din primul element. Este o listă denumită şi numele este transferat acestei subliste.

Numele componentelor listelor pot fi prescurtate la un număr minim de caractere pe care le poate identifica în mod unic. Astfel Lst$coefficients este echivalent cu Lst$coe iar Lst$covariance cu Lst$cov.

Liste noi pot fi construite din obiecte R deja existente cu ajutorul funcţiei list(). De exemplu o listă de m obiecte poate fi generată cu o comandă de tipul >Lst<-list(name_1=object_1,.......,name_m=object_m) unde object_1,…object_m sunt cele m componente ale listei.

O listă formată dintr-un anumit număr de obiecte poate fi extinsă prin specificarea numelor componentelor adiţionale. De exemplu,lista din exemplul precedent, care era formată din patru componente, poate fi extinsă la 5 prin adăugarea numelui prietenilor de familie >Lst[5]<-list(prieteni=nume_prieteni)

Listele pot fi concatenate cu ajutorul funcţiei c(). Rezultatul este tot o listă care conţine listele iniţiale drept componente. Un exemplu de comandă de acest fel este >list.ABC<-c(list.A,list.B,list.C)

Un tablou de date (data frame) este o un obiect R mai general decât o matrice în sensul că coloanele pot avea clase diferite. Toate elementele unei coloane trebuie să aparţină uneia dintre clasele: numeric, factor, caracter sau logic. Nu se admit obiecte de clase diferite pe aceaşi coloană. Tablourile de date pot fi văzute şi ca liste de clasa “data frame”. Practic tablourile de date sunt liste care satisfac anumite criterii. Componentele tablourilor de date pot fi vectori (numerici, caracter sau logici), factori, matrice numerice, liste sau alte tablouri de date.

R are o mulţime de facilităţi de creare şi manipulare a tablourilor de date. Un mod simplu de a accesa un tablou de date în spaţiul de lucru este citirea acestuia dintr-un fişier

cu ajutorul funcţiei read.table(). Această funcţie va fi descrisă în capitolul următor. Unele obiecte R, ca de exemplu vectorii sau matricele, pot fi privite ca tablouri de date. Funcţia as.data.frame() poate fi utilizată de asemenea pentru a transforma vectorii, matricele şi alte obiecte R compatibile în tablouri de date. Funcţia attach() permite accesul diferite tablourile de date care nu sunt accesibile implicit odată cu lansarea în execuţie a lui R.. Opusul acestei funcţii este detach().

Funcţiile colnames() şi rownames() sunt utilizate pentru a denumi coloanele şi respectiv liniile unui tablou de date cu ajutorul şirurilor de caractere. Funcţiile head() şi tail() permit afişarea pe ecran a primelor şi respectiv ultimelor câteva linii ale unui tablou de date.

Functia stack() concatenează coloanele succesive ale unui tablou. Operaţia inversă este realizată de funcţia unstuck(). Alte funcţii des utilizate atunci când lucrăm cu tablouri de date sunt agregate(), merge(), reshape() şi split(). Detalii despre modul de utilizare al acestora pot fi obţinute cu ajutorul funcţiei help(). PROBLEME

+ + + + 1. Presupunem ca în familia Popescu soţul se numeşte Ion, sotia Ioana. Aceştia au trei copii în vârstă de 3, 5 şi respectiv 7 ani. Creaţi o listă care să conţină această informaţie. Vizualizaţi vârsta copiilor din lista nou creată. Soluţie >Lst<-list(nume_sot=”Ion”,nume_sotie=”Ioana”,număr_copii=3, virsta_copii=c(3,5,7)) #creez lista >Lst[[1]] #afişez primul element [1] “Ion” #rezultat >Lst[[2]] #afişez al doilea element [1] “Ioana” #rezultat >Lst[[3]] #afişez al treilea element [1] 3 #rezultat >Lst[[4]] #afişez al patrulea element [1] 3 5 7 #rezultat

Alternativ se pot lista componentele listei ca Lst$nume_sot, Lst$nume_sotie, Lst$virsta_copii, Lst_număr_copii. + + + + 2. În vectorul de tip caracter nume=(“Ion”, “Gheorghe”, “Costel”) se află numele a trei persoane. Greutatea corespunzătoare a acestor persoane se află în vectorul g=(55,74,100) iar nivelul studiilor în vectorul de tip caracter studii=(“superioare”, “medii”,”superioare”). Scrieţi întreaga informaţie într-un tablou de date. Soluţie >informatii<-data.frame(nume=nume, greutate=g, studii=studii) #creez tabloul >informatii #listez conţinutul nume greutate studii #rezultat 1 Ion 55 superioare 2 Gheorghe 74 medii 3 Costel 100 superioare

Alternativ se poate vizualiza numele cu informatii$nume, greutatea cu informatii$greutate şi studiile cu informatii$studii. + + + + 3. Fie vectorii de tip numeric x1=(1,7,9), x2=(8,5,12) si x3=(2,5,5). Creaţi un tablou de date care să aibă pe coloane aceşti vectori. Denumiţi coloanele cu C1, C2 şi C3 şi liniile cu L1, L2 şi L3. Soluţie >x1=c(1,7,9) #vectorul x1 >x2=c(8,5,12) #vectorul x2 >x3=c(2,5,5) #vectorul x3 >m=cbind(x1,x2,x3) #matricea > colnames(m)=c("C1","C2","C3") #numele coloanelor >rownames(m)=c("L1","L2","L3") #numele liniilor >m C1 C2 C3 #rezultat L1 1 8 2 L2 7 5 5 L3 9 12 5 2.7. Gruparea expresiilor, execuţii condiţionate şi bucle 2.7.1. Gruparea expresiilor

Expresiile sunt combinaţii de obiecte R şi operatori care sunt evaluate. De

exemplu y=x^2 este o expresie prin care se calculează pătratul lui x, iar rezultatul este stocat in y. De asemenea y = = x^2 este o expresie prin care se testează dacă y este egal cu pătratul lui x.

R este un limbaj bazat pe expresii (expression language) deoarece comenzile se execută prin intermediul expresiilor sau al funcţiilor, care returnează un rezultat. Comenzile pot fi grupate prin intermediul acoladelor, {epr_1;….;expr_m}. Valoarea grupului de comenzi este rezultatul ultimei expresii din grup care este evaluată. Deoarece întregul grup este la rândul său o expresie el poate fi, de exemplu, inclus între acolade şi utilizat ca parte a unei expresii mai mari. PROBLEME + + + + 1. Evaluaţi simultan expresiile 1.2/3.4, 2.7*5.2,-1.2+7.4 şi puneţi rezultatul într-un vector numeric. Soluţie >{x1=1.2/3.4;x2=2.7*5.2;x3=-1.2+7.4} #grupez cele trei expresii >v=c(x1,x2,x3) #creez vectorul >v #vizualizez vectorul [1] 0.3529412 14.0400000 6.2000000 #rezultat + + + + 2. Fie vectorii x1=(1,7,9) si x2=(2,4,8). Evaluaţi simultan expresiile x1+x2 si x1-x2. Ce rezultat obţineţi?

Soluţie >x1=c(1,7,9) #creez vectorul x1 >x2=c(2,4,8) #creez vectorul x2 >{x1+x2;x1-x2} [1] -1 3 1 #rezultat

Observaţi că se returnează valoarea ultimei expresii, in cazul nostru x1-x2. 2.7.2. Execuţii condiţionate

Funcţia if() permite executarea condiţionată a comenzilor în R. Apelarea acestei funcţii se face cu comanda >if(cond) expr unde cond este o condiţie al cărui rezultat este o singură valoare logică iar expr este o expresie. Dacă rezultatul evaluării condiţiei este TRUE, atunci expresia este calculată. Dacă rezultatul evaluării este FALSE, atunci expresia nu este calculată.

Execuţiile condiţionate pot fi introduse şi prin comanda >if(cond) expr else alt.expr

Dacă rezultatul evaluării condiţiei cond este TRUE atunci se evaluează expresia expr iar dacă rezultatul este FALSE atunci se evaluează expresia alt.expr.

Operatorii “&&” şi “||” sunt deseori utilizaţi ca parte a condiţiilor asociate funcţiei if. În timp ce operatorii “&” şi “|” asociază elemente ale vectorilor, operatorii “&&” şi “||” se aplică vectorilor de lungime unu şi evaluează doar al doilea argument dacă este necesar.

Funcţia ifelse este o versiunea a funcţiei if/else. Forma acestei funcţii este >ifelse(condition,a,b) unde a şi b sunt vectori. Această funcţie returnează un vector de lungime egală cu maximul lungimii vectorilor a şi b ale cărui elemente sunt a[i] dacă condiţia este adevarată sau b[i] în caz contrar. PROBLEME + + + + 1. Se dă vectorul numeric x=(1,2,-3). Utilizaţi funcţia if pentru a scrie pe ecran poziţiile valorilor negative ale elementelor vectorului x. Soluţie >x<-c(1,2,-3) #creez vectorul numeric x >y<-x<0 #creez vectorul logic y [1] FALSE FALSE TRUE #vectorul y >if(y[1]){print(1)} #testez dacă prima valoare e negativă >if(y[2]){print(2)} #testez dacă a doua valoare e negativă >if(y[3]){print(3)} #testez dacă a treia valoare e negativă [1] 3 #rezultat + + + + 2. Se dă vectorul x=(-1,1). Utilizaţi funcţia ifelse pentru a determina dacă un element al vectorului x este mai mic sau mai mare sau egal cu zero. Soluţie

>x=c(-1,1) #creez vectorul x >y=x>=0 #creez vectorul logic y [1] FALSE TRUE #vectorul y >if(y[1]){print("x[1]>=0")} else {print("x[1]<0")} #condiţie [1] "x[1]<0 #rezultat >if(y[2]){print("x[2]>=0")} else {print("x[2]<0")} #condiţie [1] "x[2]>=0" #rezultat + + + + 3. Se dau vectorii x=(-1,1) şi y=(3,4). Creaţi un vector v care să conţină elementele lui y pe poziţia elementelor negative ale lui x şi elementele lui x pe poziţia elementelor mai mari sau egale cu zero ale lui x. Soluţie >x=c(-1,1) #creez vectorul x >y=c(3,4) #creez vectorul y >l=x<0 #creez vectorul logic l [1] TRUE FALSE #vectorul l >v<-ifelse(l,y,x) #creez vectorul v [1] 3 1 #vectorul v 2.7.3. Bucle

Buclele sau execuţiile repetate ale comenzilor R se realizează cu ajutorul

funcţiilor for(), repeat() şi while(). Apelarea funcţiei for() se face prin

>for(name în expr_1) expr_2 unde name este variabila care ciclează. expr_1 este o expresie vectorială (deseori o secvenţă de tipul 1:n) iar expr_2 este o grupare de comenzi R.

O altă posibilitate de a executa repetat o grupare de comenzi este utilizarea funcţiei repeat() care se apelează cu comanda >repeat expr unde expr este o expresie.

O altă funcţie care permite introducerea condiţiilor în execuţia comenzilor R este while() care se apelează prin >while (condition) expr

Expresia expr este evaluată atâta timp cât condiţia condition este satisfacută. În asociere cu funcţiile de ciclare menţionate mai sus se foloseşte şi funcţia

break() pentru a termina, adeseori anormal, un ciclu. De fapt aceasta este singura posibilitate de a încheia bucla generată cu funcţia repeat(). Comanda next poate fi utilizată pentru a termina un anumit ciclu şi a sări la urmatorul. PROBLEME

+ + + + 1. Utilizând funcţia for creaţi vectorul numeric v care să conţină numerele întregi de la 1 la 10. Soluţie >v=vector() #definesc vectorul v >for(i in 1:10){ v[i]=i} #bucla >v #afişez v [1] 1 2 3 4 5 6 7 8 9 10 #rezultat + + + + 2. Utilizaţi funcţia while() pentru a scrie primele 4 elemente ale vectorului v din problema precedentă într-un alt vector v1. Soluţie >v1=vector() #definesc vectorul v1 >i=1 #iniţializez indicele >while(v[i]<5){v1[i]=v[i];i=i+1} >v1 #afişez v1 [1] 1 2 3 4 #rezultat 2.8. Funcţii 2.8.1. Funcţii înglobate în R

Limbajul R permite utilizatorului să creeze obiecte de tip funcţie. Funcţiile astfel

create pot fi salvate şi apoi apelate ori de câte ori se doreşte. Utilizarea funcţiilor duce la creşterea spectaculoasă a vitezei de calcul în R. Este recomandat ca în orice proces de calcul din R să fie utilizate, cât mai mult posibil, funcţiile.

Trebuie notat că cele mai multe funcţii sunt înglobate în sistemul R. O parte din aceste funcţii, care sunt parte a sistemului R şi care sunt cel mai des utilizate, sunt enumerate mai jos. all() #returnează TRUE dacă toate valorile unui vector logic sunt TRUE any() #returnează TRUE dacă cel puţin o valoare a unui vector logic este TRUE args() #informaţii despre argumentul unei funcţii cat() #printează obiecte multiple, unul după altul cumprod() #produs cumulativ cumsum( #suma cumulativă diff() #efectuează diferenţa de ordin unu a unui vector history() #arată comanda precedentă is.factor() #returnează TRUE dacă argumentul este un factor is.na() #returnează TRUE dacă argumentul este NA length() #numărul de elemente al unui vector sau a unei liste ls() #listează numele obiectelor din spaţiul de lucru mean() #media elementelor unui vector median() #mediana elementelor unui vector

order() #ordonează un şir (NA pe ultima poziţie) print() #printează un singur obiect range() #maximul şi minimul elementelor unui vector sort() #ordonează crescător elementele unui vector(se omite NA ) rev() #aranjaza elementele unui vector în ordine inversă str() #informaţii despre un obiect R unique() #formează un vector cu valori distincte which() #localizează indicii “TRUE” ai unui vector logic which.max() #localizează indicele maximului unui vector numeric which.min() #localizează indicele minimului unui vector numeric with() #efectuează calcule utilizând coloanele unui tablou de date specificat

Pe lângă funcţiile prezentate mai sus există multe alte funcţii înglobate în R.

Informaţii despre aceste funcţii se pot obţine cu funcţia help(). O parte din funcţiile înglobate în R recunosc valorile nedefinite. Există însă şi

funcţii care returnează un mesaj de eroare sau NA dacă datele furnizate ca input conţin valori nedefinite. De exemplu, opţiunea implicit (default) a functiilor mean(), sum(), median(), range(), returnează NA când sunt aplicate vectorilor în care una sau mai multe valori sunt NA. Setarea argumentului na.rm=TRUE a acestor funcţii are ca efect neglijarea valorilor NA şi evaluarea mărimilor cerute cu elementele ramase. De exemplu >mean(c(1,NA,3,0,NA),na.rm=TRUE) #media aritmetică [1] 1.3 #rezultat

Alte funcţii utile în manipularea valorilor NA sunt na.omit() şi complete.cases(). Informaţii suplimentare se pot obţine cu help(na.omit) şi help(complete.cases). PROBLEME + + + + 1. Se dau vectorii numerici x=(1,7,12,NA) şi y=(2,NA,3,7). Calculaţi vectorul z=x+y. Sunt toate valorile lui z NA? Există cel puţin o valoare a lui z egală cu NA? Soluţie >x<-c(1,7,12,NA) #creez vectorul x > y<-c(2,NA,3,7) #creez vectorul y >z<-x+y #suma lui x şi y >l<-is.na(z) #creez vectorul logic l [1] FALSE TRUE FALSE TRUE #vectorul l >all(l) #sunt toate valorile nedefinite ? [1] FALSE #rezultat >any(l) #există cel puţin o valoare nedefinita? [1] TRUE #rezultat + + + + 2. Utilizaţi funcţia cat() pentru a vizualiza vectorii x, y şi z din problema precedentă. Soluţie >cat(x)

1 7 12 NA> #rezultat >cat(y) 2 NA 3 7> #rezultat >cat(z) 3 NA 15 NA> #rezultat ++++ 3. Se dă vectorul x=(1,7,3,-10,14). Determinaţi indicele maximului şi minimului vectorului x. Ordonaţi crescător elementele lui x şi scrieţi-le în vectorul y. Soluţie >x<-(1,7,3,-10,14) #creez vectorul x >which.max(x) #determin indicele maximului [1] 5 #rezultat >which.min(x) #determin indicele minimului [1] 4 #rezultat >y=sort(x) #aranjez crescător >y #afişez y [1] -10 1 3 7 14 #rezultat + + + + 4. Se dă vectorul x=(1,1,1,7,3,-10,14). Construiţi vectorul y format doar din valorile distincte ale lui x. Obtineţi informaţii despre y cu ajutorul funcţie str(). Soluţie >x=c=(1,1,1,7,3,-10,14) #creez vectorul x >y<-unique(x) #valorile distincte ale lui x >y #afişez rezultatul [1] 1 7 3 -10 14 #rezultat >str(y) #aplic funcţia str num [1:5] 1 7 3 -10 14 #rezultat (variabila numerica, 5 elemente) + + + + 5. Determinaţi argumentele funcţiei median() cu ajutorul funcţiei args(). Soluţie >args(median) #argumentele functiei median [1] function (x, na.rm = FALSE) #rezultat 2.8.2. Funcţii create de utilizator

Utilizatorul poate să definească propriile sale funcţii. Forma generală a unei

funcţii este >name<-function(arg_1, arg_2,...) expression unde expression este o expresie R (de obicei o grupare de expresii) care utilizează argumentele arg_i pentru a calcula o valoare. Valoarea expresiei este valoarea returnată de funcţie.

Apelarea unei funcţii se face printr-o comandă de forma >name(arg_1,arg_2,...)

Funcţia returnează rezultatul evaluării expresiilor înglobate în corpul funcţie, valori nedefinite sau mesaje de eroare. Valoarea returnată, care trebuie sa fie un singur

obiect, este cea din linia finală a corpului funcţiei. Dacă rezultatul constă îi câteva obiecte de diferite tipuri, atunci acestea se compactează de obicei într-o listă. PROBLEME + + + + 1. Se dă vectorul x=(1,7,9) şi y=(2,5,7). Creaţi funcţia myadd de adunare a doi vectori şi folosiţi această funcţie pentru adunarea lui x cu y. Soluţie >x=c(1,7,9) #creez vectorul x >y=c(2,5,7) #creez vectorul y >myadd<-function(x,y){ x+y } #definesc funcţia myadd >myadd(x,y) #adun x cu y cu funcţia myadd [1] 3 12 16 #rezultat + + + + 2. Creaţi functia meanANDsd pentru calculul mediei si a deviaţiei standard a unui şir de numere. Calculaţi media si deviaţia standard a şirurilor de numere x1=(1,7,3,8,1,15) şi x2=(1,8,7,5,NA,6,NA). Soluţie >meanANDsd<-function(x){ #definesc funcţia av<-mean(x) #media sdev<-sd(x) #deviaţia standard c(mean=av,SD=sdev)} #compactez av şi sdev într-un vector >x1=c =(1,7,3,8,1,15) #creez vectorul x1 >meanANDsd(x1) #aplic funcţia mean SD #rezultat 5.833333 5.382069 >x2=c=(1,8,7,5,NA,6,NA) #creez x2 >meanANDsd(x2) #aplic funcţia mean SD NA NA + + + + 3. Creeaţi funcţia myf pentru calculul sumei si a diferenţei a doi vectori care returnează rezultatul sub forma unei liste. Aplicaţi această funcţie pentru calculul sumei si diferenţei vectorilor x=(1,7,9) si y=(2,8,4). Soluţie >myf<-function(x,y){ #definesc funcţia s=x+y #suma d=x-y #diferenţa list(suma=s,diferenta=d)} #creez lista >x=c(1,7,9) >y=c(2,8,4) >rez=myf(x,y) #aplic funcţia >rez #rezultat $suma [1] 3 15 13

$diferenta [1] -1 -1 5