R zakres materiału install packages, wybiera sie repozytorium



Pobieranie 160,32 Kb.
Strona1/2
Data18.11.2017
Rozmiar160,32 Kb.
  1   2

R - zakres materiału
install.packages(), wybiera sie repozytorium.

Warto to robic jedynie w przypadku, gdy library(nazwa_pakietu) twierdzi, że pakietu nie ma.


1) Format polecen, umieszczanie komentarzy, korekty polecen.

Sposób zapisu liczb, stałe logiczne i tekstowe


2) Obliczenia z użyciem pojedynczych wyrażeń,

a) operatory arytmetyczne

b) operatory logiczne

c) podstawowe funkcje arytmetyczne i logiczne

d) funkcje tekstowe cat() i paste()
3) znajdowanie i zmiana kartoteki roboczej

polecenia getwd(), setwd()


4) Konstruowanie wektorów, list i ramek danych

funkcje c(),rep(), seq(), operator ":"

list(), data.frame()

5) Tworzenie macierzy

funkcje: matrix(), dim(), rbind(), cbind()
6) Podstawowe operacje indeksowania wektorów i macierzy
7) operacje z udziałem wektorów i macierzy

np. mnożenie wektorów i macierzy przez liczby

działania: wektor operator wektor

macierz operator macierz

mnożenie macierzy, wyznaczniki, macierze odwrotne,

rozwiązywanie układów równań liniowych


8) Czytanie danych z dysku:

funkcje scan() i read.table()

polecenie attach()

9) Rysowanie prostych wykresów liniowych i punktowych

funkcje: plot(), curve(), points(), lines(), legend()

abline()

10) Histogramy - funkcja hist(), wykresy kołowe pie(), boxplot() itp.


11) Statystyki opisowe

mean(), max, min(), range(), sd(),...

różne przykłady można znaleźć na stronie: http://www.statmethods.net/

12) Regresja liniowa:

funkcja lm(),

elementarna ocena wyników: summary(),

wizualizacja: plot

przykłady dopasowywania wielomianów przy użyciu funkcji lm(), użycie

funkcji I()

proste przekształcenia linearyzujące

regresja wielokrotna

dużo przykładów można znaleźć w podręczniku: aut. John Maindonald

“Using R for Data Analysis and Graphics - Introduction, Examples and

Commentary"

13) Interpolacja

pakiet polynom,

użycie funkcji sklejanych: spline(), smooth.spline()

rozdział 9 w podreczniku K. Soetaert "Using R for scientific computing

14) Budowanie własnych funkcji

rozdział 4 w podręczniku K. Soetaert "Using R for scientific computing

więcej na ten temat: rozdz. 10, str 42 podręcznik "An introduction to R"

wczytywanie bibliotek własnych funkcji: source()

15) Szukanie zer funkcji jednej zmiennej: uniroot(),

rozdział 8 w podreczniku K. Soetaert "Using R for scientific computing

szukanie ekstremów: funkcja optimize()

16) Optymalizacja wielu parametrów:

funkcja optim(), można się wzorować na przykładach z dokumentacji do optim

wystarczy elementarny poziom, bez wchodzenia w detale procedur gradientowych,


17) Rysowanie wykresów 3-wymiarowych (1-2 przykłady)

funkcja persp()

bardzo dużo przykładów z kodami źródłowymi można znaleźć na

stronie:http://addictedtor.free.fr/graphiques/thumbs.php



Słowa kluczowe:

cat(), paste()

getwd(), setwd()

c(), rep(), seq(), operator ":", list(), data.frame()

matrix(), dim(), rbind(), cbind()

scan(), read.table(), attach()

plot(), curve(), points(), lines(), legend(), abline()

hist(), pie(), boxplot()

mean(), max, min(), range(), sd()

if...else, ifelse, for, while, repeat


R - zakres materiału do sprawdzianu1 z R

1-3 Tworzenie wektora, ciagow arytmetycznych, list i ramek danych, tablice

