Czynniki
Tworzenie czynników
Czynnikiem nazywamy zmienną która ma kilka, za to wielokrotnie powtarzających się wartości. Zawsze są to zmienne dyskretne, a bardzo często są to zmienne o wartościach tekstowych. Ich przechowanie w pamięci komputera polega na przechowaniu krótkiego ciągu różnych wartości, które może mieć czynnik, przypisaniu tym wartościom liczb od 1 do n oraz przechowaniu ciągu liczbowego, w którym wartości wyjściowego ciągu zostają zamienione na przypisane im liczby.
Czynniki tworzy się funkcją factor(), której argumentem są wektory.
> cc=factor(c(3:1,1:3,c(2,3,1)))
> cc
[1] 3 2 1 1 2 3 2 3 1
Levels: 1 2 3
> cc=factor(c("c", "a", "b", "a", "b", "c", "c", "b", "c"))
> cc
[1] c a b a b c c b c
Levels: a b c
|
Czynnik można utworzyć z wektorów o nazwanych wyrazach. W poziomie levels: zostają wyszczególnione tylko różne wartości tego wektora.
> c=c(0,1,4,0,0,1,4,0,1)
> names(c)=rep(c("a","b","c"),3)
> c
a b c a b c a b c
0 1 4 0 0 1 4 0 1
> cc=factor(c)
> cc
a b c a b c a b c
0 1 4 0 0 1 4 0 1
Levels: 0 1 4
|
Zazwyczaj czynnik wyświetla nazwy kryjące się za liczbami występującymi w pierwszym wierszu. Sprawia to wrażenie, że czynnik to ten sam ciąg, z którego tworzy sią czynnik z dołączonym wykazem możliwych wartości. Pewne operacje ujawniają jednak liczby, które się kryją za tymi nazwami.
> aa=factor(c(0,5,4,0,0,5,4,0,5)) > aa [1] 0 5 4 0 0 5 4 0 5 Levels: 0 5 4 > bb=factor(c(6,3,6,5,5,5,3)) > bb [1] 6 3 6 5 5 5 3 Levels: 3 5 6 > factor(c(aa,bb)) [1] 1 3 2 1 1 3 2 1 3 3 1 3 2 2 2 1 Levels: 1 2 3 > # Jeżeli celem jest zrobienie czynnika z wektora c(0,5,4,0,0,5,4,0,5,6,3,6,5,5,5,3) to: > cc=factor(c(as.vector(aa),as.vector(bb))) > cc [1] 0 5 4 0 0 5 4 0 5 6 3 6 5 5 5 3 Levels: 0 3 4 5 6 |
Dla czynników niekiedy znamy maksymalną liczbę różnych wartości, które tego typu zmienne mogą posiadać. Tworząc czynnik powinno się te zmienne wpisać za pomocą opcji levels, nawet gdy wprowadzony na początku czynnik nie ma (jeszcze) takich wartości.
> c=c("samiec", "samiec", "samiec", "samiec", "samiec")
> cc=factor(c, levels=c("samiec", "samica"))
> cc
[1] samiec samiec samiec samiec samiec
Levels: samiec samica
|
Inną opcją funkcji factor() jest label, która umożliwia automatyczną zmianę wartości ciągu, z którego tworzony jest czynnik na inne, zazwyczaj dłuższe, ale bardziej czytelne. Nowe nazwy należy ustawić w takim porządku, w jakim porządkują się alfabetycznie nazwy w ciągu wyjściowym, by właściwie je przyporządkować. Jeżeli nie jest to możliwe, należy użyć opcji level z odpowiednim porządkiem istniejących nazw.
> c=c("Af", "Af", "Aa", "Aa", "Af", "Aa", "Aa", "Af")
> cc=factor(c, label=c("Apodemus_flavicollis", "Apodemus_arvalis"))
> cc
[1] Apodemus_arvalis Apodemus_arvalis Apodemus_flavicollis
[4] Apodemus_flavicollis Apodemus_arvalis Apodemus flavicollis
[7] Apodemus_flavicollis Apodemus_arvalis
Levels: Apodemus_flavicollis Apodemus_arvalis
> cc=factor(c, level=c("Af", "Aa"), label=c("Apodemus_flavicollis", "Apodemus_arvalis"))
> cc
[1] Apodemus_flavicollis Apodemus_flavicollis Apodemus_arvalis
[4] Apodemus_arvalis Apodemus_flavicollis Apodemus_arvalis
[7] Apodemus_arvalis Apodemus_flavicollis
Levels: Apodemus_flavicollis Apodemus_arvalis
|
Zdarza się, że wartości zmiennych, z których tworzymy czynnik, posiadają naturalny porządek niezgodny z porządkiem alfabetycznym i chcemy by te wartości pojawiały się w naturalnym porządku na poziomie levels:. Przy tworzeniu czynnika należy użyć wtedy opcji levels i określić porządek wartości oraz opcji logicznej ordered i dać jej wartość TRUE.
> c=c("poniedziałek", "wtorek", "wtorek", "środa", "czwartek", "czwartek", "czwartek",
+ "piątek", "sobota", "niedziela", "poniedziałek", "środa")
> cc=factor(c)
> cc
[1] poniedziałek wtorek wtorek środa czwartek czwartek czwartek
[8] piatek sobota niedziela poniedziałek środa
Levels: czwartek niedziela piatek poniedziałek sobota środa wtorek
> cc=factor(c,levels=c("poniedziałek", "wtorek", "środa", "czwartek", "piątek", "sobota",
+ "niedziela"), ordered=TRUE)
[1] poniedziałek wtorek wtorek środa czwartek czwartek czwartek
[8] piątek sobota niedziela poniedziałek środa
Levels: poniedziałek < wtorek < środa < czwartek < piątek < sobota < niedziela
|
Ciekawym sposobem na tworzenie czynników jest funkcja gl(). Ma ona składnie gl(n,k) i tworzy ciąg liczbowy, w których liczby od 1 do n powtarzają się k razy (to samo co rep(1:n,each=k)), a następnie przekształca go na czynnik. Liczby od 1 do n można zamienić na teksty za pomocą opcji labels=c(). Ciąg nazw przy opcji labels musi mieć n elementów.
> gl(3,5)
[1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3
Levels: 1 2 3
> gl(3,5, labels=c("10_stopni", "15_stopni", "kontrola"))
[1] 10_stopni 10_stopni 10_stopni 10_stopni 10_stopni 15_stopni 15_stopni 15_stopni
[9] 15_stopni 15_stopni kontrola kontrola kontrola kontrola kontrola
Levels: 10_stopni 15_stopni kontrola
|
Czynniki zaimplementowane do R
Do R zaimplementowano kilka czynników stałych, na których można ćwiczyć różne operacje. Przykładowo state.region jest czynnikiem pokazującym przyjęte określenie rozmieszczenia geograficznego każdego z 50 stanów USA.
> state.region [1] South West West South West West [7] Northeast South South South West West [13] North Central North Central North Central North Central South South [19] Northeast South Northeast North Central North Central South [25] North Central West North Central West Northeast Northeast [31] West Northeast South North Central North Central South [37] West Northeast Northeast South North Central South [43] South West Northeast South West South [49] North Central West Levels: Northeast South North Central West |
Odwołanie się do elementów czynnika
Odwołanie się do wybranych wartości czynnika jest takie same jak odwołanie się do tych wartości w wektorze. Jednak odpowiedź programu nieco inaczej wygląda.
> a=c("kawa", "kakao", "kawa", "herbata", "kawa", "kakao")
> a[1]
[1] "kawa"
> aa=factor(a)
> aa[1]
[1] "kawa"
Levels: herbata kakao kawa
|
Do wybranych wyrazów czynnika można się odwoływać zarówno przez wskazanie indeksów jak i ciąg wartości logicznych.
> b=c("Lis", "Foka", "Bóbr", "Lis", "Lis", "Bóbr")
> bb=factor(b)
> bb
[1] Lis Foka Bóbr Lis Lis Bóbr
Levels: Bóbr Foka Lis
> bb[c(1,2,4,5)]
[1] Lis Foka Lis Lis
Levels: Bóbr Foka Lis
> bb[c(TRUE,TRUE,FALSE,TRUE,TRUE,FALSE)]
[1] Lis Foka Lis Lis
Levels: Bóbr Foka Lis
|
Odwołania przez indeksy lub ciąg wartości logicznych nie zmieniaja poziomu levels:, nawet wtedy, gdy czynnik po takim odwołaniu nie posiada pwnych wartości wyróżnionych w poziomie levels:.
Wektor wartości czynników łatwo jest uzyskać stosując funkcje as.vector(). Powstały ciąg jest tożsamy z ciągiem wyjściowym użytym do utworzenia czynnika, tylko wartości liczbowe zostają zamienione na tekstowe. Odwołanie się do poziomu levels:, czyli wyświetlenie, jakie różne wartości występują w czynniku, umożliwia funkcja levels()
> bb=factor(rep(letters[1:4],each=3)) > bb [1] a a a b b b c c c d d d Levels: a b c d > as.vector(bb) [1] "a" "a" "a" "b" "b" "b" "c" "c" "c" "d" "d" "d" > levels(bb) [1] "a" "b" "c" "d"> bb=factor(rep(1:4,each=3)) > bb [1] 1 1 1 2 2 2 3 3 3 4 4 4 Levels: 1 2 3 4 > as.vector(bb) [1] "1" "1" "1" "2" "2" "2" "3" "3" "3" "4" "4" "4" > level(bb) [1] "1" "2" "3" "4" |
Edycja czynników
Poprzez odwołanie czynnik[n] można zamienić wartość n-tego wyrazu czynnika pod warunkiem, że nowa nazwa będzie występować w poziomie levels: czynnika.
> a=c("kawa", "kakao", "kawa", "herbata", "kawa", "kakao")
> aa=factor(a)
> aa[6]="kawa"
> aa
[1] kawa kakao kawa herbata kawa kawa
Levels: herbata kakao kawa
> aa[6]="mleko"
Komunikat ostrzegawczy:
W poleceniu '`[<-.factor`(`*tmp*`, 6, value = "mleko")':
invalid factor level, NA generated
> aa
[1] kawa kakao kawa herbata kawa <NA>
Levels: herbata kakao kawa
|
Wprowadzenie nowej wartości w dowolne miejsce czynnika musi poprzedzić wprowadzenie tej wartości do poziomu levels:. Wektor ten wywołuje się funkcją levels() i wtedy można go zmodyfikować.
> aa=factor(c("kawa", "kakao", "kawa", "herbata", "kawa", "kakao"))
> levels(aa)
[1] "herbata" "kakao" "kawa"
> levels(aa)=c(levels(aa),"mleko")
> aa[6]="mleko"
> aa
[1] kawa kakao kawa herbata kawa mleko
Levels: herbata kakao kawa mleko
|
Zdarza się, że wszystkie elementy czynnika o danej wartości należy zamienić. Najlepiej taką zamianę zrobić w wektorze, który wywołuje się funkcją levels(czynnik).
> aa=factor(c(1987, 1995, 1987, 1987, 1995)) > aa [1] 1987 1995 1987 1987 1995 Levels: 1987 1995 > levels(aa)[1]=1997 > aa [1] 1997 1995 1997 1997 1995 Levels: 1997 1995 |
Czynniki można tworzyć z uporządkowanymi wartościami na poziomie levels: według zadanego klucza. Czasem dopiero po utworzeniu czynnika pojawia się potrzeba innego uporządkowania wartości na tym poziomie. Aby zmienić uporządkowanie nazw należy użyć funkcji ordered().
> aa=factor(c("wiosna","lato","wiosna","jesień","zima","lato","wiosna"))
> aa
[1] wiosna lato wiosna jesień zima lato wiosna
Levels: jesien lato wiosna zima
> bb=ordered(aa,levels=c("wiosna","lato","jesień","zima"))
> bb [1] wiosna lato wiosna jesień zima lato wiosna
Levels: wiosna < lato < jesień < zima
|
Czasami chcemy jakąś wartość występującą w levels wykluczyć. Służy do tego opcja exclude.
> c=c("Af", "Af", "Aa", "Aa", "Af", "Aa", "Aa", "Af")
> cc=factor(c, levels=c("Aa", "Af", "Mg"))
> cc
[1] Af Af Aa Aa Af Aa Aa Af
Levels: Aa Af Mg
> dd=factor(cc, exclude="Mg")
Komunikat ostrzegawczy:
W poleceniu 'as.vector(exclude, typeof(x))':
pojawiły się wartości NA na skutek przekształcenia
> dd
[1] Af Af Aa Aa Af Aa Aa Af
Levels: Aa Af
|
Komunikat dotyczy ewentualnego błędu, który nie pojawia się, gdy w czynniku nie ma wartości wymienionych w ciągu exclude. Gdyby w wyjściowym ciągu była wartość “Mg” pojawiłaby się w tym miejscu wartość pomijalna NA.
Wykrawanie fragmentu czynnika może być wykonane poprzez wskazanie indeksów lub wskazanie poprzez funkcje logiczne.
> bb=factor(c("Ala","Ola","Ala","Ela","Ola","Ala"))
> cc=bb[1:3]
> cc
[1] Ala Ola Ala
Levels: Ala Ela Ola
> dd=bb[c(TRUE,TRUE,FALSE,FALSE,TRUE,TRUE)]
> dd
[1] Ala Ola Ola Ala
Levels: Ala Ela Ola
> ee=bb[bb!="Ela"]
> ee
[1] Ala Ola Ala Ola Ala
Levels: Ala Ela Ola
|
Łączenie czynników można wykonać za pomocą formuły:
factor(c(as.vector(czynnik_1),as.vector(czynnik_2)))Trochę krótszy sposób wymaga utworzenia obiektu, który jest opisany w następnym rozdziale (listy) za pomocą funkcji list(), a następnie przekształcenie go funkcją unlist().
> aa=factor(c(1,1,3,3,5,5)) > aa [1] 1 1 3 3 5 5 Levels: 1 3 5 > bb=factor(c(2,2,3,3,4,4)) > bb [1] 2 2 3 3 4 4 Levels: 2 3 4 > cc=factor(c(as.vector(aa),as.vector(bb))) > cc [1] 1 1 3 3 5 5 2 2 3 3 4 4 Levels: 1 2 3 4 5 > cc=unlist(list(aa,bb)) > cc [1] 1 1 3 3 5 5 2 2 3 3 4 4 Levels: 1 3 5 2 4 |
Czynnik utworzony za pomoca złożenia funkcji unlist(list()) jest poprawny, choć jego wartości w poziomie levels: już nie zawsze są uporządkowane alfabetycznie lub liczbowo.
Funkcje i operacje na czynnikach
Funkcje mode(czynnik) i typeof(czynnik) analizują wyłącznie ciąg liczbowy i pokazują typ jego elementów, a funkcja str(czynnik) dokładnie pokazuje strukturę czynnika.
> cc=factor(c("c", "a", "b", "a", "b", "c", "c", "b", "c"))
> mode(cc)
[1] "numeric"
> typeof(cc)
[1] "integer"
> class(cc)
[1] "factor"
> str(cc)
Factor w/ 3 levels "a","b","c": 3 1 2 1 2 3 3 2 3
|
Do odczytywania wartości występujących w czynnikach służy funkcja levels(). Do wyliczenia liczby różnych wartości występujących w czynnikach służy funkcja nlevels(). Natomiast do wyliczenia długości czynnika (liczbę wszystkich jego wyrazów) służy funkcja length().
> cc=factor(c("Af", "Af", "Aa", "Aa", "Af", "Aa", "Aa", "Af"))
> levels(cc)
[1] "Aa" "Af"
> nlevels(cc)
[1] 3
> length(cc)
[1] 8
|
Podstawowa operacja statystyczna, stosowana przy opracowywaniu czynników, polega na wyliczeniu, ile obiektów w czynniku ma pierwszą wartość, drugą, trzecią itd. Następnie liczby te pokazuje się jako ułamek ogólnej liczebności (frakcję) lub procent ogólnej liczebności. W R najczęściej stosuje się do tego funkcję table() lub summary().
> cc=factor(c("b", "a", "c", "c", "b", "c", "a", "b"))
> table(cc)
cc
a b c
2 3 3
table(cc)/length(cc)
cc
a b c
0.250 0.375 0.375
> table(cc)/length(cc)*100
cc
a b c
25.0 37.5 37.5
> summary(cc)
a b c
2 3 3
> summary(cc)/length(cc)*100
a b c
25.0 37.5 37.5
|
Funkcje table() i summary() generują obiekty typu tablicowego, o którym mowa będzie później. Pokazują one, ile jest w czynniku wyrazów o danej wartości. Wartości te są uporządkowane taki sam sposób, w jakim są one uporządkowane w czynniku na poziomie levels:
> a=c("wiosna", "lato", "wiosna", "zima", "zima", "jesień", "wiosna")
> table(a)
a
jesień lato wiosna zima
1 1 3 2
> table(factor(a))
jesień lato wiosna zima
1 1 3 2
> table(factor(a, levels=c("wiosna", "lato", "jesień", "zima"), ordered=TRUE))
wiosna lato jesień zima
3 1 1 2
|
Czynników, nawet jeśli ich wartościami są liczby, nie przekształca się funkcjami matematycznymi. Próba takich operacji kończy się błędem. Kiedy istnieje potrzeba takich przekształceń trzeba najpierw czynnik przekształcić funkcją as.vector() na wektor. W wyniku uzyska się wektor o wartościach tekstowych. Trzeba go przekształcić funkcją as.numeric(), wykonać operację, a wynik, który chcemy traktować jako czynnik, należy przekształcić funkcją as.factor().
> cc=factor(c(94, 94, 96, 96, 99, 99)) > cc+1900 [1] NA NA NA NA NA NA Komunikat ostrzegawczy: W poleceniu 'Ops.factor(cc, 1900)': + nie ma sensu dla czynników > as.vector(cc) [1] "94" "94" "96" "96" "99" "99" > as.numeric(as.vector(cc)) [1] 94 94 96 96 99 99 > as.numeric(as.vector(cc))+1900 [1] 1994 1994 1996 1996 1999 1999 > as.factor(as.numeric(as.vector(cc))+1900) [1] 1994 1994 1996 1996 1999 1999 Levels: 1994 1996 1999 |
Choć na wartościach czynników nie wykonuje się działań, może być z nimi związany ciąg liczbowy, np. wypłat z bankomatu w każdym dniu tygodnia. Działania mogą być ważne po zgrupowaniu liczb względem wartości czynnika. Takie działania wykonuje się funkcją tapply().
> cc=factor(c(rep("poniedziałek",2),rep("wtorek",3),rep("środa",5),rep("czwartek",2), rep("piątek",1)))
> cc=ordered(cc, levels=c("poniedziałek", "wtorek", "środa", "czwartek", "piątek"))
> cc
[1] poniedziałek poniedziałek wtorek wtorek wtorek środa środa
[8] środa środa środa czwartek czwartek piątek
Levels: poniedziałek < wtorek < środa < czwartek < piątek
> dd=c(150,50,100,100,200,50,50,100,50,50,300,100,350)
> tapply(dd,cc,sum)
poniedziałek wtorek środa czwartek piątek
200 400 300 400 350
|
Funkcje w tapply() mogą być dowolnymi funkcjami zdefiniowanymi dla ciągów (np. mean(), sd(), var(), range()) lub zdefiniowanymi przez użytkownika według schematu ‘function(x) formuła’. Przykładowo może być to: tapply(dd,cc,function(x) mean((x-mean(x))^2)).
Czasami trzeba połączyć ze sobą parami wartości kilku wektorów lub czynników równej długości by uzyskać ciąg będący połączeniem nazw występujących na danym miejscu w ciągach składowych. Służy do tego funkcja interaction(). Wynikiem takiej operacji jest nie ciąg, ale czynnik.
> rodzaj=c("Apodemus", "Apodemus", "Myodes")
> rozsz.gatunkowe = c("flavicolis", "agrarius", "glareolus")
> interaction(rodzaj, rozsz.gatunkowe)
[1] Apodemus.flavicolis Apodemus.agrarius Myodes.glareolus
6 Levels: Apodemus.agrarius Myodes.agrarius Apodemus.flavicolis Myodes.flavicolis ... Myodes.glareolus
> gat=factor(interaction(rodzaj, rozsz.gatunkowe),exclude=c("Myodes.agrarius", "Myodes.flavicolis", "Apodemus.glareolus"))
Komunikat ostrzegawczy:
W poleceniu 'as.vector(exclude, typeof(x))':
pojawiły się wartości NA na skutek przekształcenia
> gat
[1] Apodemus.flavicolis Apodemus.agrarius Myodes.glareolus
Levels: Apodemus.agrarius Apodemus.flavicolis Myodes.glareolus
|
R utworzył obiekt typu factor dla 6 gatunków (w tym trzech nie istniejących). Trzeba było posłużyć opcją exclude, albo zamienić wynikowy czynnik na wektor i znowu utworzyć z niego czynnik. Innym sposobem na wyczyszczenie poziomu levels: czynnika po zastosowaniu funkcji interaction() jest zastosowanie złożenia funkcji as.vector(interaction()) i ewentualna zamiana tego wektora na czynnik.
Jedną z bardziej interesujących możliwości R jest automatyczna zamiana zmiennej ciągłej na zmienną dyskretną poprzez przydzielenie każdej wartości zmiennej przedziału do którego ta wartość należy. Stosuje się do tego celu funkcję cut(). Powstaje w ten sposób obiekt typu factor.
> dane=c(2.7, 4.1, 3.6, 3, 4, 3.4, 2.6, 3.2, 3.6, 3.4, 4.2, 3.4, 4.8, 3.1, 3.7, 3.5, 4.1, 3.3, 2.9, 3.1, 4.2, 4.1, 3, 3.5, 4.4, 3.9, 4.8, 4, 4.5, 4, 4.5, 3.9, 3.6, 3.5, 3.5, 2.4, 4.2, 3.8, 3.3, 3.9, 3.3, 3.5, 3.8, 3.7, 4.4, 3.9, 3.8, 3, 4.5, 4.4) > dane2=cut(dane,1.5+(1:8/2)) > dane2 [1] (2.5,3] (4,4.5] (3.5,4] (2.5,3] (3.5,4] (3,3.5] (2.5,3] (3,3.5] (3.5,4] [10] (3,3.5] (4,4.5] (3,3.5] (4.5,5] (3,3.5] (3.5,4] (3,3.5] (4,4.5] (3,3.5] [19] (2.5,3] (3,3.5] (4,4.5] (4,4.5] (2.5,3] (3,3.5] (4,4.5] (3.5,4] (4.5,5] [28] (3.5,4] (4,4.5] (3.5,4] (4,4.5] (3.5,4] (3.5,4] (3,3.5] (3,3.5] (2,2.5] [37] (4,4.5] (3.5,4] (3,3.5] (3.5,4] (3,3.5] (3,3.5] (3.5,4] (3.5,4] (4,4.5] [46] (3.5,4] (3.5,4] (2.5,3] (4,4.5] (4,4.5] Levels: (2,2.5] (2.5,3] (3,3.5] (3.5,4] (4,4.5] (4.5,5] (5,5.5] > table(dane2) dane2 (2,2.5] (2.5,3] (3,3.5] (3.5,4] (4,4.5] (4.5,5] (5,5.5] 1 6 14 15 12 2 0 |
W przytoczonym przykładzie granice wybierano co 0.5kg. Nic nie stoi na przeszkodzie by wybierać granice końca przedziałów tak, by powstały przedziały o nierównej szerokości. Czasami to może się przydać.
W funkcji cut() pierwszym argumentem jest ciąg liczbowy, drugim granice przedziałów. Najmniejsza liczba w drugim ciągu jest początkiem pierwszego przedziału, a największa – końcem ostatniego przedziału. Jeżeli dane w pierwszym ciągu są mniejsze od najmniejszej wartości drugiego ciągu przypisany im przedział ma wartość NA. Podobnie, danym pierwszego ciągu większym od największej wartości drugiego ciągu przypisywana jest wartość NA – przedział pomijalny.
Wśród interesujących opcji funkcji cut() jest labels= umożliwiająca zamianę przedziałów na wybrane nazwy albo np. ich środki, right=TRUE powodująca zamianę danych na przedziały lewostronnie domknięte (standardowo są prawostronnie domknięte) oraz include.lowest=TRUE powodująca, że najmniejszy z przedziałów jest obustronnie domknięty.
> d=c(1,5,4,2,3,4,1,5,4,1,2,6,4,7) > cut(d,c(5,2,4)) [1] <NA> (4,5] (2,4] <NA> (2,4] (2,4] <NA> (4,5] (2,4] <NA> <NA> <NA> (2,4] <NA> Levels: (2,4] (4,5] > cut(d,c(5,2,4), right=FALSE) [1] <NA> <NA> [4,5) [2,4) [2,4) [4,5) <NA> <NA> [4,5) <NA> [2,4) <NA> [4,5) <NA> Levels: [2,4) [4,5) > cut(d,c(5,2,4), right=FALSE, include.lowest=TRUE) [1] <NA> [4,5] [4,5] [2,4) [2,4) [4,5] <NA> [4,5] [4,5] <NA> [2,4) <NA> [4,5] <NA> Levels: [2,4) [4,5] > cut(d,c(5,2,4), right=FALSE, include.lowest=TRUE, labels=c(3,4.5)) [1] <NA> 4.5 4.5 3 3 4.5 <NA> 4.5 4.5 <NA> 3 <NA> 4.5 <NA> Levels: 3 4.5 |
Funkcja cut() działa także na obiektach klasy POSIXt umożliwiając podział względem jednostek czasu. Wygląda to następująco:
> x=seq(ISOdate(2022,12,09,tz=""),ISOdate(2023,03,10,tz=""),by="week") > x [1] "2022-12-09 12:00:00 CET" "2022-12-16 12:00:00 CET" "2022-12-23 12:00:00 CET" [4] "2022-12-30 12:00:00 CET" "2023-01-06 12:00:00 CET" "2023-01-13 12:00:00 CET" [7] "2023-01-20 12:00:00 CET" "2023-01-27 12:00:00 CET" "2023-02-03 12:00:00 CET" [10] "2023-02-10 12:00:00 CET" "2023-02-17 12:00:00 CET" "2023-02-24 12:00:00 CET" [13] "2023-03-03 12:00:00 CET" "2023-03-10 12:00:00 CET" > cut(x, breaks="month") [1] 2022-12-01 2022-12-01 2022-12-01 2022-12-01 2023-01-01 2023-01-01 2023-01-01 [8] 2023-01-01 2023-02-01 2023-02-01 2023-02-01 2023-02-01 2023-03-01 2023-03-01 Levels: 2022-12-01 2023-01-01 2023-02-01 2023-03-01 |
W efekcie powstał czynnik złożony z obiektów klasy Date, w którym dzień miesiąca został zmieniony do 1. Pozwala to zobaczyć i policzyć tygodnie których piątki (dlatego, że w dniu 09/12/2022 był piątek) występowały w danym miesiącu.
Szczegółowe omówienie funkcji cut() wynika z jej przydatności w opracowaniu danych biologicznych.