Algunos generadores de matrices en Octave y Python

Existen algunas matrices básicas que resultan útiles al momento de comenzar a trabajar, ya sea por que permiten inicializar variables matriz o por que será útil en cálculos posteriores.

     Es posible recurrir a funciones en lenguaje M que nos permiten crear esas matrices y que están disponibles en Octave.

    Algunas de estás funciones son:

Función	Resultado
zeros	Una matriz de ceros
ones	Una matriz de unos
rand	Una matriz con elementos aleatorios de distribuición uniforme
randn	Una matriz con elementos aleatorios de distribución normal
eye	Una matriz identidad

    Para crear un vector renglón de ceros:

>> x = zeros(1,3)
x =

   0   0   0

y un vector columna de ceros:

>> y = zeros(3,1)
y =

   0
   0
   0

    Una matriz de ceros de 3x3:

>> M = zeros(3)
M =

   0   0   0
   0   0   0
   0   0   0

y una matriz rectangular de 3x2:

>> N = zeros(3,2)
N =

   0   0
   0   0
   0   0

    La misma forma de invocacion se puede emplear para la función ones. Así por ejemplo, para crear una matriz llena de 0.5 de dimensión 4x3, se puede usar la función ones y dividir entre 2:

>> M1 = ones(4,3)/2
M1 =

   0.50000   0.50000   0.50000
   0.50000   0.50000   0.50000
   0.50000   0.50000   0.50000
   0.50000   0.50000   0.50000

    O crear una matriz rectangular de 3x4 llena de unos:

>> M2 = ones(3,4)
M2 =

   1   1   1   1
   1   1   1   1
   1   1   1   1

    Y la forma de invocar es extensible al resto de las funciones.

    Por ejemplo, para crear un vector de elementos pseudoaleatorios:

>> u = rand(1,6)
u =

   0.82166   0.74930   0.79187   0.73530   0.73373   0.84726

    Una matriz de 2x2:

>> Mr = rand(2,2)
Mr =

   0.16396   0.75682
   0.77751   0.28670

    O crear una matriz identidad de 4x4:

>> I=eye(4)
I =

Diagonal Matrix

   1   0   0   0
   0   1   0   0
   0   0   1   0
   0   0   0   1

    En el caso particular de la función eye, si lo que se solicita es una matriz rectangular, coloca unos en la posición a(i,i), por ejemplo:

>> J=eye(2,4)
J =

Diagonal Matrix

   1   0   0   0
   0   1   0   0

    Existen funciones equivalente en Python con Numpy, que usa el mismo nombre y se comportan de forma similar.

    Para que estén disponibles es necesario importar el paquete y después invocarlas para obtener arreglos Numpy con contenido equivalente.

>>> import numpy as np

    Para crear un arreglo numpy de una dimensión de ceros en Python:

>>> x = np.zeros(3)

>>> print(x)

[0. 0. 0.]

    Para crear un arreglo numpy de ceros de 3x3:

>>> Mc = np.zeros([3,3])

>>> print(Mc)

[[0. 0. 0.]

 [0. 0. 0.]

 [0. 0. 0.]]

    Para crear una "matriz" rectangular de 4x2:

>>> Mc = np.zeros([4,2])

>>> print(Mc)

[[0. 0.]

 [0. 0.]

 [0. 0.]

 [0. 0.]]

    Existe también la función ones que se puede utilizar de igual forma que en Octave:

>>> M1 = np.ones([4,3])/2

>>> print(M1)

[[0.5 0.5 0.5]

 [0.5 0.5 0.5]

 [0.5 0.5 0.5]

 [0.5 0.5 0.5]]

    O una matriz rectangular inicializada con 1.5:

>>> M2 = np.ones([3,4])*1.5

>>> print(M2)

[[1.5 1.5 1.5 1.5]

 [1.5 1.5 1.5 1.5]

 [1.5 1.5 1.5 1.5]]

    La función rand en Python requiere un poco más de escritura, al usar la clase random. Por ejemplo, para crear una "matriz" de 2x2 de números pseudoaleatorios:

>>> u = np.random.rand(2,2)

>>> print(u)

[[0.05328813 0.79864914]

 [0.46865742 0.85856544]]

    O para crear una matriz de 2x4 con números pseudoaleatorios con una distribución normal:

>>> v = np.random.randn(2,4)

>>> print(v)

[[-1.45490502 -0.76736795  0.05142855  0.02027987]

 [-0.36772701  1.39209878 -0.58810718  1.22065564]]

    Y existen las funciones identity y eye para crear "matrices" identidad; en donde la función eye tiene un comportamiento semejante al de Octave, mientras que identity siempre devuelve una matriz cuadrada con unos en su diagonal principal.

    Por ejemplo para crear una "matriz" rectangular con unos en su elemento a(i,i):