4-8 Indeksowanie, relacje, modyfikacje tresci wektorow i list

uzycie funkcji, tworzenie wlasnych funkcji, instrukcje warunkowe i petle, postawowe funkcje statystyki opisowej(mean, max, min,range, summary)

8-10 rysunki, zmiana typu wykresu, kolorow, symboli punktów, zmiana zakresu zmiennosci zm zaleznej i niezaleznej na wykresie (xlim=c(min,max), ylim=c(min,max))


Podstawy R
1) Zmienne

nazwy do 32 znaków, na początku litera lub kropka

jeżeli nazwa zaczyna się kropką to drugim znakiem

nie może być cyfra



2) Typy obiektów:

a) numeryczne (liczby) - trzy klasy:

- całkowite +- 1.6E+9

- rzeczywiste 12-13 cyfr, +- 1.5E+-308

zapis +-mE+-c, m - mantysa (nie musi zawierać kropki, c - cecha

- zespolone - pary liczb rzeczywistych,

stale: z = Re + Imi

np.: z = 7.5 + 3.14i

b)Typ czynnikowy (wyliczeniowy, kategoryczny).

wektory wartości na kilku poziomach (kategoriach)

do tworzenia obiektów tego typu służy funkcja factor

>oceny=factor(c("ndst","dost","db","db","dost","bdb"))

> oceny

[1] ndst dost db db dost bdb



Levels: bdb db dost ndst

> summary(oceny)

bdb db dost ndst

1 2 2 1
c) tekstowe (do 500 znaków):

stałe: "tekst"

Funkcje cat() i paste()

> cat(" co \t to \\ teraz\"\n bedzie?")

co to \ teraz"


bedzie?
> # napisy można sklejać

> paste("Napis", "napis doklejony", 12)



[1] "Napis napis doklejony 12"
d) logiczne stałe: TRUE FALSE
e) wyrażenia (expression): teksty zawierające zapisane wyrażenia (wzory: y=a*x+b)
Obliczenia jak na kalkulatorze:


3) Struktury danych:

a) wektory (podstawowy typ obiektów): uporządkowany zbiór wielkości tego samego typu)

przykłady: c(1 ,3.5, 2.4, 7.8) <== wektor liczb

c("ABC","ANNA","Zorro","Woda") <== tekstów

c(TRUE,FALSE,TRUE,TRUE) <== wektor logiczny
b) listy Uporządkowany zbiór obiektów różnego typu (tak jak wektor liczb, ale składowe listy to obiekty różnego typu np.: liczbowe, tekstowe, wyliczeniowe, logiczne itp.)

list("Jan","Kowalski",1991,"Kraków","TRUE")

elementy list (i wektorów) moga być nazwane)

list(imie="Jan",nazwisko="Kowalski",ur=1991,zam="Kraków",stud="TRUE")

zamiast pojedynczych wartości można wprowadzać wektory

d1 =list(imie=c("Jan","Piotr"),nazwisko=c("Kowalski","Nowak"),ur=c(1991,1995),

+ zam=c("Kraków","Opole"),stud=c(TRUE,FALSE))

$imie


[1] "Jan" "Piotr"

$nazwisko

[1] "Kowalski" "Nowak"

$ur


[1] 1991 1995
$zam

[1] "Kraków" "Opole"

$stud

[1] TRUE FALSE


> d1$stud <==== mozemy pytać o elementy listy

[1] TRUE FALSE


c) ramki danych

zbiory nazwanych wektorów o tej samej liczbie elementów (tak jak tablica liczb, ale w każdej kolumnie znajdują się obiekty tego samego typu – niekoniecznie liczby)

data.frame(d1=1:5,d2=6:10,nazw=c("a","b","c","d","e"))

df = data.frame(d1=1:5,d2=6:10,nazw=c("a","b","c","d","e"))

> df

d1 d2 nazw



1 1 6 a

2 2 7 b


3 3 8 c

