Opérations vectorielles communes dans R

Détails
Catégorie parente: Logiciel R
Catégorie : Les vecteurs dans R

Examinons maintenant certaines opérations communes liées aux vecteurs. Nous allons couvrir les opérations arithmétiques et logiques, l'indexation des vecteurs et quelques façons utiles de créer des vecteurs. 


1 Opérations arithmétiques et logicielles vectorielles
Rappelez-vous que R est un langage fonctionnel. Chaque opérateur, y compris + dans l'exemple suivant, est en fait une fonction.

  1. > 2 + 3 
  2. [1] 5
  3. > "+" (2,3) 
  4. [1]
Source code

Rappelons en outre que les scalaires sont aussi des vecteurs à un élément. Nous pouvons donc ajouter des vecteurs, et l'opération + sera appliquée en fonction des éléments.

  1. > x <- c (l, 2,4)
  2. > x + c (5,0, -l) 
  3. [1] 6 2 3
Source code

Si vous connaissez l'algèbre linéaire, vous pouvez être étonné de ce qui se passe lorsque nous multiplions deux vecteurs.

  1. > x * c (5,0, -l) 
  2. [1] 5 0 -4
Source code

Mais rappelez-vous, en raison de la façon dont la fonction * est appliquée, la multiplication est faite élément par élément. Le premier élément du produit (5) est le résultat du premier élément de x (1) multiplié par le premier élément de c (5,0, -1) qui est (5), et ainsi de suite.
Le même principe s'applique aux autres opérateurs numériques. Voici un exemple:

  1. > x <- c (l, 2,4)
  2. > x / c (5,4, -l)
  3. [1] 0,2 0,5 -4,0
  4. > x %% c (5,4, -l) [1] 1 2 0
Source code


2 Indexation vectorielle
L'une des opérations les plus importantes et fréquemment utilisées dans R est celle des vecteurs d'indexation, dans lesquels nous formons un sous-vecteur en sélectionnant des éléments du vecteur donné pour des indices spécifiques. Le format est vector1 [vector2], nous sélectionnons les éléments de vector1 dont les indices sont donnés dans vector2.

  1. > y <- c (1.2, 3.9, 0.4, 0.12)
  2. > y [c (1,3)] # extraire les éléments 1 et 3 de y 
  3.  
  4. [1] 1.2 0.4
  5. > y [2: 3]
  6. [1] 3.9 0.4
  7. > v <- 3: 4
  8. > y [v]
  9. [1] 0,40 0,12
Source code
Notez que les doublons sont autorisés.
  1. > x <- c (4,2,17,5)
  2. > y <- x [c (1,1,3)]
  3. > y
  4. [1] 4 4 17
Source code
Les indices négatifs signifient que nous voulons exclure les éléments donnés dans notre production.

  1. > z <- c (5,12,13)
  2. > z [-1] # exclure l'élément 1 
  3. [1] 12 13
  4. > z [-1: -2] # exclure les éléments 1 à 2 
  5. [1] 13
Source code
Dans de tels contextes, il est souvent utile d'utiliser la fonction length (). Par exemple, supposons que nous souhaitons reprendre tous les éléments d'un vecteur z sauf pour le dernier. Le code suivant fera exactement cela:

  1. > z <- c (5,12,13)
  2. > z [1: (length (z) -1)] 
  3. [1] 5 12
Source code
Ou plus simplement:

  1. > z [-length (z)] 
  2. [1] 5 12
Source code
C'est plus général que d'utiliser z [1: 2]. Notre programme peut avoir besoin de travailler pour plus que des vecteurs de la longueur 2, et la deuxième approche nous donnerait cette généralité.


3 Générer des vecteurs utiles avec: Opérator
Il existe quelques opérateurs R qui sont particulièrement utiles pour créer des vecteurs. Commençons par l'opérateur du colon: qui a été introduit dans le chapitre 1. Il produit un vecteur constitué d'une gamme de nombres.

  1. > 5: 8
  2. [1] 5 6 7 8
  3. > 5: 1
  4. [1] 5 4 3 2 1
