Contenido

1
●

Escuela de Matemáticas y Estadística

●

Universidad
●
Pedagógica y Tecnológica de ●Colombia
● ●
●
●
● ● ●
●●
●
● ● ●
● ● ● ●
●● ●
●
● ●
● ● ● ● ●
●●● ●

NumPy
● ●
● ●● ●
● ●● ●
● ● ● ● ●

Arreglos NumPy
● ●
● ● ● ● ●
● ● ● ● ●
● ● ● ● ● ●
● ●● ● ● ●
● ● ●
●
● ● ● ● ● ●
● ● ● ● ●
●
●● ●
● ● ● ●
●
● ● ●
● ● ●
● ● ●
● ●
● ●

Problema central
● ● ●
● ●● ●
● ●
Alex L. Rojas
●
● ●
●
●
● ●
●

●
https://alexrojas.netlify.app/post/prog/
●
●
●
● ●
●
●
●

● ●
● ●
● ● ●●● ●
● ●
● ●

Eliminación de ciclos for

● ●● ● ● ●
● ●● ● ●
●
● ●
● ●●
● ● ● ●
● ●● ●
● ●
●
● ●●
●●● ●●
● ●
16 de febrero de 2021
● ●● ● ●
●
●

● ●
●

Alex L. Rojas | Programación

Arreglos NumPy Arreglos NumPy

2 3

Los arreglos n-dimensionales, las estructuras básicas del módulo NumPy, El código anterior carga el módulo ‘NumPy‘ con el alias ‘np‘, el cual es el
son conocidos también como arreglos ‘NumPy‘ o simplemente como alias estándar para este módulo. Usamos el objeto numeros_1al8 para
arreglos. Cada arreglo ‘NumPy‘ es un contenedor homogéneo de crear varios objetos de tipo ‘ndarray‘, a los que llamaremos de ahora en
elementos de tamaño inmutable, es decir, todos sus elementos son del adelante arreglos ‘NumPy‘. Para esto, usamos la función ‘np.array()‘, que
mismo tipo y su forma no cambia. Consideremos los arreglos ‘NumPy‘ es el constructor principal de los arreglos ‘NumPy‘, es decir, la función
definidos en el siguiente código: que crea objetos tipo ‘ndarray‘.
1 import numpy as np Por defecto, ‘np.array()‘ asigna 8 ‘bytes‘ (64 ‘bits‘) de memoria, pero en
2 numeros_1al8 = range (1 ,9) situaciones en las que sabemos que necesitamos menos memoria
3 enteros8bytes = np . array ( numeros_1al8 )
4 enteros4bytes = np . array ( numeros_1al8 , dtype = ’ int32 ’)
podemos reducirle a 4, 2, o 1 ‘byte‘. Así fue como creamos los arreglos
5 enteros2bytes = np . array ( numeros_1al8 , dtype = ’ int16 ’) ‘enteros4bytes‘, ‘enteros2bytes‘ y ‘enteros1byte‘, respectivamente.
6 enteros1byte = np . array ( numeros_1al8 , dtype = ’ int8 ’)
7 M a t r i z E n t e r o s 8 b y t e s = np . array ([ numeros_1al8 , numeros_1al8 , No solo podemos definir arreglos donde todos sus elementos son enteros,
8 numeros_1al8 ]) también es posible que sean todos de punto flotante, complejos,
booleanos o enteros sin signo.

Alex L. Rojas | Programación Alex L. Rojas | Programación

 Arreglos NumPy Arreglos NumPy
4 5

Al igual que otros objetos en ‘Python‘, los arreglos ‘NumPy‘ tienen

