Rechercher des éléments de tableau qui remplissent certaines conditions

Ouvrir le live script

Cet exemple montre comment filtrer les éléments d’un tableau en lui appliquant des conditions. Par exemple, il est possible d’examiner les éléments pairs d’une matrice, de localiser tous les zéros dans un tableau multidimensionnel ou de remplacer les valeurs NaN dans les données. Vous pouvez effectuer ces tâches en combinant des opérateurs relationnels et logiques. Les opérateurs relationnels (>, <, >=, <=, == et ~=) imposent des conditions au tableau. Vous pouvez appliquer plusieurs conditions en les reliant par les opérateurs logiques and, or et not respectivement représentés par les symboles &, | et ~.

Appliquer une seule condition

Pour appliquer une seule condition, commencez par créer une matrice de 5 x 5 contenant des nombres entiers aléatoires compris entre 1 et 15. Réinitialisez le générateur de nombres aléatoires à son état par défaut à des fins de reproductibilité.

rng("default")
A = randi(15,5)
A = 5×5

    13     2     3     3    10
    14     5    15     7     1
     2     9    15    14    13
    14    15     8    12    15
    10    15    13    15    11

Utilisez l’opérateur relationnel inférieur à < pour déterminer quels éléments de A sont inférieurs à 9. Stockez le résultat dans B.

B = A < 9
B = 5×5 logical array

   0   1   1   1   0
   0   1   0   1   1
   1   0   0   0   0
   0   0   1   0   0
   0   0   0   0   0

Le résultat est une matrice logique. Chaque valeur de B est un 1 logique (true) ou un 0 logique (false) qui indique si l’élément correspondant de A remplit la condition A < 9. Par exemple, A(1,1) est égal à 13 donc B(1,1) est un 0 logique (false). En revanche, A(1,2) est égal à 2 donc B(1,2) est un 1 logique (true).

B indique quels éléments de A sont inférieurs à 9. Toutefois, B n’indique pas la valeur de ces éléments. Au lieu de comparer les deux matrices élément par élément, vous pouvez utiliser B pour indexer A.

A(B)
ans = 8×1

     2
     2
     5
     3
     8
     3
     7
     1

Le résultat est un vecteur colonne des éléments de A inférieurs à 9. Comme B est une matrice logique, cette opération est appelée indexation logique. Dans cet exemple, le tableau logique utilisé comme index est de la même taille que le tableau qu’il indexe, mais ce n’est pas obligatoire. Pour plus d’informations, consultez Indexation des matrices.

Certains problèmes nécessitent de connaître la position des éléments du tableau remplissant une condition plutôt que leur valeur. Dans cette exemple, il est possible d’utiliser la fonction find pour localiser tous les éléments de A inférieurs à 9.

I = find(A < 9)
I = 8×1

     3
     6
     7
    11
    14
    16
    17
    22

Le résultat est un vecteur colonne d’indices linéaires. Chaque indice décrit la position d’un élément de A inférieur à 9. Dans la pratique, A(I) renvoie donc le même résultat que A(B). La différence est que A(B) utilise l’indexation logique alors que A(I) utilise l’indexation linéaire.

Appliquer plusieurs conditions

Vous pouvez utiliser les opérateurs logiques and, or et not pour appliquer autant de conditions que vous le souhaitez à un tableau. Le nombre de conditions n’est pas limité à une ou deux.

Tout d’abord, utilisez l’opérateur logique and noté & pour spécifier deux conditions : les éléments doivent être inférieurs à 9 et supérieurs à 2. Spécifiez ces conditions sous forme d’index logique pour afficher les éléments qui les remplissent toutes les deux.

A(A<9 & A>2)
ans = 5×1

     5
     3
     8
     3
     7

Le résultat est une liste des éléments de A qui remplissent les deux conditions. Veillez à spécifier chaque condition dans une instruction distincte reliée par un opérateur logique. Par exemple, vous ne pouvez pas spécifier les conditions ci-dessus avec A(2<A<9) car cela revient à évaluer A(2<A | A<9).

Ensuite, recherchez les éléments de A qui sont inférieurs à 9 et pairs.

A(A<9 & ~mod(A,2))
ans = 3×1

     2
     2
     8

Le résultat est une liste de tous les éléments pairs de A qui sont inférieurs à 9. L’opérateur logique not (~) convertit mod(A,2) en matrice logique avec une valeur 1 logique (true) aux emplacements où l’élément est divisible par 2 ou pair.

Pour finir, recherchez les éléments de A qui sont inférieurs à 9, pairs et différents de 2.

A(A<9 & ~mod(A,2) & A~=2)
ans = 
8

Le résultat, à savoir 8, est inférieur à 9, pair et différent de 2. C’est le seul élément de A qui remplit les trois conditions.

Utilisez la fonction find pour obtenir l’indice de l’élément égal à 8 qui remplit les conditions.

find(A<9 & ~mod(A,2) & A~=2)
ans = 
14

Le résultat indique que A(14) = 8.

Remplacer les valeurs qui remplissent une condition

Il est parfois utile de modifier simultanément la valeur de plusieurs éléments existants d’un tableau. Utilisez l’indexation logique avec une simple instruction d’affectation pour remplacer les valeurs d’un tableau qui remplissent une condition.

Par exemple, remplacez toutes les valeurs de A qui sont supérieures à 10 par le nombre 10.

A(A>10) = 10
A = 5×5

    10     2     3     3    10
    10     5    10     7     1
     2     9    10    10    10
    10    10     8    10    10
    10    10    10    10    10

Ensuite, remplacez toutes les valeurs de A qui ne sont pas égales à 10 par une valeur NaN.

A(A~=10) = NaN
A = 5×5

    10   NaN   NaN   NaN    10
    10   NaN    10   NaN   NaN
   NaN   NaN    10    10    10
    10    10   NaN    10    10
    10    10    10    10    10

Enfin, remplacez toutes les valeurs NaN de A par des zéros et appliquez l’opérateur logique not à A, ~A.

A(isnan(A)) = 0;
C = ~A
C = 5×5 logical array

   0   1   1   1   0
   0   1   0   1   1
   1   1   0   0   0
   0   0   1   0   0
   0   0   0   0   0

La matrice ainsi obtenue contient des 1 logiques (true) au lieu des valeurs NaN et des 0 logiques (false) au lieu des 10. L’opération logique not (~A) convertit le tableau numérique A en tableau logique C de sorte que A&C renvoie une matrice de valeurs 0 logiques (false) et que A|C renvoie une matrice de valeurs 1 logiques (true).

Voir aussi

| | | | | | | |