Numpy R

r_[start:end:step]
r_[x1, x2, x3, … ]
r_['r', x1, x2, x3, … ]
r_['c', x1, x2, x3, … ]

Este comando oferece uma sintaxe conveniente e simples para a criação de arranjos, baseado na sintaxe de slices do Python e também na concatenação de diversos arranjos. Existem diversos usos diferentes para esse comando. Os argumentos especificados no cabeçalho são descritos abaixo:

start
Este argumento indica o início do intervalo.
end
Indica o final do intervalo. O último valor não é incluído no arranjo resultante, exceto se um arranjo linear for criado (ver abaixo).
step
Intervalo entre os elementos do arranjo. Se step for um valor complexo, um arranjo linear é criado, e este argumento é interpretado como o número de pontos entre start e end (incluindo os extremos).
x1, x2, x3, …
Diversos arranjos que serão concatenados para formar o novo arranjo.
'r'
Se a string 'r' for incluída como o primeiro argumento, então é criada uma matriz de $N \times 1$ elementos, ou seja, uma matriz-linha.
'c'
Se a string 'c' for incluída como o primeiro argumento, então é criada uma matriz de $1 \times N$ elementos, ou seja, uma matriz-coluna.

É importante lembrar que, para que a concatenação de arranjos seja feita de forma adequada, é necessário que as dimensões sejam coerentes. Uma vez que as concatenações são feitas ao longo do eixo principal (ie.: como colunas), todos os arranjos precisam ter o mesmo número de linhas.

O tipo numérico dos elementos dos arranjos ou matrizes criados vai depender do tipo usado como base. Como padrão, será o mais simples tipo capaz de representar os dados resultantes.

Veja também:

array() , arange() , linspace() , c_

Exemplos:

Nestes exemplos, consideraremos que o módulo numpy foi carregado com a linha de comando from numpy import *. Se você fizer a importação de maneira diferente, não se esqueça de especificar o espaço de nomes sendo utilizado. Estes exemplos podem ser testados diretamente na linha de comando.

O método mais simples de utilizar o comando r_ é como uma especificação de um intervalo. Se desejamos um arranjo contendo o intervalo entre -5 e 5, excluindo o último, com espaçamento entre os elementos de 0.5, fazemos:

>>> r_[-5:5:0.5]
array([-5. , -4.5, -4. , -3.5, -3. , -2.5, -2. , -1.5, -1. , -0.5,  0. ,
        0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])

O efeito é o mesmo que usar a função arange(). Para a criação de um arranjo linear, incluindo as extremidades (o equivalente à função linspace()), usamos

>>> r_[-5:5:11j]
array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.,  5.])

Note que o argumento step foi especificado como um número complexo (seguido de j), por isso a diferença no resultado. (Usar um número complexo para representar o número de pontos não é exatamente intuitivo, mas existe pouca escolha neste caso, e esta foi a convenção adotada pelos criadores do NumPy).

Para concatenarmos arranjos, usamos a sintaxe abaixo:

>>> r_[ 1, 2, 3, array((4, 5, 6)) ]
array([1, 2, 3, 4, 5, 6])

Note que não é necessário que apenas arranjos sejam usados. Na verdade, quaisquer seqüências de elementos, explícitas ou não, podem ser usados. O comando se encarrega de interpretar os resultados. Abaixo vemos o que acontece se desejamos concatenar seqüências com dimensões incompatíveis. Omitimos a mensagem de erro completa, uma vez que o objetivo é apenas demonstrar o efeito:

>>> a = array( [ [ 4, 5 ], [ 6, 7 ] ] )
>>> a
array([[4, 5],
       [6, 7]])
>>> r_[ 1, 2, 3, a ]
 
Traceback (most recent call last):
(...)
ValueError: arrays must have same number of dimensions

Slices também podem ser utilizados para a criação de arranjos concatenados. Muitas seqüências interessantes podem ser criadas usando essa técnica, em poucas linhas de programa. Pode-se, é claro, misturar slices e arranjos simultaneamente na concatenação:

>>> r_[ 1:5:0.5, 1:5:5j ]
array([ 1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  1. ,  2. ,  3. ,
        4. ,  5. ])

Vemos abaixo como criar matrizes-linha e matrizes-coluna, adicionando os respectivos modificadores na criação dos slices. Note como o tipo numérico dos elementos foi feito adequado aos dados que foram passado aos comandos:

>>> r_['r', 1., 2., 3.]
matrix([[ 1.,  2.,  3.]])
>>> r_['c', 1., 2., 3.]
matrix([[ 1.],
        [ 2.],
        [ 3.]])
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License