El atributo ‘shape‘ podemos modificarlo con la función ‘np.reshape()‘,
atributos que nos proveen información importante para su manipulación.
siempre y cuando la nueva forma sea compatible con la original. Esto se
La siguiente tabla contiene los atributos básicos.
logra cuando el número total de elementos del arreglo original es igual al
Tabla: Atributos básicos de la clase ndarray número total de elementos del arreglo reformado.
En otras palabras, el producto de los elementos de la tupla que
Atributo Descripción representa la forma del arreglo original debe ser igual al producto de la
tupla que representa la forma del arreglo reformado.
dtype Tipo de elementos en el arreglo.
nbytes Número de bytes usados para almacenar los datos. Por ejemplo, la forma del arreglo ‘enteros8bytes‘ es (8, ), podríamos por lo
ndim Número de dimensiones. tanto modificar el arreglo para que tenga alguna de las siguientes formas:
size Número total de elementos del arreglo. (8, 1), (2, 4), (4, 2), (2, 2, 2). Así como se muestra en el siguiente código:
shape Tupla que contiene el número de elementos para cada 1 enteros8bytes . reshape (8 ,1)
dimensión del arreglo. 2 enteros8bytes . reshape (2 ,4)
strides Tupla con el número de bytes necesarios para atravesar 3 enteros8bytes . reshape (4 ,2)
cada una de las dimensiones en un arreglo. 4 enteros8bytes . reshape (2 ,2 ,2)

Alex L. Rojas | Programación Alex L. Rojas | Programación

Arreglos NumPy Arreglos NumPy

6 7

La siguiente tabla presenta una lista de las funciones comúnmente usadas

para inicializar arreglos ‘NumPy‘.
Tabla: Resumen de algunas de las funciones para generar arreglos NumPy
Nombre de la función
np.apply_along_axis()
np.array()
np.arange()
Tabla: Resumen de algunas de las funciones para generar arreglos NumPy
Nombre de la función Tipo de arreglo creado
np.diag() Arreglo de dos dimensiones con valores
Tipo de arreglo creado
específicos en la diagonal y ceros en el
Arreglo resultado al aplicar una función resto de celdas.
dada a los arreglos unidimensionales en np.fromfunction() Arreglo de dos dimensiones con valores
un eje. obtenidos al aplicar una función donde los
Arreglo con los elementos dados por ob- argumentos son los índices.
jetos similares a un arreglo, tales como np.full() Arreglo con dimensiones especificadas por
listas y tuplas. la usuaria con todos sus elementos iguales
Arreglo con valores igualmente espacia- a una constante dada.
dos entre un valor inicial (primer argu- np.linspace() Arreglo con un número específico de va-
mento) y un valor final (segundo argu- lores (tercer argumento) igualmente es-
mento), donde el espacio está dado por paciados entre el primer argumento y el
el tercer argumento. segundo argumento.

Alex L. Rojas | Programación Alex L. Rojas | Programación

 Arreglos NumPy Arreglos NumPy
8 9

Tabla: Resumen de algunas de las funciones para generar arreglos NumPy Example
Queremos definir un arreglo ‘Numpy‘ para representar la matriz P
Nombre de la función Tipo de arreglo creado definida como
0 1
np.meshgrid() Arreglos de coordenadas con base en vectores 11 1 1 1 1 1 1
de coordenadas. B 1 21 1 1 1 1 1 C
B C
np.ones() Arreglo de unos con dimensiones especifica- B 1 1 31 1 1 1 1 C
B C
das por el usuario. P=B B 1 1 1 41 1 1 1 C .
C
np.random.choice() Arreglo con una muestra aleatoria de tamaño B 1 1 1 1 51 1 1 C
B C
especificado por la usuaria proveniente de un @ 1 1 1 1 1 61 1 A
arreglo unidimensional 1 1 1 1 1 1 71
np.random.rand() Arreglo de números aleatorios uniformemen-
te distribuidos entre 0 y 1. Es decir, queremos construir una matriz de 7 ⇥ 7 donde todos los números
np.sort() Copia del arreglo original ordenado. fuera de la diagonal son iguales a uno, y en la diagonal encontramos los
np.zeros() Arreglo de ceros con dimensiones especifica- números 11, 21, 31, 41, 51, 61 y 71. Luego P puede ser construída
das por el usuario. sumando dos matrices: una matriz de solo unos, y otra cuyos elementos
en la diagonal son los números del 10 al 70 contando de 10 en 10.
Alex L. Rojas | Programación Alex L. Rojas | Programación

