Scilab Function

insertion - insertion/modification dans une matrice ou une liste

### Sequence d'appel

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

### Parametres

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

### Description

- CAS DES MATRICES `i` et `j` peuvent être :
- - des scalaires, vecteurs ou matrices à éléments positifs.
- * Si `a` est une matrice de dimensions `(size(i,'*'),size(j,'*'))` `x(i,j)=a` renvoie une nouvelle matrice `x` telle que `x(int(i(l)),int(j(k)))=a(l,k)` pour `l` variant de 1 à `size(i,'*')` et `k` variant de 1 à `size(j,'*')`, les autres composantes initiales de `x` sont inchangées.

Si `a` est un scalaire `x(i,j)=a` renvoie une nouvelle matrice `x` telle que `x(int(i(l)),int(j(k)))=a` pour `l` variant de 1 à `size(i,'*')` et `k` variant de 1 à `size(j,'*')`, les autres composantes initiales de `x` sont inchangées.

Si la valeur maximum de `i` ou `j` dépasse la dimension correspondante de `x`, alors `x` est au préalable agrandie aux dimensions adéquates en stockant des zéros pour les matrices standard, des chaînes vides pour les matrices de chaînes de caractères ou la valeur %F pour les matrices booléennes.

- * `x(i,j)=[]` détruit les lignes spécifiées par `i` si `j` désigne toutes les colonnes de `x` ou détruit les colonnes spécifiées par `j` si `i` désigne toutes les lignes de `x`. Dans tous les autres cas `x(i,j)=[]` produit une erreur.
- * `x(i)=a` où `a` est un vecteur renvoie une nouvelle matrice `x` telle que `x(int(i(l)))=a(l)` pour `l` variant de 1 à `size(i,'*')` , les autres composantes initiales de `x` sont inchangées.

`x(i)=a` où `a` est un scalaire, renvoie une nouvelle matrice `x` telle que `x(int(i(l)))=a` pour `l` variant de 1 à `size(i,'*')` , les autres composantes initiales de `x` sont inchangées.

Si la valeur maximum de `i` dépasse `size(x,1)`, `x` est au préalable agrandie aux dimensions adéquates en stockant des zéros pour les matrices standard, des chaînes vides pour les matrices de chaînes de caractères ou la valeur %F pour les matrices booléennes.

- Si `x` est une matrice 1 x 1 `a` peut être un vecteur ligne (resp. colonne) de dimension `size(i,'*')`. La matrice `x` obtenue est un vecteur ligne (resp. colonne)
- Si `x` est un vecteur ligne (resp. colonne) `a` doit être un vecteur ligne (resp. colonne) de dimension `size(i,'*')`
- Si `x` est une matrice en général `a` doit être un vecteur ligne ou colonne de dimension `size(i,'*')` et la valeur maximum de`i` ne peut dépasser `size(x,'*')`,
- * `x(i)=[]` supprime les termes spécifiés par `i`.

- Le symbole `:` signifiant "tous les éléments".

- * `x(i,:)=a` est interprété comme `x(i,1:size(x,2))=a`
- * `x(:,j)=a` est interprété comme `x(1:size(x,1),j)=a`
- * `x(:)=a` renvoie dans `x` la matrice `a` remise en forme en accord avec les dimensions de x. `size(x,'*')` doit être égal à`size(a,'*')`

- - vecteur de booléens. Si un indice (`i` ou `j` ) est un vecteur de booléens, 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 insertion récursive directe sans utiliser de variable intermédiaire. Les instructions `l(k1)...(kn)(i)=a` et `l(list(k1,...,kn,i)=a)` sont interprétées comme : `lk1 = l(k1)` `.. = ..` `lkn = lkn-1(kn)` `lkn(i) = a` `lkn-1(kn) = lkn` `.. = ..` `l(k1) = lk1` et les instructions`l(k1)...(kn)(i,j)=a` et `l(list(k1,...,kn,list(i,j))=a` sont interprétées comme : `lk1 = l(k1)` `.. = ..` `lkn = lkn-1(kn)` `lkn(i,j) = a` `lkn-1(kn) = lkn` `.. = ..` `l(k1) = lk1`
- i peut être :
- - un scalaire réel positif `l(0)=a` ajoute un terme "à gauche" de la liste `l(i)=a` affecte `a` au terme `i` de la liste `l`. Si `i>size(l)`, `l` est préalablement agrandie et les termes créés sont de type non-défini. `l(i)=null()` supprime le terme `i`th de la liste.
- - 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é.

\un nombre réel positif

- - 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.

### 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'insertion des éléments d'un vecteur, à cause de la confusion possible avec l'insertion des éléments de liste. La syntaxe `x(1,j)` où `x(i,1)` doit être utilisée dans ce cas.

### Exemples

    // CAS DES MATRICES
    a=[1 2 3;4 5 6]
    a(1,2)=10
    a([1 1],2)=[-1;-2]
    a(:,1)=[8;5]
    a(1,3:-1:1)=[77 44 99]
    a(1)=%s
    a(6)=%s+1
    a(:)=1:6
    a([%t %f],1)=33
    a(1:2,$-1)=[2;4]
    a($:-1:1,1)=[8;7]
    a($)=123
    //
    x='test'
    x([4 5])=['4','5']
    //
    b=[1/%s,(%s+1)/(%s-1)]
    b(1,1)=0
    b(1,$)=b(1,$)+1
    b(2)=[1 2] // le numérateur
    // CAS des LISTES (types LIST et TLIST)
    l=list(1,'qwerw',%s)
    l(1)='Changed'
    l(0)='Added'
    l(6)=['one more';'added']
    //
    //
    dts=list(1,tlist(['x';'a';'b'],10,[2 3]));
    dts(2)('a')=33
    dts(2)('b')(1,2)=-100

### Voir aussi

`find` `horner` `parents` `extraction`