Source code
Vous vous souvenez peut-être qu'il a été utilisé plus tôt dans ce chapitre dans un contexte de boucle, comme suit:
pour (i en 1: longueur (x)) {
Méfiez-vous des problèmes de priorité des opérateurs.

  1. > i <- 2
  2. > 1: i-1 # signifie (1: i) - 1, pas 1: (i-1) 
  3. [1] 0 1
  4. > 1: (i-1)
  5. [1] 1
Source code
Dans l'expression 1: i-1, l'opérateur de colon a la priorité sur la soustraction. Donc, l'expression 1: i est évaluée en premier, en retournant 1: 2. R soustrait alors 1 de cette expression. Cela signifie soustraire un vecteur d'un élément d'un élément à deux éléments, ce qui se fait par recyclage. Le vecteur à un élément (1) sera étendu à (1,1) pour être de longueur compatible avec 1: 2. La soustraction élémentaire donne alors le vecteur (0,1).
Dans l'expression 1: (i-1), d'autre part, les parenthèses ont une priorité supérieure à celle du colon. Ainsi, 1 est soustrait de i, résultant en 1: 1, comme on le voit dans l'exemple précédent.


2.4.4 Générer des séquences vectorielles avec seq ()
Une généralisation de ":" est la fonction seq () (ou séquence), qui génère une séquence dans la progression arithmétique. Par exemple, tandis que 3: 8 donne le vecteur (3,4,5,6,7,8), les éléments étant espacés d'une unité (4 - 3 = 1,5 - 4 = 1, etc.), nous pouvons les distinguer, disons, trois unités:

  1. > seq (from = 12, to = 30, by = 3) [1] 12 15 18 21 24 27 30
Source code
L'espacement peut également être une valeur non-entière, disons 0.1.
  1. > seq (from = 1.1, to = 2, by = 10)
  2. [1] 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0
Source code
Une utilisation pratique pour seq () est de traiter le problème du vecteur vide que nous avons mentionné plus haut dans la section 2.1.2. Là, nous avons affaire à une boucle qui a commencé avec ceci:
pour (i en 1: length (x))
Si x est vide, cette boucle ne devrait pas comporter d'itérations, mais elle a en fait deux, puisque 1: length (x) est évaluée à (1,0). Nous pourrions résoudre ce problème en écrivant l'énoncé comme suit:
pour (i en seq (x))
Pour voir comment cela fonctionne, faisons un test rapide de seq ():

  1. > x <- c (5,12,13)
  2. > x
  3. [1] 5 12 13
  4. > seq (x)
  5. [1] 1 2 3
  6. > x <- NULL
  7. > x NULL
  8. > seq (x)
Source code
Vous pouvez voir que seq (x) nous donne le même résultat que 1: length (x) si x n'est pas vide, mais il évalue correctement sur NULL si x est vide, ce qui entraîne des itérations de zéro dans la boucle ci-dessus.

 

2.4.5 Constantes vectorielles répétées avec rep ()
La fonction rep () (ou répétition) nous permet de mettre le même élément dans les longs vecteurs. La forme d'appel est rep (x, times), ce qui crée un vecteur d'éléments times * length (x). Voici un exemple:

  1. > x <- rep (8,4)
  2. > x
  3. [1] 8 8 8 8
  4. > rep (c (5,12,13), 3)
  5. [1] 5 12 13 5 12 13 5 12 13
  6. > rep (1: 3,2)
  7. [1] 1 2 3 1 2 3
Source code

Il y a aussi un argument nommé chacun, avec un comportement très différent, qui entrecoupe les copies de x.

  1. > rep (c (5,12,13), chacun = 2) 
  2. [1] 5 5 12 12 13 13
Source code