domingo, septiembre 12, 2021

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. 

Etiquetas: ,

0 Comentarios:

Publicar un comentario

Suscribirse a Comentarios de la entrada [Atom]

<< Página Principal