extraction

Scilab Function
Last update : 17/06/2004

extraction - extraction à partir d'une matrice ou d'une liste

### Calling Sequence

  `x(i,j)`
  `x(i)`
  `[...]=l(i)`
  `[...]=l(k1)...(kn)(i) ou [...]=l(list(k1,...,kn,i))`
  `l(k1)...(kn)(i,j) ou l(list(k1,...,kn,list(i,j))`

### Parameters

- `x` : matrice de tout type
- `l` : liste
- `i,j` : indices
- `k1,...kn` : indices à valeurs entières

### Description

  CAS DES MATRICES `i` et `j` peuvent être :
    des scalaires,vecteurs ou matrices à éléments positifs.
      `r=x(i,j)` construit la matrice `r` telle que:

      `r(l,k)=x(int(i(l)),int(j(k)))`

      pour `l` variant de 1 à `size(i,'*')`

      et `k` variant de 1 à `size(j,'*')` .

      La valeur maximale de `i` (resp. `j` ) doit être inférieure ou égale à `size(x,1)` (resp. `size(x,2)` ).

      `r=x(i)` où `x` est une matrice 1 x 1, construit la matrice `r` telle que `r(l,k)=x(int(i(l)),int(i(k)))` pour `l` variant de 1 à `size(i,1)` et `k` variant de 1 à `size(i,2)` . Noter que dans ce cas l'indice `i` est valable si toutes ses composantes sont égales à 1.
      `r=x(i)` avec `x` un vecteur ligne, construit le vecteur ligne `r` tel que `r(l)=x(int(i(l)))` pour `l` entre 1 et `size(i,'*')` La valeur maximale de `i` doit être inférieure ou égale à `size(x,'*')` .
      `r=x(i)` avec `x` une matrice à une ou plusieurs colonnes, construit la matrice `r` telle que `r(l)` (`l` variant de 1 à `size(i,'*')` ) contient le terme numéro `int(i(l))` du vecteur colonne issu de la concaténation des colonnes de `x` . La valeur maximale de `i` doit être inférieure ou égale à `size(x,'*')` .
    Le symbole `:` signifiant "tous les éléments".
      `r=x(i,:)` construit la matrice `r` telle que `r(l,k)=x(int(i(l)),k))` pour `l` variant de 1 à `size(i,'*')` et `k` variant de 1 à `size(x,2)`
      `r=x(:,j)` construit la matrice `r` telle que `r(l,k)=x(l,int(j(k)))` pour `l` variant de 1 à `size(r,1)` et `k` variant de 1 à `size(j,'*')` .
      `r=x(:)` construit le vecteur colonne `r` obtenu par concaténation des colonnes de `x` . Cette commande est équivalente à `r=matrix(x,size(x,'*'),1)` .
    vecteur de booléens Si un indice (`i` ou `j` ) est un vecteur de booléen il est interprété comme `find(i)` ou `find(j)` , respectivement.
    un polynôme Si un indice (`i` ou `j` ) est un vecteur de polynômes ou de polynômes implicites il est interprété comme `horner(i,m)` ou `horner(j,n)` , respectivement, où `m` et `n` sont les dimensions de `x` associées. Même si cette fonctionnalité marche pour tous les polynômes, il est recommandé d'utiliser des polynômes dans `$` par souci de lisibilité.
  CAS DES LISTES

  (types LIST et TLIST) S'ils sont présents, les `ki` donnent le chemin vers un terme d'une sous-liste de la liste `l` . Ils permettent de faire une extraction récursive directe sans utiliser de variable intermédiaire. Les instructions:

  `[...]=l(k1)...(kn)(i)`

  et

  `[...]=l(list(k1,...,kn,i))`

  sont interprétées comme :

  `lk1 = l(k1)` , `.. = ..` , `lkn = lkn-1(kn)` , `[...] = lkn(i)`

  De même, les instructions

  `l(k1)...(kn)(i,j)`

  et

  `l(list(k1,...,kn,list(i,j))`

  sont interprétées comme :

  `lk1 = l(k1)` , `.. = ..` , `lkn = lkn-1(kn)` , `lkn(i,j)`

  `i` et `j` , peuvent valoir :

    scalaire vecteur ou matrice à termes positifs `[r1,...rn]=l(i)` extrait les termes `i(k)` de la liste l et les stocke dans les variables `rk` pour `k` variant de 1 à `size(i,'*')`
    le symbole : ("tous les éléments")
    vecteur de booléens Si `i` est un vecteur de booléens, il est interprété comme `find(i)` .
    un polynôme Si `i` est un vecteur de polynômes ou de polynômes implicites il est interprété comme `horner(i,m)` où `m=size(l)` . Même si cette fonctionnalité marche pour tous les polynômes, il est recommandé d'utiliser des polynômes dans `$` par souci de lisibilité.
  k1,..kn peuvent être :
    un nombre réel positif
    un polynôme un polynôme, interprété comme `horner(ki,m)` ou `m` est la taille de la sous-liste correspondante.
    une chaîne de caractères associée à un nom d'entrée de sous-liste'

  Quand le chemin désigne plusieurs termes d'une liste l'instruction doit avoir autant de termes dans la liste des arguments du membre de gauche que le nombre de termes sélectionnés. Mais si la syntaxe d'extraction est utilisée dans les arguments d'entrée d'une fonction, chaque terme renvoyé est ajouté aux arguments d'entrée.

  Notez que `l(list())` est identique à `l` .

### REMARQUES

Pour les matrices rationnelles et les systèmes dynamiques linéaires stockés sous forme de représentation d'état, la syntaxe `x(i)` ne doit pas être utilisée pour l'extraction des éléments d'un vecteur, à cause de la confusion possible avec l'extraction des éléments de liste. La syntaxe `x(1,j)` où `x(i,1)` doit être utilisée dans ce cas.

### Examples

        // CAS DES MATRICES
        a=[1 2 3;4 5 6]
        a(1,2)
        a([1 1],2)
        a(:,1)
        a(:,3:-1:1)
        a(1)
        a(6)
        a(:)
        a([%t %f %f %t])
        a([%t %f],[2 3])
        a(1:2,$-1)
        a($:-1:1,2)
        a($)
        //
        x='test'
        x([1 1;1 1;1 1])
        //
        b=[1/%s,(%s+1)/(%s-1)]
        b(1,1)
        b(1,$)
        b(2) // le numérateur
        // CAS des LISTES (types LIST et TLIST)
        l=list(1,'qwerw',%s)
        l(1)
        [a,b]=l([3 2])
        l($)
        x=tlist(l(2:3)) // construction d'une TLIST avec les deux derniers termes de l
        //
        dts=list(1,tlist(['x';'a';'b'],10,[2 3]));
        dts(2)('a')
        dts(2)('b')(1,2)
        [a,b]=dts(2)(['a','b'])

### See Also

`find` , `horner` , `parents` ,