R Language
Vectoren maken

Volgorde van nummers

Gebruik de operator : om reeksen getallen te maken, zoals voor gebruik bij het vectoriseren van grotere delen van uw code:

x <- 1:5
x
## [1] 1 2 3 4 5

Dit werkt beide kanten op

10:4
# [1] 10  9  8  7  6  5  4

en zelfs met getallen met drijvende komma

1.25:5
# [1] 1.25 2.25 3.25 4.25

of minpunten

-4:4
#[1] -4 -3 -2 -1  0  1  2  3  4

seq ()

seq is een flexibelere functie dan de operator : waarmee andere stappen dan 1 kunnen worden opgegeven.

De functie maakt een reeks vanaf het start (standaard is 1) tot het einde inclusief dat nummer.

U kunt alleen de parameter end ( to ) opgeven

seq(5)
# [1] 1 2 3 4 5

Evenals het begin

seq(2, 5) # or seq(from=2, to=5)
# [1] 2 3 4 5

En ten slotte de stap ( by )

seq(2, 5, 0.5) # or seq(from=2, to=5, by=0.5)
# [1] 2.0 2.5 3.0 3.5 4.0 4.5 5.0

seq kan optioneel de (gelijkmatig verdeelde) stappen afleiden wanneer alternatief de gewenste lengte van de uitgang ( length.out ) wordt geleverd

seq(2,5, length.out = 10)
# [1] 2.0 2.3 2.6 2.9 3.2 3.5 3.8 4.1 4.4 4.7 5.0

Als de reeks dezelfde lengte moet hebben als een andere vector, kunnen we de along.with als afkorting voor length.out = length(x)

x = 1:8
seq(2,5,along.with = x)
# [1] 2.000000 2.428571 2.857143 3.285714 3.714286 4.142857 4.571429 5.000000

Er zijn twee handige vereenvoudigde functies in de seq familie: seq_along , seq_len en seq.int . seq_along en seq_len functies construeren de natuurlijke (tel) getallen van 1 tot en met N waarbij N wordt bepaald door het functieargument, de lengte van een vector of lijst met seq_along en het argument met gehele getallen met seq_len .

seq_along(x)
# [1] 1 2 3 4 5 6 7 8

Merk op dat seq_along de indices van een bestaand object retourneert.

# counting numbers 1 through 10
seq_len(10)
[1]  1  2  3  4  5  6  7  8  9 10
# indices of existing vector (or list) with seq_along
letters[1:10]
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
seq_along(letters[1:10])
[1]  1  2  3  4  5  6  7  8  9 10

seq.int is hetzelfde als seq onderhouden voor oude compatibiliteit.

Er is ook een oude functie sequence die een vector sequenties van een niet negatief argument creëert.

sequence(4)
# [1] 1 2 3 4
sequence(c(3, 2))
# [1] 1 2 3 1 2
sequence(c(3, 2, 5))
# [1] 1 2 3 1 2 1 2 3 4 5

vectoren

Vectoren in R kunnen verschillende typen hebben (bijv. Geheel getal, logisch, teken). De meest algemene manier om een vector te definiëren is door de functievector vector() .

vector('integer',2) # creates a vector of integers of size 2.
vector('character',2) # creates a vector of characters of size 2.
vector('logical',2) # creates a vector of logicals of size 2.

In R zijn de steno-functies over het algemeen populairder.

integer(2) # is the same as vector('integer',2) and creates an integer vector with two elements
character(2) # is the same as vector('integer',2) and creates an character vector with two elements
logical(2) # is the same as vector('logical',2) and creates an logical vector with two elements

Het maken van vectoren met andere waarden dan de standaardwaarden is ook mogelijk. Vaak wordt hiervoor de functie c() gebruikt. De c staat voor combineren of aaneenschakelen.

c(1, 2) # creates a integer vector of two elements: 1 and 2.
c('a', 'b') # creates a character vector of two elements: a and b.
c(T,F) # creates a logical vector of two elements: TRUE and FALSE.

Belangrijk om op te merken is dat R elk geheel getal (bijv. 1) interpreteert als een geheel getal van grootte één. Hetzelfde geldt voor cijfers (bijvoorbeeld 1.1), logica (bijvoorbeeld T of F) of tekens (bijvoorbeeld 'a'). Daarom combineer je in wezen vectoren, die op hun beurt vectoren zijn.

Let op dat je altijd vergelijkbare vectoren moet combineren. Anders zal R proberen de vectoren om te zetten in vectoren van hetzelfde type.

c(1,1.1,'a',T) # all types (integer, numeric, character and logical) are converted to the 'lowest' type which is character.