4 4 9 d


5 5 10 e
> df$nazw #<=== jak w przypadku list można wywołać kolumne ramki

[1] a b c d e

Levels: a b c d e # w wektorze są napisy - przyjmuje że jest to typ wyliczeniowy stąd levels

> summary(df$nazw)

a b c d e

1 1 1 1 1


jezeli nie nadamy nazw to R zrobi to "po swojemu"

df = data.frame(1:5,d2=6:10,c("a","b","c","d","e"))

> df

X1.5 d2 c..a....b....c....d....e..



1 1 6 a

2 2 7 b


3 3 8 c

4 4 9 d


5 5 10 e
d) tablice - struktury dwu- lub więcej wymiarowe. Tworzenie tablic:
0) z istniejących wektorów przez "sklejenie" ich w tablicę

> rbind(1:4,'a') # skleja wierszami cbind() skleja kolumnami (UWAGA: uzupełnia brakujące elementy cyklicznie - ogólna reguła !)

[,1] [,2] [,3] [,4]

[1,] "1" "2" "3" "4"

[2,] "a" "a" "a" "a"
i) z istniejącego wektora, przez przypisanie wymiarów

tab = 1:20

dim(tab)=c(5,4) - tworzy tablice o 5 wierszach i 4 kolumnach (5*4=20 wymiary muszą być równe!)

sama funkcja dim zwraca informacje o organizacji tablicy (lub innego obiektu)

dim(tab)

wymiary tablicy mogą być zmieniane, pod warunkiem, że iloczyn wymiarów pozostanie równy liczbie elementów

dim(tab)=c(2,10)

dim(tab)=c(4,5)

dim(tab)=c(10,2)
ii) użycie funkcji matrix
mm = matrix(data=1:24,nrow=3,ncol=8)

mm = matrix(data=1:24,nrow=4) # liczba kolumn zostanie obliczona

mm = matrix(data=1:24) # utworzy macierz kolumnową

tablica jest wypełniana "kolumnami", jeżeli chcemy zmienić kolejność używamy parametru "byrow=TRUE"

mm = matrix(data=1:24,nrow=3,ncol=8,byrow=TRUE)
iii) użycie funkcji array (tablica może mieć więcej niż dwa wymiary)
ma = array(data=1:81,dim=c(3,3,9)). # dim = tablica zawierająca wektory indeksów
Wektory:

Konstruktor: funkcja c(v1,v2,....,vn), vi - stała, zmienna, wektor

składowe muszą być tego samego typu.

wekt=c(1,2,5,6,7)


> # elementy wektora mogą mieć nazwy

> c(pierwszy = 12, drugi = 10, trzeci = 18)

pierwszy drugi trzeci

12 10 18
Sekwencje (ciągi):

w1 = 1:10

w2 = 10:(-2)

w3=seq(from=0,to=2*pi,by=0.01) <== zadany skok wartości

w3=seq(0,2*pi,length.out=400) <== przedział [0,2pi] dzielimy na 399 części

w4=seq(length=51, from=-5, by=0.2)

w5=seq(from=-5,by=0.1,along=w4) <== ma tyle samo elementów ile w4


Powtórzenia:

x = 1:3


w6=rep(x,times=5)

w6

[1] 1 2 3 1 2 3 1 2 3 1 2 3 1 2 3



w7=rep(x,each=5)

w7