Arreglos NumPy Arreglos NumPy

10 11

En un ejemplo anterior presentamos las funciones ‘Vsm()‘ y ‘Vcs()‘ para

calcular el volumen molar total del agua en una disolución de sulfato de
Es así que podemos usar la función ‘np.ones()‘ para generar una matriz
magnesio, y cloruro de sodio, respectivamente. Usando la función
de 7 ⇥ 7 con solo unos en todas las celdas y por otro lado podemos usar
‘np.linspace()‘ podemos crear una partición del intervalo donde queremos
la función ‘np.diag()‘ para crear una matriz con diagonal el vector
graficar la función, y así aplicar las funciones ‘Vsm()‘ y ‘Vcs()‘ elemento
(10, 20, 30, 40, 50, 60, 70), el cual puede ser generado usando la función
a elemento en la partición. Los gráficos de Vsm y Vcs en el intervalo
‘np.arange()‘. Esta función genera una partición con un valor inicial, en
[0, 0.5] (mol kg 1) los podemos generar con el siguiente:
este caso 10, con un incremento constante, igualmente 10, mientras que
sea menor que un valor de parada. Como valor de parada podemos usar 1 x1 = np . linspace (0.0 , 0.6)
2 ysm = Vsm ( x1 )
cualquier número mayor que 70 y menor o igual que 80. Si usamos solo 3 x2 = np . linspace (0.0 , 0.5)
números enteros en esta función, el resultado es un arreglo ‘NumPy‘ de 4 ycs = Vcs ( x2 )
números enteros. Si alguno de los argumentos es de punto flotante, el 5 f , ( ax1 , ax2 ) = plt . subplots (1 , 2)
arreglo creado contiene números de punto flotante. Así, la matriz P la 6 ax1 . plot ( x1 , ysm , ’o - ’ , color = ’ black ’)
7 ax1 . set_ylabel ( r ’ Volumen molar del agua $cm ^3 $ ’)
podemos obtener con el siguiente código. 8 ax1 . set_xlabel ( r ’ Sulfato de magnesio ( mol kg$ ^{ -1}) $ ’)
1 P = np . ones ((7 ,7) ) + np . diag ( np . arange (10 ,71 ,10) ) 9 ax1 . set_ylim (1001 ,1012)
10 ax2 . plot ( x2 , ycs , ’ - ’ , color = ’ black ’)
11 ax2 . set_xlabel ( r ’ Cloruro de sodio ( mol kg$ ^{ -1}) $ ’)
12 ax2 . set_ylim (1001 ,1012)

Alex L. Rojas | Programación Alex L. Rojas | Programación

 Arreglos NumPy Arreglos NumPy
12 13

Example
Queremos graficar las curvas de nivel de la función Example
Queremos inicializar un arreglo ‘NumPy‘ con el siguiente formato:
f (x, y ) = sen(x) + cos(x),
0 1 2 3 4
en la región R = [ 2⇡, 2⇡] ⇥ [0, 4⇡]. Para hacer este gráfico necesitamos 1 0 1 2 3
evaluar la función en una malla de puntos en la región R. Tomemos la 2 1 0 1 2
malla tal que las coordenadas en el eje y corresponden a la partición del 3 2 1 0 1
intervalo [0, 4⇡] en diez subintervalos de igual longitud. Mientras que las 4 3 2 1 0
coordenadas de la malla en el eje x está dada por los puntos
xi = 2⇡ + 0.5 · (i 1) con i = 0, 1, 2, . . . , 26. Podemos verificar fácilmente que la posición (i, j) en este arreglo
corresponde al valor |i j|, luego podemos usar la función
1 puntosEnX = np . arange ( -2* np . pi ,2* np . pi ,.5)
2 puntosEnY = np . linspace (0 ,4* np . pi ,11) ‘np.fromfunction()‘ para crearlo de la siguiente manera:
3 xs , ys = np . meshgrid ( puntosEnX , puntosEnY ) 1 DistC = np . fromfunction ( lambda i , j : abs (i - j ) , (5 ,5) , dtype =
4 f_eval = np . sin ( xs ) + np . cos ( ys ) int )
5 fig = plt . figure ( figsize =(10 ,10) )
6 plt . contourf ( puntosEnX , puntosEnY , f_eval )
7 plt . colorbar ()

