insertionaffectation

Scilab Function
Last update : 17/06/2004

insertion - insertion/modification dans une variable

affectation - affectation partielle d'une variable

### Calling Sequence

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

### Parameters

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

  Si `x` est un tableau `i` et `j` peuvent être :
    Des scalaires, vecteurs ou matricesDans ce cas les parties entieres des valeurs données en indices doivent être strictement positives. Seule la prtie entière est prise e, compte.
      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 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,'*')`
    Vecteurs 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.
    PolynomesSi 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
    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` `.. = ..`

    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é.
    `k1,..kn` peuvent être :
      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.

### Remarque

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.

### Examples

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

### See Also

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