[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3


0/0

NaN # <=== (Not a Number)


brakujące dane: NA (Not Available)
braki = c(1,3.5,2.7,NA,7.5,24)
Operacje arytmetyczne i logiczne:
+, - , *, /, ^ Standardowe operatory arytmetyczne.

%% Reszta modulo z dzielenia.

%/% Dzielenie całkowite.

wektory lub macierze powinny mieć ten sam rozmiar lub gdy jeden z nich jest pojedynczą liczbą!

> x = 1:3

x*5


[1] 5 10 15
> y=6:10

> z=x*y


Warning message:

In x * y : longer object length is not a multiple of shorter object length

> z

[1] 6 14 24 9 20 <=== ????? jak to sie liczy


%*% Iloczyn dwóch macierzy.
> m1=matrix(data=1:6,ncol=3)

> m1


[,1] [,2] [,3]

[1,] 1 3 5

[2,] 2 4 6

> m2=matrix(data=1:9,nrow=3)

> m2

[,1] [,2] [,3]



[1,] 1 4 7

[2,] 2 5 8

[3,] 3 6 9

> m1 %*% m2

[,1] [,2] [,3]

[1,] 22 49 76

[2,] 28 64 100
Operatory logiczne

<, ==, >, <=, >=, != Standardowe operatory porównywania wartosci liczbowych (relacje).

! Operator negacji.

&, &&, |, || Logiczny iloczyn oraz logiczna suma (| & - dla każdego elementu, || && dla całego wektora)

any(), all() Logiczna suma(iloczyn) wszystkich elementów wektora.


> 2 > 3

[1] FALSE

>

> !2 > 3 <=== negacja



[1] TRUE

>

> x = 1:10



> x >= 5

[1] FALSE FALSE FALSE FALSE TRUE TRUE TRUE TRUE TRUE TRUE


> x >= 5 & x > 7

[1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE TRUE TRUE

>

> x >= 5 | x < 3



[1] TRUE TRUE FALSE FALSE TRUE TRUE TRUE TRUE TRUE TRUE

>

> x >= 5 && x < 7 # iloczyn i suma logiczna dla wszystkich elementów



[1] FALSE # obliczane łącznie

> x >= 5 || x < 7

[1] TRUE
> any(x>5)

[1] TRUE


> all(x>5)

[1] FALSE

>
UWAGA: Jeżeli zamiast zmiennej czy stałej logicznej wstawimy do wyrażenia

logicznego liczbe (stałą lub zmienną) to będzie traktowana jako FALSE gdy ma wartość zero

a jako TRUE dla wartości różnych od zera !!!!!

Indeksowanie:
>x = 1:10

> x[x==6]

[1] 6

> x[x>=7]



[1] 7 8 9 10

> x[-3]


[1] 1 2 4 5 6 7 8 9 10
> y=c(1,2,3,NA,5,6)

> z=y[!is.na(y)] <=== kopiujemy jedynie zdefiniowane elementy wektora

> z

[1] 1 2 3 5 6



indeksowanie macierzy
> x = array(data=1:20,dim=c(4,5))

> x


[,1] [,2] [,3] [,4] [,5]

[1,] 1 5 9 13 17

[2,] 2 6 10 14 18

[3,] 3 7 11 15 19

[4,] 4 8 12 16 20
> x[3,4]

[1] 15


> x[2,]

[1] 2 6 10 14 18

> x[,3]

[1] 9 10 11 12



> x[1:3,1:3]

[,1] [,2] [,3]

[1,] 1 5 9

[2,] 2 6 10

[3,] 3 7 11
> x[,2:4] # wybieramy kolumny 2:4 z macierzy x

[,1] [,2] [,3]

[1,] 5 9 13

[2,] 6 10 14

[3,] 7 11 15

[4,] 8 12 16


macierze indeksów

> i = array(data=c(1:3,3:1),dim=c(3,2)) # i zawiera indeksy (wiersz, kolumna) do innej tablicy - wybiera z niej tyle elementów ile jest wierszy w dim)

> i

[,1] [,2]



[1,] 1 3

[2,] 2 2


[3,] 3 1

> x[i]


[1] 9 6 3

> x[i] = 0 # elementy wybrane w tablicy i stają się równe 0

> x

[,1] [,2] [,3] [,4] [,5]



[1,] 1 5 0 13 17

[2,] 2 0 10 14 18

[3,] 0 7 11 15 19

[4,] 4 8 12 16 20


a=outer(1:10,1:10) # kombinacja dwu zmiennych - domyślnie iloczyn (a=outer(1:10,1:10,'*')

> a


[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]

[1,] 1 2 3 4 5 6 7 8 9 10

[2,] 2 4 6 8 10 12 14 16 18 20

[3,] 3 6 9 12 15 18 21 24 27 30

[4,] 4 8 12 16 20 24 28 32 36 40

[5,] 5 10 15 20 25 30 35 40 45 50

[6,] 6 12 18 24 30 36 42 48 54 60

[7,] 7 14 21 28 35 42 49 56 63 70

[8,] 8 16 24 32 40 48 56 64 72 80

[9,] 9 18 27 36 45 54 63 72 81 90

[10,] 10 20 30 40 50 60 70 80 90 100
d = outer(1:10,1:10,"/") <=== można uzyć dowolnego operatora

> d


[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]

[,10]


[1,] 1 0.5 0.3333333 0.25 0.2 0.1666667 0.1428571 0.125 0.1111111

0.1


[2,] 2 1.0 0.6666667 0.50 0.4 0.3333333 0.2857143 0.250 0.2222222

0.2


[3,] 3 1.5 1.0000000 0.75 0.6 0.5000000 0.4285714 0.375 0.3333333

0.3


[4,] 4 2.0 1.3333333 1.00 0.8 0.6666667 0.5714286 0.500 0.4444444

0.4


[5,] 5 2.5 1.6666667 1.25 1.0 0.8333333 0.7142857 0.625 0.5555556

0.5


[6,] 6 3.0 2.0000000 1.50 1.2 1.0000000 0.8571429 0.750 0.6666667

0.6


[7,] 7 3.5 2.3333333 1.75 1.4 1.1666667 1.0000000 0.875 0.7777778

0.7


[8,] 8 4.0 2.6666667 2.00 1.6 1.3333333 1.1428571 1.000 0.8888889

0.8


[9,] 9 4.5 3.0000000 2.25 1.8 1.5000000 1.2857143 1.125 1.0000000

0.9


[10,] 10 5.0 3.3333333 2.50 2.0 1.6666667 1.4285714 1.250 1.1111111

1.0


>
Macierze specjalne

> v = c(1,2,3,4,5)

> diag(v) <=== funkcja diag, argument to wektor a rezultat to macierz

[,1] [,2] [,3] [,4] [,5]

[1,] 1 0 0 0 0

[2,] 0 2 0 0 0

[3,] 0 0 3 0 0

[4,] 0 0 0 4 0

[5,] 0 0 0 0 5
> m=array(data=1:36,dim=c(6,6))

> m


[,1] [,2] [,3] [,4] [,5] [,6]

[1,] 1 7 13 19 25 31

[2,] 2 8 14 20 26 32

[3,] 3 9 15 21 27 33

[4,] 4 10 16 22 28 34

[5,] 5 11 17 23 29 35

[6,] 6 12 18 24 30 36

> diag(m) <=== argumentem diag jest macierz, rezultatem wektor

[1] 1 8 15 22 29 36

>

Funkcje (W R funkcje są polimorficzne – ta sama funkcja może być wywoływana z różną listą argumentów)


function(listaArgumentow)

instr # Instrukcje instr można zastąpić blokiem instrukcj { }
Przykład

> # definiujemy nową funkcje, wykorzystując funkcję sort()


> wyswietl3Najmniejsze <- function(wektor) { # deklaracja funkcji i początek bloku instrukcji

+ posortowane <- sort(wektor) # do posortowane wpisz posortowany wektor

+ posortowane[1:3] # wypisz 3 pierwsze wartości

+}
> lLiczby <- c(11, 3, 10, 1, 0, 8) # tworzymy wektor liczb

> (wynik <- wyswietl3Najmniejsze(lLiczby)) # wywołujemy naszą funkcję

[1] 0 1 3



O B L I C Z E N I A na wektorach (i tablicach)

===================================================================

Funkcje statystyki opisowej, działające na składowych wektora:
wartości skrajne

max(v) - maksymalna wartość składowej wektora

min(v) - minimalna wartość składowej wektora
średnie

mean(v)- wartość średnia, dodatkowe parametry:

trim=0-0.5, oblicza średnią po odrzuceniu 200%*trim skrajnych wartości z v,

na.rm=FALSE, czy wyrzucać wartości nieznane?

weighted.mean(v,w) - średnia ważona, w - wektor wag

geometric.mean(psych) - z pakietu "psych"

harmonic.mean(psych) - z pakietu "psych"
median(v) - wartość środkowa

quantile(x) - wyznacza kwantyle


------------- przyklady

> quantile(x <- rnorm(1001)) # Extremes & Quartiles by default

0% 25% 50% 75% 100%

-2.960752743 -0.647673124 0.004523922 0.632159008 3.100949014

> quantile(x, probs = c(0.1, 0.5, 1, 2, 5, 10, 50, NA)/100)

0.1% 0.5% 1% 2% 5% 10%

-2.920614903 -2.551016732 -2.206166415 -1.908824109 -1.605590363 -1.221637594

50%


0.004523922 NA

--------------------------------------------------------------

IQR(v) - rozstęp międzykwartylowy
range(x) zakres zmienności x

[1] -2.960753 3.100949


var(x) - wariancja w próbie
sd(v) - odchylenie standardowe
cor(v), cov(v) macierz korelacji i kowariancji
sd(v)/mean(v) - tzw współczynnik zmienności (CV - Coefficient of

Variance)


length(v) - liczba elementów wektora
kurtosis(v) - (wymaga pakietu e1071), Kurtoza, miara spłaszczenia rozkładu
skewness(v) – (wymaga pakietu e1071), Skośność, miara asymetrii rozkładu
moda(v) - pakiet dprep, Dominanta, wartość występująca najczęściej
Użycie:

ponizsze dane pochodzą ze strony autora podręcznika

Przewodnik po pakiecie R, aut. P. Biecek

daneSoc = read.table("d:/daneSoc",header=TRUE,sep=";")

head(daneSoc) # <== oglšdamy poczatek ramki
wiek wyksztalcenie st.cywilny plec praca

1 70 zawodowe w zwiazku mezczyzna uczen lub pracuje

2 66 zawodowe w zwiazku kobieta uczen lub pracuje

3 71 zawodowe singiel kobieta uczen lub pracuje

4 57 srednie w zwiazku mezczyzna uczen lub pracuje

5 45 srednie w zwiazku kobieta uczen lub pracuje

6 48 srednie w zwiazku mezczyzna nie pracuje

cisnienie.skurczowe cisnienie.rozkurczowe

1 143 83

2 123 80


3 167 80

4 150 87


5 130 83

6 138 75
attach(daneSoc) #<== nie chcemy każdorazowo wypisywać nazwy ramki np. daneSoc$wiek, komenda attach włacza składniki ramki do naszej przestrzeni roboczej i możemy traktować nazwy kolumn jako nazwy zmiennych lokalnych

badamy dane nt. wieku

> range(wiek) # przedział wartości

[1] 22 75
> IQR(wiek) # rozstęp międzykwartylowy

[1] 23
> mean(wiek) # średni wiek

[1] 43.16176
> mean(wiek,trim=0.2) # ?rednia po odrzuceniu 40% skrajnych wartości

[1] 42.58065


> geometric.mean(wiek) # chcemy wyznaczyć średnią geometryczną

Error: could not find function "geometric.mean" # nie znamy tej funkcji

> library(psych) # ładujemy pakiet "psych"

> geometric.mean(wiek) # i już umiemy to liczyć

[1] 40.89757
> harmonic.mean(wiek) # przy okazji z pakietu psych załadowano funkcję, która potrafi obliczyć średnią harmoniczną

[1] 38.66

> median(wiek) # mediana

[1] 45
> moda(wiek) # jaki wiek występuje najliczniej w próbie?

Error: could not find function "moda"

> library(dprep) # potrzebny będzie pakiet dprep

Loading required package: MASS #ładując się wprowadza dodatkowe biblioteki

Loading required package: nnet

Loading required package: lattice

Loading required package: class

> moda(wiek) # <===== tu już potrafimy wyznaczyć wartość moda()

[1] 26


> sd(wiek) # odchylenie standardowe

[1] 13.8471


> kurtosis(wiek) # czy rozkład jest skoncentrowany?

Error: could not find function "kurtosis"

> library(e1071) # znowu trzeba załadować bibliotekę

> kurtosis(wiek) # wynik odległy od zera (kurtoza = 0 dla rozkładu normalnego)


[1] -0.955848

>
> skewness(wiek) # czy rozkład jest skośny?

[1] 0.233151

Podsumowania:
summary(wektor)
> summary(wyksztalcenie) # <== dane kategoryczne

podstawowe srednie wyzsze zawodowe

93 55 34 22
summary(wiek) # <== dane liczbowe

Min. 1st Qu. Median Mean 3rd Qu. Max.



    1. 30.00 45.00 43.16 53.00 75.00





próby losowe
> sample(1:49,6)

[1] 3 19 33 15 34 13 <== mozemy wyręczyć totalizator

> sample(1:49,6)

[1] 47 25 5 18 49 14


dziesięć losowych liter

> sample(letters,10,T)

[1] "u" "q" "x" "s" "q" "f" "c" "f" "l" "x"

> # wylosujmy wektor cyfr od 1 do 3, z zadanymi prawdopodobieństwami wylosowania

> sample(1:3,20,replace=TRUE, prob=c(0.6,0.3,0.1))

[1] 2 3 1 1 3 3 1 1 1 1 1 2 1 1 1 2 1 1 2 2




R Y S O W A N I E
I. Rozkazy "wysokiego poziomu"

Każde użycie otwiera nowy rysunek (okno graficzne)

hist, barplot, pie, boxplot, (1-D plot) <== wykresy jednowymiarowe
plot, curve, matplot, pairs, ((x-y)plots) <== wykresy zalezności x,y
image, contour, filled.contour,... (2-D surface plots) <== powierzchnie 2 wym.
persp, scatterplot3d(4) (3-D plots) <== rysunki 3-wymiarowe

II. Rozkazy "niższego poziomu"

dodają nowe elementy do rysunku już wykonanego przez rozkaz

z grupy "wysokiego poziomu"

lines, points, segments, polygon, rect, text, arrows, legend, abline,

locator, rug, itd.



  1. Parametry definiujące:

a) wygląd obiektów na rysunku


cex (rozmiar tekstu i symboli),

col (kolor),

font (czcionka),

las (orientacja etykiet na osiach),

lty (rodzaj linii),

lwd (szerokość linii),

pch (rodzaj znaków reprezentujących punkty),

asp (stosunek długości odcinków na osiach x i y), itd.


b) wygląd okna graficznego