Alex L. Rojas | Programación Alex L. Rojas | Programación

Juego de la vida Juego de la vida

14 15

El juego de la vida de John H. Conway se desarrolla en una tablero

cuadrado en el cual viven “células”. Para un tiempo t, en cada celda (i, j)
vive o muere una célula de acuerdo a al estado de las celdas vecinas en el
tiempo t 1. Cada celda tiene ocho celdas vecinas, y las reglas para la
siguiente generación son las siguientes tres:
Regla para nacer: una célula nace en la siguiente generación en una
celda vacía que tenga exactamente tres células vecinas, en cualquier otro
caso la celda permanece vacía.
Regla para sobrevivir: una célula con dos o tres vecinas sobrevive para
la siguiente generación.
Regla para morir: una célula con cuatro o más vecinas muere por Figura: Ejemplo de un autómata con 36 celdas. Las células vivas están
sobrepoblación, y una célula con solo un vecino o ninguno muere de representadas por las celdas negras. El número dentro de cada celda
corresponde al número de células vivas vecinas en el tiempo t (izquierda) y
solitud.
t + 1 (derecha). Fuente: López y Rojas (2021)

Alex L. Rojas | Programación Alex L. Rojas | Programación

 Juego de la vida Eliminación de ciclos for
16 17

Podemos codificar el juego de la vida usando ciclos ‘for‘. Para esto,

representamos las celdas con una célula viva con el número ‘1‘, y las
celdas vacías con ‘0‘. Luego avanzamos por cada elemento de la matriz I Funciones universales: función definida en la librería ‘NumPy‘ que
encontrando cuantas células vecinas hay para cada celda, y aplicamos las opera elemento por elemento en arreglos ‘NumPy‘, y son usualmente
reglas del juego. Para evitar problemas con la frontera, el borde de la conocidas como ‘ufuncs‘.
matriz no se tiene en cuenta en los cálculos en la siguiente función: I Agregaciones: son funciones que *resumen* los valores en un
1 def JuegoVidaV0 ( B ) : arreglo, como por ejemplo la media, la mediana, el máximo, el
2 n , m = np . array ( B ) . shape mínimo, la suma, percentiles etc.
3 Bt = np . zeros (( n , m ) ) I Broadcasting: conjunto de reglas usadas por ‘NumPy‘ para decidir
4 for i in range (1 , n -1) :
5 for j in range (1 ,m -1) : como operan las funciones universales en arreglos de diferentes
6 vecinas = ( B [i -1 ,j -1] + B [i ,j -1] + B [ i +1 ,j -1]+\ formas.
B [i -1 , j ] + B [ i +1 , j ] +\
7
8 B [i -1 , j +1] + B [i , j +1]+ B [ i +1 , j +1])
I Indexación: es más flexible con arreglos ‘NumPy‘ que con listas, y
9 if ( B [i , j ]==0) & ( vecinas == 3) : además ofrece dos opciones más para indexar rápidamente y de una
10 Bt [i , j ]= 1 manera conveniente. Estas son denominadas enmascarar (masking) e
elif ( B [i , j ]==1) & (( vecinas == 3) |( vecinas ==
11
indexación elegante (fancy).
2) ) :
12 Bt [i , j ] = 1
13 return ( Bt )
Alex L. Rojas | Programación Alex L. Rojas | Programación

Eliminación de ciclos for Eliminación de ciclos for

Funciones universales Agregaciones
18 19

Vamos a generar una lista de cien mil temperaturas en grados Fahrenheit

