insertion insertion/modification dans une variable
affectation affectation partielle d'une variable

## Séquence 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

## Paramètres

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 matrices

    Dans ce cas, les valeurs données en indices doivent être strictement positives. Seules les parties entières sont prises en 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.

  Polynomes

    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

  - 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 (seule sa partie entière est prise en compte). `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.

## 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
    a(1,%pi)=1 //équivalent à a(1,3)=1
    //
    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(%pi)=1 //équivalent à l(3)=1
    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
- parentheses
- extraction