>>> I1 = np.eye(4,3)

>>> print(I1)

[[1. 0. 0.]

 [0. 1. 0.]

 [0. 0. 1.]

 [0. 0. 0.]]

y para crear una "matriz" identidad de 3x3:

>>> I2 = np.identity(3)

>>> print(I2)

[[1. 0. 0.]

 [0. 1. 0.]

 [0. 0. 1.]]

    Finalmente es importante notar que los métodos zero y ones consumen una lista cuando se necesita crear un arreglo de dos o más dimensiones, mientras que random.rand, random.randn, identity y eye, se pasan escalares como argumentos para el tamaño en cada dimensión. 

Un poco de matrices en Octave y Python

 Crear matrices en Octave es relativamente fácil, solo hay que delimitar los elementos que la conforman entre paréntesis cuadrados. Los elementos de un renglón se separan por espacios, y los renglones se separan utilizando punto y coma (;).

    Por ejemplo, para un vector de cinco elementos, en Octave se define de la siguiente manera:

x = [1.1 2.1 3.1 4.1 5.1]

    Y para una matriz de 3x4, se define:

A = [1.1 2.1 3.1 4.1; 5.1 6.1 7.1 8.1; 9.1 10.1 11.1 12.1]

mostrando lo siguiente:

A =

    1.1000    2.1000    3.1000    4.1000

    5.1000    6.1000    7.1000    8.1000

    9.1000   10.1000   11.1000   12.1000

    Se pueden concatenar vectores y matrices para crear matrices más grandes.

    Por ejemplo, dado el siguiente vector:

x = [1 2 3]

    Se puede construir la siguiente matriz a partir de concatenar x varias veces:

A = [x; x; x]

dando como resultado:

A =

   1   2   3

   1   2   3

   1   2   3

    Si definimos el vector "y" de la siguiente forma:

y = [1; 2; 3]

y se concatena el vector y varias veces para crear una matriz de la siguiente forma:

B = [y y y]

da como resultado:

B =

   1   1   1

   2   2   2

   3   3   3

 Podemos usar las matrices A y B para construir una matriz más grande.

C = [A 2*A; B [1 0 0; 0 1 0; 0 0 1]]

dando como resultado:

C =

   1   2   3   2   4   6

   1   2   3   2   4   6

   1   2   3   2   4   6

   1   1   1   1   0   0

   2   2   2   0   1   0

   3   3   3   0   0   1

    Para realizar la misma tarea en Python requiere más pasos, empezando por importar el paquete Numpy. 

import numpy as np

    Para definir el vector "x":

x = np.array([1.1, 2.1, 3.1, 4.1, 5.1])

    Y para definir la matriz ejemplo anterior en Python:

A = np.array([[1.1, 2.1, 3.1, 4.1], [5.1, 6.1, 7.1, 8.1], [9.1, 10.1, 11.1, 12.1]])

que devuelve:

array([[ 1.1,  2.1,  3.1,  4.1],

       [ 5.1,  6.1,  7.1,  8.1],

       [ 9.1, 10.1, 11.1, 12.1]])

    En Python para concatenar arreglos Numpy se usa el método concatenate, por lo que a partir del vector "x" definido de la siguiente forma:

x = np.array([[1, 2, 3]])

crear una matriz A de la siguiente forma:

A = np.concatenate((x, x, x))

da como resultado lo siguiente:

array([[1, 2, 3],

       [1, 2, 3],

       [1, 2, 3]])

    Para este ejemplo es importante notar que el vector x en realidad es una matriz Numpy de un único renglon y es importante porque en Python y Numpy no es lo mismo concatenar vectores que concatenar matrices.

Para el vector "y" utilizado previamente, definido de la siguiente forma:

y = np.array([[1],[2],[3]])

al concatenarlo de la siguiente forma:

B = np.concatenate((y,y,y), axis=1) 

se obtiene:

array([[1, 1, 1],

       [2, 2, 2],

       [3, 3, 3]])

En este ejemplo es importante notar que se usó el argumento axis, para indicar que se concatene a la derecha y no hacia abajo.

    Finalmente utilizando ambas matrices resultantes A y B al concatenarlas de la siguiente forma:

C1 = np.concatenate((A, 2*A), axis=1)

C2 = np.concatenate((B,[[1, 0, 0], [0, 1, 0], [0, 0, 1]]), axis = 1)

C = np.concatenate((C1, C2)) 

se obtiene:

 print(C)                                                               

[[1 2 3 2 4 6]

 [1 2 3 2 4 6]

 [1 2 3 2 4 6]

 [1 1 1 1 0 0]

 [2 2 2 0 1 0]

 [3 3 3 0 0 1]]

Obteniendo desde Python, resultados equivalentes a los vistos en Octave.