y queremos pasarlas a Celcius. Usando comprensión de listas podemos
digitar: Las agregaciones podrían definirse usando ciclos ‘for‘, pero es más rápido
hacer cálculos con estas funciones:
1 temperaturasF = np . random . uniform (20 ,90 ,(100000 ,1) )
2 temperaturasC = [( x -32) /1.8 for x in temperaturasF ] 1 %timeit min ( temperaturasF )
2 %timeit np . min ( temperaturasF )
sando las funciones universales ‘add()‘ y ‘divide()‘, las cuales podemos
utilizar con su notación infijo, es decir, en lugar de escribir También podemos usar las funciones de agregación para arreglos en
‘divide(subtract(temperaturasF,32),1.8)‘ se escribe simplemente: múltiples dimensiones. Por ejemplo, podemos encontrar el promedio
global de los valores en una matriz de números aleatorios, el promedio
1 temp eratur asCN = ( temperaturasF -32) /1.8
por filas y por columnas:
Las dos operaciones son sencillas de leer, pero en nuestra opinión la 1 a = np . random . uniform (0 ,100 ,(100 ,200) )
versión con funciones universales es más clara. Pero además de la 2 a . mean ()
facilidad para leer, nos interesa la velocidad de ejecución de los cálculos. 3 a . mean ( axis = 0) # promedio por columnas
4 a . mean ( axis = 1) # promedio por filas
Para esto usamos la función ‘ %timeit‘, la cual mide el tiempo que tarda
en completarse una expresión o declaración. donde ‘axis=0‘ corresponde a las columnas, y ‘axis=1‘ a las filas.
1 %timeit [( x -32) /1.8 for x in temperaturasF ]
2 %timeit ( temperaturasF -32) /1.8

Alex L. Rojas | Programación Alex L. Rojas | Programación

 Eliminación de ciclos for Eliminación de ciclos for
Broadcasting Broadcasting
20 21

Las reglas son: Consideremos los siguientes cuatro arreglos ‘Numpy‘:

1. Si la forma de los arreglos NumPy difieren, a la tupla con menor 1 a = np . array ([1 ,2 ,3 ,4])
longitud se le adicionan unos a la izquierda hasta que las tuplas 2 b = np . fromfunction ( lambda i , j : i *10+ j +1 ,(3 ,4) )
tengan la misma longitud. Por ejemplo, 3 c = np . array ( -1)
Forma original de los arreglos Nueva forma de los arreglos 4 d = np . fromfunction ( lambda i , j : ( - i *10) ,(3 ,1) )
(), (4, ) ! (1, ), (4, ) Estos arreglos tienen las siguientes formas (4, ), (3, 4), () y (3, 1),
(4, ), (3, 4) ! (1, 4), (3, 4) respectivamente. Dadas las reglas del broadcasting, ‘NumPy‘ puede llevar
(5, 2), (2, 1, 1) ! (1, 5, 2), (2, 1, 1) a cabo operaciones entre cualquier pareja de estos arreglos, por ejemplo:
(3, ), (3, 2, 2) ! (1, 1, 3), (3, 2, 2)
1 a ** b
2. Si cualquiera de los valores en las nuevas tuplas son diferentes, 2 a - c
2.1 si alguno de los valores que difiere es 1, se expande las dimensiones 3 a + d
con valor 1 hasta que las formas sean iguales. 4 b * d
Forma original de los arreglos Nueva forma de los arreglos
(1, ), (4, ) ! (4, ), (4, ) Sin embargo, si en lugar de tener un arreglo bidimensional ‘d‘ de forma
(1, 4), (3, 4) ! (3, 4), (3, 4) (3, 1), le cambiamos la forma por (1, 3):
(1, 2, 4), (4, 2, 4) ! (4, 2, 4), (4, 2, 4) 1 d = np . fromfunction ( lambda i , j : ( - j *10) ,(1 ,3) )
(1, 1, 4), (4, 2, 1) ! (4, 2, 4), (4, 2, 4)
2.2 y si alguno de los valores que difieren en las tuplas no es 1, se ‘NumPy‘ solamente puede hacer operaciones para ‘d‘ con ‘c‘, y no con ‘a‘
produce un error y la operación no se puede llevar a cabo. y ‘b‘.
Alex L. Rojas | Programación Alex L. Rojas | Programación

Eliminación de ciclos for Eliminación de ciclos for

Broadcasting Broadcasting
22 23