Het vinden van elementen in vectoren kan worden gedaan met de [ operator.

vec_int <- c(1,2,3)
vec_char <- c('a','b','c')
vec_int[2] # accessing the second element will return 2
vec_char[2] # accessing the second element will return 'b'

Dit kan ook worden gebruikt om waarden te wijzigen

vec_int[2] <- 5 # change the second value from 2 to 5
vec_int # returns [1] 1 5 3

Ten slotte kan de operator : (afkorting van de functie seq() ) worden gebruikt om snel een vector met getallen te maken.

vec_int <- 1:10
vec_int # returns [1] 1 2 3 4 5 6 7 8 9 10

Dit kan ook worden gebruikt om vectoren in te stellen (van eenvoudige tot meer complexe subsets)

vec_char <- c('a','b','c','d','e')
vec_char[2:4] # returns [1] "b" "c" "d"
vec_char[c(1,3,5)] # returns [1] "a" "c" "e"

Benoemde vectoren maken

Benoemde vector kan op verschillende manieren worden gemaakt. Met c :

xc <- c('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

wat resulteert in:

> xc
a b c d 
5 6 7 8

met list :

xl <- list('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

wat resulteert in:

> xl
$a
[1] 5

$b
[1] 6

$c
[1] 7

$d
[1] 8

Met de functie setNames kunnen twee vectoren van dezelfde lengte worden gebruikt om een benoemde vector te maken:

x <- 5:8
y <- letters[1:4]

xy <- setNames(x, y)

wat resulteert in een benoemde integer vector:

> xy
a b c d 
5 6 7 8

Zoals te zien is, geeft dit hetzelfde resultaat als de c methode.

U kunt ook de functie names gebruiken om hetzelfde resultaat te krijgen:

xy <- 5:8
names(xy) <- letters[1:4]

Met zo'n vector is het ook mogelijk om elementen op naam te selecteren:

> xy["c"]
c 
7 

Deze functie maakt het mogelijk om een dergelijke benoemde vector te gebruiken als een opzoekvector / tabel om de waarden te matchen met waarden van een andere vector of kolom in het dataframe. Overweegt het volgende dataframe:

mydf <- data.frame(let = c('c','a','b','d'))

> mydf
  let
1   c
2   a
3   b
4   d

Stel dat u een nieuwe variabele in het mydf dataframe wilt maken met de naam num met de juiste waarden van xy in de rijen. Met de match functie kunnen de juiste waarden uit xy worden geselecteerd:

mydf$num <- xy[match(mydf$let, names(xy))]

wat resulteert in:

> mydf
  let num
1   c   7
2   a   5
3   b   6
4   d   8

Een vector uitbreiden met de functie rep ()

De rep functie kan worden gebruikt om een vector op een redelijk flexibele manier te herhalen.

# repeat counting numbers, 1 through 5 twice
rep(1:5, 2)
[1] 1 2 3 4 5 1 2 3 4 5

# repeat vector with incomplete recycling
rep(1:5, 2, length.out=7)
[1] 1 2 3 4 5 1 2

Het argument elke is met name handig voor het uitbreiden van een vector van statistieken van observationele / experimentele eenheden naar een vector van data.frame met herhaalde waarnemingen van deze eenheden.

# same except repeat each integer next to each other
rep(1:5, each=2)
[1] 1 1 2 2 3 3 4 4 5 5

Een leuk kenmerk van rep betrekking tot uitbreiding van een dergelijke gegevensstructuur is dat uitbreiding van een vector naar een ongebalanceerd paneel kan worden bereikt door het lengte-argument te vervangen door een vector die het aantal keren dicteert om elk element in de vector te herhalen:

# automated length repetition
rep(1:5, 1:5)
 [1] 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
# hand-fed repetition length vector
rep(1:5, c(1,1,1,2,2))
[1] 1 2 3 4 4 5 5

Dit zou de mogelijkheid moeten blootleggen om een externe functie toe te staan het tweede argument van rep te voeden om dynamisch een vector te construeren die volgens de gegevens uitbreidt.

Net als bij seq zijn snellere, vereenvoudigde versies van rep rep_len en rep.int . Deze laten sommige attributen achter die rep onderhoudt en kan dus het meest nuttig zijn in situaties waar snelheid een zorg is en aanvullende aspecten van de herhaalde vector onnodig zijn.

# repeat counting numbers, 1 through 5 twice
rep.int(1:5, 2)
[1] 1 2 3 4 5 1 2 3 4 5

# repeat vector with incomplete recycling
rep_len(1:5, length.out=7)
[1] 1 2 3 4 5 1 2

Vectoren van ingebouwde constanten: reeksen letters en maandnamen

R heeft een aantal ingebouwde constanten. De volgende constanten zijn beschikbaar:

• LETTERS : de 26 hoofdletters van het Romeinse alfabet
• letters : de 26 kleine letters van het Romeinse alfabet
• month.abb : de drieletterige afkortingen voor de Engelse month.abb
• month.name : de Engelse namen voor de maanden van het jaar
• pi : de verhouding tussen de omtrek van een cirkel en zijn diameter

Van de letters en maandconstanten kunnen vectoren worden gemaakt.

1) Reeksen letters:

> letters
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"

> LETTERS[7:9]
[1] "G" "H" "I"

> letters[c(1,5,3,2,4)]
[1] "a" "e" "c" "b" "d"

2) Sequenties van maandafkortingen of maandnamen:

> month.abb
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

> month.name[1:4]
[1] "January"  "February" "March"    "April"   

> month.abb[c(3,6,9,12)]
[1] "Mar" "Jun" "Sep" "Dec"