mar (wielkość marginesów),

mfrow (liczba obrazów w wierszu),

mfcol(liczba obrazów w kolumnie)


przykład 1:

x=1:100


y=runif(100)

plot(x,y) # rysujemy wykres x-y

z=rnorm(100) # generujemy 100 liczb o rozkładzie normalnym

points(x,z,col="red",pch=3) # i dorysowujemy je do istniejącego rysunku


przykład 2:

data(Orange)

head(Orange)
#rysujemy zależność obwodu pnia od wieku drzewka
plot(Orange$age, Orange$circumference,xlab="wiek, dni",

ylab="obwód pnia, mm", main= "Wzrost drzewek pomarańczowych")


#ponownie rysujemy, rozróżniając dane dla kolejnych pięciu drzewek
plot(Orange$age, Orange$circumference,xlab="wiek, dni",

ylab="circumference, mm", main= "Orange tree growth",

pch=(15:20)[Orange$Tree],

col=(1:5)[Orange$Tree],

cex=1.3)
legend("bottomright",pch=15:20,col=1:5,legend=1:5) # warto dodać legendę


Rysunki funkcji matematycznych
1) funkcja curve(wyrażenie)
np.

curve(sin(3*pi*x)) # zakres x [0,1], na podstawie 101 wartości

curve(sqrt(x)) # j.w.

