Découvrir Scilab/Structures de données avancées

9. Structures de données avancées

Listes

Affichage d'une liste sous la forme d'un arbre.

Une liste est un ensemble ordonné d'objets Scilab (nombre, chaîne de caractère, vecteur, matrice, liste, …). Les opérations standard sur les listes sont :

L = list(a₁, a₂, …, a_n) : crée la liste avec les objets a_i et la met dans le vecteur L ;
L(0) = a : insère a en début de liste (L(1) = a) et décale les autres éléments
L(i) = a : remplace l'élément i par a ;
L($+1) = a : place a en queue de liste ;
L(i) = null : supprime l'élément i ;
size(L) ou length(L) : taille de la liste ;
L3 = lstcat(L1, L2) : concaténation des listes.

On peut décrire un arbre par des listes imbriquées. La commande tree_show permet d'afficher la liste sous forme arborescente, par exemple :

a = list(list(1, 2, 3), list(4,5,6),list(7,8,9));
tree_show(a);

Structures

Les structures sont des objets similaires aux vecteurs, mais dont les champs ont un nom de type structure.champ. Elles sont créées par la commande struct("champ1", valeur1, "champ2", valeur2, …) :

-->aujourdhui = struct("jour", 23, "mois", "octobre", "annee", 2012)
 aujourdhui  =
 
  jour: [1x1 constant]
  mois: [1x1 string]
  annee: [1x1 constant]

-->disp(aujourdhui.mois)
 
 octobre 

-->aujourdhui("jour")
 ans  =
 
    23.  

-->aujourdhui.mois = "novembre"
 aujourdhui  =
 
  jour: [1x1 constant]
  mois: [1x1 string]
  annee: [1x1 constant]

On peut ajouter un champ à la volée :

-->aujourdhui.semaine = 47
 aujourdhui  =
 
  jour: [1x1 constant]
  mois: [1x1 string]
  annee: [1x1 constant]
  semaine: [1x1 constant]

de fait, on peut créer une structure directement en assignant la valeur d'un champ :

-->demain.jour = 24
 demain  =
 
  jour: [1x1 constant]
 
-->type(demain)
 ans  =
 
    17. 
 
-->typeof(demain)
 ans  =
 
 st 

--> today("day") = 23
today  = 

  day: [1x1 constant]

--> today("month") = "october"
today  = 

  day: [1x1 constant]
  month: [1x1 string]

--> today("year") = 2012
today  = 

  day: [1x1 constant]
  month: [1x1 string]
  year: [1x1 constant]

Notons que selon son contenu, la commande type() sur une structure retourne 16 (tlist) ou 17 (mlist).

La commande fieldnames() permet d'extraire le nom des champs :

--> fieldnames(aujourdhui)
 ans  =

!jour     !
!         !
!mois     !
!         !
!annee    !
!         !
!semaine  !

On peut aussi créer une structure avec une liste typée :

hier = tlist(["nom", "jour", "mois", "annee"], 22, "octobre", 2012)

Dans le cas d'une liste typée, les appels suivants sont équivalents : hier(2), aujourdhui("jour"),hier.jour. La syntaxe générale de tlist est :

tlist(type, a1, a2, …)

où

type est un vecteur de chaînes de caractères dont
- le premier élément est le nom que l'on donne au type ; c'est ce qui est retourné par la fonction typeof,
- les éléments suivants sont les noms des champs ;
a1, a2, … sont les valeurs des champs.

Si l'objet se comporte de la même manière qu'une structure, en revanche, la commande typeof() ne retourne donc pas st.

Enfin, on peut créer une matrice de structures :

-->foo(1, 1).nombre = %e
 foo  =
 
   nombre: list
 
-->foo(2, 2).texte = "e"
 foo  =
 
2x2 struct array with fields:
   nombre
   texte
 
-->foo(1, 1).nombre
 ans  =
 
    2.7182818  
 
-->foo(1, 1).texte
 ans  =
 
     []

-->type(foo)
 ans  =
 
    17.  
 
-->typeof(foo)
 ans  =
 
 st

Tableaux de cellules

On peut voir un tableau de cellules (cell array) comme une « hypermatrice » pouvant contenir des objets hétéroclites ; par hypermatrice, nous entendons un tenseur à n indices. Un tableau de cellules est créée par la commande cell. Par exemple

-->cell(4,3)
 ans  =
 
 
!{}  {}  {}  !
!            !
!{}  {}  {}  !
!            !
!{}  {}  {}  !
!            !
!{}  {}  {}  !

crée une matrice (tenseur à deux indices) 4×3. Cette matrice s'affiche encadrée de points d'exclamation. Les éléments vides sont représentés par des paires d'accolades {}.

Notons que cell(4) crée un matrice 4×4 ; pour créer une liste (tenseur à un indice, vecteur ligne ou colonne), il faut utiliser cell(4,1) ou cell(1,4). La commande

cell(4, 3, 2)

crée un tenseur à trois indices 4×3×2, représenté comme deux couches de matrices 4×3 :

-->cell(4,3,2)
 ans  =


(:,:,1)

!{}  {}  {}  !
!            !
!{}  {}  {}  !
!            !
!{}  {}  {}  !
!            !
!{}  {}  {}  !
(:,:,2)
 
!{}  {}  {}  !
!            !
!{}  {}  {}  !
!            !
!{}  {}  {}  !
!            !
!{}  {}  {}  !

Les dimensions peuvent être indiquées par un vecteur de nombre. Par exemple

V = [4, 3, 2];
A = cell(V);

Pour accéder à un terme, c'est-à-dire lui assigner une valeur ou bien afficher cette valeur, il faut utiliser le pointeur .entries. Par exemple,

A(1, 1, 1).entries = 'vecteur';
A(1, 1, 2).entries = 1:5;

met la chaîne de caractères « vecteur » dans le terme A(1, 1, 1), et le vecteur [1, 2, 3, 4, 5] dans le terme terme A(1, 1, 2), ce qui donne

 A  =


(:,:,1)

!"vecteur"  {}  {}  !
!                   !
!{}         {}  {}  !
!                   !
!{}         {}  {}  !
!                   !
!{}         {}  {}  !
(:,:,2)

![1,2,3,4,5]  {}  {}  !
!                     !
!{}           {}  {}  !
!                     !
!{}           {}  {}  !
!                     !
!{}           {}  {}  !

Le pointeur .dims donne les dimensions du tableau de cellules.

-->A.dims
 ans  =

  4  3  2

Environnement < ↑ > Gestion des fichiers