extraction extração de entradas de matrizes e listas

## Seqüência de Chamamento

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

## Parâmetros

x

  matriz de qualquer tipo possível

l

  variável do tipo lista

i,j, k

  índices

k1,...kn

  índices

## Descrição

CASO DE MATRIZES

  `i`, `j`, `k`,.. podem ser:

  escalares reais ou vetores ou matrizes com elementos positivos.

    - `r=x(i,j)` constrói a matriz `r` tal que `r(l,k)=x(int(i(l)),int(j(k)))` para `l` de 1 a `size(i,'*')` e `k` de 1 a `size(j,'*')`. O valor máximo de`i` (`j`) deve ser menor do que ou igual a `size(x,1)` (`size(x,2)`).

    - `r=x(i)` com `x` uma matriz 1x1 contrói a matriz `r` tal que `r(l,k)=x(int(i(l)),int(i(k)))` para `l` de 1 a `size(i,1)` e `k` para 1 a `size(i,2)`.

      Note que, nesse caso, o índice `i` é válido apenas se todas as suas entradas são iguais a 1.

    - `r=x(i)` com `x` um vetor linha constrói o vetor linha `r` tal que `r(l)=x(int(i(l)))` para `l` de 1 a `size(i,'*')``i` deve ter valor máximo menor do que ou igual a `size(x,'*')`.

    - `r=x(i)` com `x` uma matriz com uma ou mais colunas constrói o vetor coluna `r` tal que `r(l)` (`l` de 1 a `size(i,'*')`) contém a entrada `int(i(l))` do vetor coluna formado pela concatenação das colunas de `x`.

      `i` deve ter valor máximo menor do que ou igual a `size(x,'*')`.

  O símbolo `':'`

    `` significa "todos os elementos".

    - `r=x(i,:)` constrói uma matriz `r` tal que `r(l,k)=x(int(i(l)),k))` para `l` de 1 a `size(i,'*')` and `k` from 1 to `size(x,2)`

    - `r=x(:,j)` constrói a matriz `r` tal que `r(l,k)=x(l,int(j(k)))` para `l` de 1 a `size(r,1)` e `k` de 1 a `size(j,'*')`.

    - `r=x(:)` constrói o vetor coluna `r` formado pelas concatenações das colunas de`x`. É equivalente a `matrix(x,size(x,'*'),1)`.

  vetor de booleanos

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

  um polinômio

    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 a `x`. Mesmo se este recurso funcionar para todos os polinômios, é recomendado utilizar polinômios em `$` para legibilidade.

  Para matrizes com mais de duas dimensoes (ver:hypermatrices), a dimensionalidade é automaticamente reduzida quando as dimensões mais a direita são 1.

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` Eles permitem uma extração recursiva sem cópias intermediárias. As instruções

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

  e

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

  são interpretadas como:

  `lk1 = l(k1)``.. = ..` `lkn = lkn-1(kn)``[...] = lkn(i)` e as instruções `l(k1)...(kn)(i,j)` e

  `l(list(k1,...,kn,list(i,j))` são interpretadas como: `lk1 = l(k1)` `.. = ..` `lkn = lkn-1(kn)` `lkn(i,j)` `i` e `j`, podendo ser: quando pontos de endereço sobre mais de um componente da lista, a instrução deve ter tantos argumentos do lado esquerdo quanto os componentes selecionados. Mas se a sintaxe de extração é usada dentro da seqüência de chamamento de entrada de uma função, cada componente da lista retornado é adicionado à seqüência de chamamento da função.

  Note que, `l(list())` é o mesmo que `l`.

  i e j podem ser :
    escalares reais ou vetores ou matrizes de elementos positivos

      `[r1,...rn]=l(i)` extrai os elementos `i(k)` da lista l e armazena-os em variáveis `rk` para `k` de 1 a `size(i,'*')`

    O símbolo `:`

      significa "todos os elementos".

    um vetor de booleanos

      Se `i` é um vetor de booleanos, é interpretado como `find(i)`.

    um polinômio

      Se `i` é um vetor de polinômios ou um vetor de polinômios implícito, é interpretado como `horner(i,m)` onde `m=size(l)`. Mesmo que este recurso funcione para todos os polinômios, é recomendado utilizar polinômios em `$` para legibilidade.

  k1,..kn podem ser :
    escalares reais posistivos

    um polinômio

      interpretado como `horner(ki,m)` onde `m` é o tamanho da sub-lista correspondente.

    string

      associado ao nome da entrada da 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 extração de elementos de vetores devido a confusões com extração de elementos de 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)
    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='teste'
    x([1 1;1 1;1 1])
    //
    b=[1/%s,(%s+1)/(%s-1)]
    b(1,1)
    b(1,$)
    b(2) // o numerador
    // CASO DE LISTAS OU TLISTS
    l=list(1,'qwerw',%s)
    l(1)
    [a,b]=l([3 2])
    l($)
    x=tlist(l(2:3)) //forma um tlist com os últimos dois componentes 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'])

## Ver Também

- find
- horner
- parentheses