curve(sqrt) # mozna podać tylko nazwę funkcji


# bardziej skoplikowany przypadek

curve(sin(3*pi*x),from=0,to=2,col="blue",

xlab="x",ylab="f(x)",main=" funkcja curve")
curve(cos(3*pi*x),add=TRUE,col="red",lty=2) # dorysujemy jeszcze cosinus add=TRUE dodaj do istniejącego rysunku
abline(h=0,lty=2) # dorysujemy linię poziomą na wysokosci 0 (h=0) jest to linia przerywana (lty=2) i dodamy opis

legend("bottomleft",legend=c("sin","cos"),text.col=c("blue","red"),lty=1:2)


Kilka rysunków obok siebie

funkcja par zmienia sposób rysowania


par(mfrow=c(3,2)) # rysunki w trzech wierszach i dwu kolumnach, rysowane wierszami
par(mfcol=c(3,2)) # rysunki w trzech wierszach i dwu kolumnach, rysowane kolumnami
przykład

par(mfrow=c(2,2))

for ( i in 1:4) curve(sin(i*pi*x),0,1,main=i)

Programowanie

Składnia instrukcji warunkowych
if (war) instrukcja # to może być tzw. instrukcja złożona: ciąg instrukcji ujętych w nawiasy klamrowe {.... }