Luego para hacer la estandarización elemento a elemento necesitaríamos

Example los siguientes dos arreglos bidimensionales:
8
Dada una matriz X = {xij }np , queremos estandarizar las columnas, es >
> x1 x2 . . . xp s1 s2 . . . sp
>
< x1 x2 . . . xp
decir, para cada elemento de la j-ésima columna, j = 1, . . . , p, queremos s1 s2 . . . sp
encontrar n filas .. .. .. .. .. .. .. .. .
>
> . . . . y . . . .
>
:
xij xj x1 x2 . . . xp s1 s2 . . . sp
yij = , i = 1, . . . , n,
sj Sin embargo, esto no es necesario gracias al broadcasting. Ya calculados
donde x j y sj son la media y la desviación estándar de los valores en la los vectores de medias y desviaciones estándar, tenemos tres arreglos: la
j-ésima columna, respectivamente. Para esto necesitamos encontrar la matriz X de forma (n, p), el vector de medias de las p columnas en un
media y la desviación estándar para cada una de las columnas, las cuales arreglo (p, ), y el vector de varianzas de las p columnas en un arreglo
pueden ser almacenadas en dos arreglos ‘NumPy‘ cada uno con forma (p, ), luego aplicando la primera regla de broadcasting tenemos las tuplas
(p, ): [x 1 , x 2 , . . . , x p ] y [s 1 , s 2 , . . . , s p ]. (n, p), (1, p) y (1, p). Ahora, aplicando la segunda regla, tenemos las
tuplas (n, p) y (n, p), y podemos realizar la operación término a término
sin problema alguno:

Alex L. Rojas | Programación Alex L. Rojas | Programación

 Eliminación de ciclos for Eliminación de ciclos for
Broadcasting Indexación
24 25

1 X = np . random . uniform (0 ,100 ,(10 ,2) )
2 X _E st a nd a ri za d a = ( X - X . mean ( axis =0) ) / X . std ( axis =0)
En el ejemplo anterior, el arreglo ‘X‘ tiene una forma ‘(10,2)‘, mientras
que la agregación ‘X.mean(axis=0)‘ tiene una forma ‘(2,)‘, luego la
operación ‘X-X.mean(axis=0)‘ está restando a cada fila del arreglo ‘X‘ el
vector de medias y genera un arreglo con forma ‘(10,2)‘. Ahora la
operación ‘(X-X.mean(axis=0))/X.std(axis=0)‘ está dividiendo cada fila
de ‘(X-X.mean(axis=0))‘ entre las desviaciones estándar de cada
columna de ‘X‘, y produce de nuevo un arreglo con forma ‘(10,2)‘.
Dado un arreglo con valores booleanos, este puede ser usado para indicar
las posiciones de un arreglo que queremos seleccionar. Es decir, si una
posición tiene el valor verdadero (‘True‘) esto le indica a ‘Python‘ que
esta posición debe seleccionarse, de otra manera se enmascara, es decir,
se oculta. Por ejemplo,
1 a = np . array ([2 , 3.5 , -2 , -4.5 , 4 , 5 , -3.5 , 17])
2 mascara = [ True , False , False , True , True , False , False ,
True ]
3 a [ mascara ]
En este caso se seleccionan las posiciones 0, 3, 4 y 7, ya que el restos
fueron enmascaradas.
En la lista anterior podemos seleccionar fácilmente los elementos que
sean positivos, o aquellos elementos cuyo cuadrado sea menor que 16:
1 a [ a > 0]
2 a [ a **2 < 16]

Alex L. Rojas | Programación Alex L. Rojas | Programación

Eliminación de ciclos for Eliminación de ciclos for

Indexación 26
Indexación 27

