# insertion

atribuição ou modificação parcial de variáveis

# assignation

atribuição parcial de variáveis

## Seqüência de Chamamento

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

## Parâmetros

x

  matriz de qualquer tipo

l

  lista

i,j

  índices

k1,...kn

  índices com valores inteiros

a

  novo valor de entrada

## Descrição

CASO DE MATRIZES

  Se `x` é uma matriz, os índices `i` e `j`, podem ser:

  Escalares reais, vetores ou matrizes

    neste caso, os valores fornecidos como índices devem ser inteiros e apenas suas partes inteiras são levadas em consideração.

    - Se `a` é uma matriz com dimensões `(size(i,'*'),size(j,'*'))`, `x(i,j)=a` retorna uma nova matriz `x` tal que `x(int(i(l)),int(j(k)))=a(l,k)` para `l` de 1 a `size(i,'*')` e `k` de 1 a `size(j,'*')`, as outras entradas iniciais de `x` não são modificadas.

    - Se `a` é um escalar, `x(i,j)=a` retorna uma nova matriz `x` tal que `x(int(i(l)),int(j(k)))=a` para `l` de 1 a `size(i,'*')` e `k` de 1 a `size(j,'*')`, as outras entradas iniciais de `x` não são modificadas.

    - Se o valor máximo de `i` ou `j` exceder a dimensão correspondente da matriz `x` , o array `x` é previamente estendido para as dimensões requeridas com entradas 0 para matrizes padrões, strings de comprimento 0 para matrizes de strings e valores falsos para matrizes de booleanos.

    - `x(i,j)=[]` cancela linhas especificadas por `i` se `j` corresponde a todas as colunas de `x` ou cancela colunas especificadas por `j` se `i` corresponde a todas as linhas de `x`. Em outros casos `x(i,j)=[]` produz um erro.

    - `x(i)=a` com `a` um vetor retorna a nova matriz `x` tal que `x(int(i(l)))=a(l)` para `l` de 1 a `size(i,'*')` , outras entradas iniciais de `x` não são modificadas.

    - `x(i)=a` com `a` um escalar retorna uma nova matriz `x` tal que `x(int(i(l)))=a` para `l` de 1 a `size(i,'*')` , outras entradas iniciais de `x` não são modificadas.

      Se o valor máximo de `i` exceder `size(x,1)`, `x` é previamente estendida para a dimensão requerida com entradas 0 para matrizes padrões, strings de comprimento 0 para matrizes de strings e valores falsos para matrizes de booleanos.

      Se

        `x` é uma matriz 1x1

        `a` pode ser um vetor linha (respectivamente coluna) com dimensão `size(i,'*')`. A matriz `x` resultante é um vetor linha (respectivamente coluna).

      Se

        `x` é um vetor linha

        `a` deve ser um vetor linha de dimensão `size(i,'*')`

      Se

        `x` é um vetor coluna

        `a` deve ser um vetor coluna de dimensão `size(i,'*')`

      Se

        `x` é uma matriz geral

        `a` deve ser um vetor linha ou coluna de dimensão `size(i,'*')` e o valor máximo de `i` não pode exceder `size(x,'*')`,

    - `x(i)=[]` cancela entradas especificadas por `i`.

  O símbolo :

    O símbolo `':'` significa "todos os elementos".

    - `x(i,:)=a` é interpretado como `x(i,1:size(x,2))=a`

    - `x(:,j)=a` é interpretado como `x(1:size(x,1),j)=a`

    - `x(:)=a` retorna em `x` a matriz `a` de forma redefinida de acordo com as dimensões de x. `size(x,'*')` deve ser igual a `size(a,'*')`

  Vetores de booleanos

    se um índice (`i` ou `j` ) é um vetor de booleanos, é interpretado como `find(i)` ou, respectivamente, `find(j)`

  Polinômios

    se um índice (`i` ou `j` ) é um vetor de polinômios ou um vetor de polinômios implícito, é interpretado como `horner(i,m)` ou respectivamente `horner(j,n)` onde `m` e `n` são as dimensões associadas de `x`. Mesmo se esse recurso funcionar para todos os polinômios, é recomendado utilizar polinômios em `$` para legibilidade.

CASO DE LISTAS OU TLISTS

  - Se estiverem presentes, os `ki` fornecem o endereço para uma entrada de sub-lista da estrutura de dados `l` data structure. Eles permitem uma extração recursiva sem cópias intermediárias. As instruções `l(k1)...(kn)(i)=a` e `l(list(k1,...,kn,i)=a)` são interpretadas como:

    `lk1 = l(k1)` `.. = ..`

    `lkn = lkn-1(kn)` `lkn(i) = a`

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

    E as instruções `l(k1)...(kn)(i,j)=a` e `l(list(k1,...,kn,list(i,j))=a` são interpretadas como:

    `lk1 = l(k1)` `.. = ..`

    `lkn = lkn-1(kn)` `lkn(i,j) = a`

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

  - `i` pode ser :

    - Um escalar real não-negativo. `l(0)=a` adiciona uma entrada à "esquerda" da lista, `l(i)=a` configura a entrada `i` da lista `l` como `a`. Se `i>size(l)`, `l` é previamente estendido com entradas de comprimento 0 (indefinidas). `l(i)=null()` suprime a `i`-ésima entrada da lista.

    - Um polinômio. Se `i` é um polinômio, é interpretado como `horner(i,m)` onde `m=size(l)`. Mesmo se este recurso funcionar para todos os polinômios, é recomendado utilizar polinômios em `$` para legibilidade.

  - `k1,..kn` podem ser :

    - Escalares reais positivos.

    - Polinômios, interpretados como `horner(ki,m)` onde `m` é o tamanho da sub-lista correspondente.

    - Strings associados a nomes de entradas de uma sub-lista.

## Observações

Para tipos de matrizes "soft-coded" como funções racionais e sistemas lineares de espaços de estados, a sintaxe `x(i)` não pode ser usada para inserção de entradas em vetores devido a confusões com inserção de entradas em listas. A sintaxe `x(1,j)` ou `x(i,1)` deve ser usada.

## Exemplos

    // CASO DE MATRIZES
    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='teste'
    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] // o numerador
    // CASO DE LISTAS OU TLISTS
    l=list(1,'qwerw',%s)
    l(1)='Modificado'
    l(0)='Adicionado'
    l(6)=['mais um';'adicionado']
    //
    //
    dts=list(1,tlist(['x';'a';'b'],10,[2 3]));
    dts(2).a=33
    dts(2)('b')(1,2)=-100

## Ver Também

- find
- horner
- parents
- extraction