if (war) # tutaj trzeba pilnować by "else"

instrukcja1 else instrukcja2 # else nie rozpoczynalo linijki

ifelse(war, instrukcja1,instrukcja2) # alternatywna wersja poprzedniej instrukcji, stosowana zwykle w przypadku gdy instrukcje 1 i 2 są krótkie


Przykłady

##################################################################

# Instrukcje warunkowe - przykłady

##################################################################


Wyznaczanie pierwiastków trójmianu kwadratowego

# równanie: a*x^2 +b*x + c = 0


a =

b =


c =
delta = b^2 - 4*a*c # obliczamy wartość delta
if (delta != 0.0) { #jeżeli delta różni sie od zera to mamy dwa różne pierwiastki

delta = as.complex(delta) # zamieniamy wielko?ć delta na liczbe zespoloną


x1 = (-b + sqrt(delta))/(2*a) # pierwiastek nr 1

x2 = (-b - sqrt(delta))/(2*a) # pierwiastek nr 2

cat("x1 = ",x1,"\n","x2 = ",x2,"\n") # możemy wyświetlić wyniki

} else { # jeżeli delta = 0 to x1=x2 (pierwiastek podwójny)

x1 = -b/(2*a) # wytarczy obliczyć tylko jeden pierwiastek

cat("x1 = x2 = ",x1,"\n") } # <== ten nawias kończy drugą instrukcję złożoną

# W powyższym przykładzie wykorzystano fakt, że liczby rzeczywiste

# są podzbiorem liczb zespolonych, gdy delta > 0 część urojona

# liczby zespolonej będzie miała wartość 0

#

# Jeżeli nie chcemy żeby maszyna wypisywała dla delta > 0 zbędne



# informacje o częściach urojonych wyników wystarczy niewielka

" zmiana w powyższym kodzie:

if(delta > 0.0) { x1 = Re(x1); x2 = Re(x2) } # funkcja Re pozostawia z liczby zespolonej tylko część rzeczywistą

# ^--- krótkie instrukcje możemy pisać w jednej linii oddzielając je od siebie średnikami

cat("x1 = ",x1,"\n","x2 = ",x2,"\n") # wyświetli wyniki,



  1   2


©operacji.org 2017
wyślij wiadomość

    Strona główna