Example
Queremos definir un arreglo ‘Numpy‘ para representar la matriz P
definida como
Example 0 1
Dado un arreglo de números, queremos encontrar los elementos del 0 0 0 0 0 0 0
B 0 1 1 1 1 1 0 C
arreglo que estén dos desviaciones estándar alejados de su promedio y B C
B 0 1 2 2 2 1 0 C
reemplazarlos con su mediana. Para esto, calculamos la media, la B C
desviación estándar y la mediana de los números. Luego buscamos los P=B B 0 1 2 3 2 1 0 C.
C
B 0 1 2 2 2 1 0 C
elementos del arreglo que cumplan la condición ‘ abs(a - np.mean(a)) > B C
@ 0 1 1 1 1 1 0 A
2*np.std(a)‘, que son los que son reemplazados por ‘np.median(a)‘:
0 0 0 0 0 0 0
1 a [ abs ( a - np . mean ( a ) ) > 2* np . std ( a ) ] = np . median ( a )
Una manera de crear este arreglo en ‘Python‘ es usar el siguiente código.
1 P = np . zeros ((7 ,7) )
2 P [1: -1 ,1: -1] = 1
3 P [2: -2 ,2: -2] = 2
4 P [3: -3 ,3: -3] = 3

Alex L. Rojas | Programación Alex L. Rojas | Programación

 Eliminación de ciclos for Eliminación de ciclos for
Indexación 28
Indexación 29

Dada una matriz de probabilidades de tamaño n ⇥ m, P = {pij }n⇥m ,

queremos reemplazar las probabilidades por debajo de un ✏, por ✏, y las
probabilidades por encima de 1 ✏ reemplazarlas por 1 ✏, es decir,
Podemos simplificar el código y a la vez hacer más general la generación queremos calcular pij⇤ donde
de la matriz del ejercicio anterior. Primero, la dimensión de la matriz está
dada por 2 · n + 1, donde n es el número que va en el centro de la matriz. pij⇤ = mín{máx{pij , ✏}, 1 ✏} i = 1, . . . , n; j = 1, . . . , m.
Segundo, podemos asignar los valores de las celdas con un ciclo ‘for‘ de Además, para cada fila de la matriz queremos calcular
la siguiente manera:
def matriz Pirami de ( n =3) :
pij⇤
1
pij? = m , i = 1, . . . , n; j = 1, . . . , m.
2 P = np . zeros ((2* n +1 ,2* n +1) , dtype = " int " ) X
3 for i in range (1 , n +1) : pij⇤
4 P [ i : -i , i : - i ] = i j=1
5 return ( P )
Para reemplazar los valores de las probabilidades que sean menores que ✏
o mayores que 1 ✏, podemos enmascarar las probabilidades que no
cumplan esta condición y así reemplazar las que si la cumplan:
1 P [ P > 1 - epsilon ] = 1 - epsilon
2 P [ P < epsilon ] = epsilon
Alex L. Rojas | Programación Alex L. Rojas | Programación

Eliminación de ciclos for Eliminación de ciclos for

Indexación 30
Indexación 31

Ahora podemos calcular la suma por filas de las probabilidades usando

agregaciones:
1 sumaXfila = P . sum ( axis =1)
2 sumaXfila . shape

Note que la forma de ‘sumaXfila‘ es ‘(n,)‘, ya que calculamos la suma 1 def p r o b T o t a l A c o t a d a (P , epsilon ) :
para n filas y la forma de P es ‘(n,p)‘, luego al aplicar las reglas de 2 P [ P > 1 - epsilon ] = 1 - epsilon
broadcasting no sería posible dividir cada elemento de una fila por la 3 P [ P < epsilon ] = epsilon
4 sumaXfila = P . sum ( axis =1)
suma de la fila ya que terminamos con arreglos con formas ‘(n,p)‘ y 5 P = P / sumaXfila [: , np . newaxis ]
‘(1,n)‘. 6 return P

Podemos, sin embargo, hacer uso de ‘np.newaxis‘:

1 sumaXfilas [: , np . newaxis ]

Este método aumenta la dimensión del arreglo en un eje. En nuestro caso

el arreglo ‘sumaXfilas‘ pasa de ser un arreglo con forma ‘(n,)‘ a un
arreglo con forma ‘(n,1)‘, luego al aplicar las reglas de broadcasting
podemos dividir cada elemento de una fila por la suma de la fila:
Alex L. Rojas | Programación Alex L. Rojas | Programación