# Clase 3 - NumPy

# Ejemplo 1 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

import numpy as np

a = np.array([4, 2, 1, 4, 7, 6])    # definición de un array por elementos

print(a)

dim_a = a.ndim              # obtenemos la cantidad de "ejes" que tiene el array
forma_a = a.shape           # obtenemos el "tamaño" (cantidad de elementos) de cada eje
tamano_a = a.size           # obtenemos la cantidad total de elementos del array (dim_a x forma_a)
tipo_a = a.dtype

print(dim_a, forma_a, tamano_a, tipo_a)     # REVISAR CÓMO MOSTRAR QUÉ TIPO SON

type(dim_a)
type(forma_a)
type(tamano_a)
type(tipo_a)

# Ejemplo 2 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

ArrStr = np.array(['h','o','l','a'])
# vemos un poco qué es esto:
#print(ArrStr)
#ArrStr.ndim
#ArrStr.size
#ArrStr.shape
#ArrStr.dtype

# ¿Qué nos sale si imprimimos el elemento ArrStr[2]?
#ArrStr[2]

ArrZero = np.zeros(6)
print(ArrZero)

ArrOnes = np.ones(4)
print(ArrOnes)

ArrEmpty = np.empty(5)
print(ArrEmpty)

# ver las propiedades de cada Array

#b = np.arange([start,] stop[, step][, dtype=])
b1 = np.arange(7)
b2 = np.arange(1,11)
b3 = np.arange(0,11,2)
b4 = np.arange(25,-1,-5)

#c = np.linspace(start, stop, num[=50])
c1 = np.linspace(3,27)
c2 = np.linspace(3,27,25)

# sort
a2 = np.sort(a)
print(a,a2)

# concatenate
b5 = np.concatenate((b3,b4))
print(b3,b4,b5)


# Ejemplo 3 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

a3 = a2.reshape((2,3))
print(a2)
print(a3)
print(a2.ndim, a2.shape, a2.size)
print(a3.ndim, a3.shape, a3.size)

# mostrar como se va llenando a3

b6 = b5.reshape((2,3,2))
print(b5)
print(b6)
print(b5.ndim, b5.shape, b5.size)
print(b6.ndim, b6.shape, b6.size)

# mostrar cómo se va llenando b6

# y algo más complicado, un array en cuatro dimensiones
aux = np.ones(81)
Tensor = aux.reshape((3,3,3,3))

for i in [1,2,3]:
    for j in [1,2,3]:
        for k in [1,2,3]:
            for l in [1,2,3]:
                Tensor[i-1,j-1,k-1,l-1] = i*j*k*l

print(Tensor)


# Ejemplo 4 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

# extracción de partes de un array de un eje

a4 = a2[2:5]
print(a2,a4)

# extracción de pedazos de una matriz

a5 = np.hstack((a3,a3))
print(a3,a5)

[a6_1, a6_2, a6_3] = np.hsplit(a5,3)
print(a5)
print(a6_1)
print(a6_2)
print(a6_3)

[a7_1, a7_2, a7_3] = np.hsplit(a5,(3,4))
print(a5)
print(a7_1)
print(a7_2)
print(a7_3)

a8 = a5[1,:]
a9 = a5[:,4]
print(a5,a8,a9)


# Ejemplo 5 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

# operaciones entre arrays de las mismas dimensiones
d1 = np.array([[2, 3],[4, 9]])
d2 = np.array([[4, 1],[2, 3]])
print(d1)
print(d2)

suma = d1+d2
print(suma)

resta = d1-d2
print(resta)

divi = d1/d2
print(divi)

multi = d1*d2
print(multi)
# notar que son operaciones ELEMENTO A ELEMENTO


# operaciones entre arrays de distinto tamaño.  Algunos ejemplos
suma7 = a7_1+a7_2
multip7 = a7_1*a7_2
print(a7_1)
print(a7_2)
print(suma7)
print(multip7)

suma_a = a5+a8
multip_a = a5*a8
print(a5)
print(a8)
print(suma_a)
print(multip_a)

# notar que las operaciones a5+a9 y a5*a9, etc, no funcionan porque a9 tiene un eje menos que a5.  Revisen la forma de cada array
suma_a2 = a5+a9
multip_a2 = a5*a9
# es necesario agregarle una columna a a9

a9_2 = np.expand_dims(a9, axis=1)
suma_a2 = a5+a9_2
multip_a2 = a5*a9_2
print(a5)
print(a9_2)
print(suma_a2)
print(multip_a2)

# operaciones array x escalar

d1b = d1*1.7
d1c = d1-4

print(d1)
print(d1b)
print(d1c)

# y puedo reasignar partes completas de un array
print(b1)
b1[2:5] = -3
print(b1)

print(b6)
b7 = b6.copy()              # generamos una copia exacta de b7
b7[:,:,1] = -10
print(b7)

#jugamos con los máximos, mínimos y sumas
a3copy = a3.copy()
a3[0,1] = 8

max_a3 = a3.max()
min_a3 = a3.min()
sum_a3 = a3.sum()
print(a3)
print(max_a3)
print(min_a3)
print(sum_a3)

#maximos y mínimos en distintos ejes
max_a3_ax0 = a3.max(axis=0)
max_a3_ax1 = a3.max(axis=1)

print(max_a3_ax0)
print(max_a3_ax1)

# generación de números aleatorios
rng = np.random.default_rng(0)
ArrRnd = rng.random((2,3))
print(ArrRnd)

# generación de una matriz de enteros random
MatA = rng.integers(5, size=(2, 4))


# Ejemplo 6 - Matrices ++++++++++++++++++++++++++++++++++++++++++++++++++++++++

# matrices
MatA = rng.integers(10, size=(4, 4))
MatA = MatA-5
print(MatA)
# probar este mismo ejemplo con valores entre -50 y 50...

det_MatA = np.linalg.det(MatA)
print(det_MatA) 

# una matriz con determinante nulo
A1 = rng.integers(10, size=(3, 4))
a1 = np.sum(A1,axis=0)
print(A1,a1)

# ver las dimensiones de cada array
A1.shape
a1.shape

# es necesario agregarle un eje a a1

a1 = np.expand_dims(a1, axis=0)
a1.shape

A2 = np.vstack((A1,a1))
print(A2)

det_A2 = np.linalg.det(A2)
print(det_A2) 
# el determinante de A2 es el cero de la máquina


# Ejemplo 7 - Resolución de sistemas de ecuaciones ++++++++++++++++++++++++++++

A3 = rng.integers(100, size=(4, 4))
A3 = A3-50
print(A3)

b3 = np.sum(A3, axis=1)
print(b3)

invA3 = np.linalg.inv(A3)
print(invA3)

# verifico
print(invA3*A3)  # ¿qué pasó acá?
print(np.matmul(invA3,A3)) # ahora sí, estamos multiplicando como corresponde
# otro método posible es np.dot.  Ver diferencias

x_a = np.matmul(invA3,b3)
print(x_a)


# Ejemplo 8 - resolviendo sistemas de ecuaciones ++++++++++++++++++++++++++++++

x_b = np.linalg.solve(A3, b3)
print(x_b)

# ¿En qué se diferencian?

import timeit

ResolInv = """
import numpy as np
rng = np.random.default_rng(0)
A3 = rng.integers(100, size=(4, 4))
A3 = A3-50
b3 = np.sum(A3, axis=1)
invA3 = np.linalg.inv(A3)
x_a = np.matmul(invA3,b3)
"""

ResolDir = """
import numpy as np
rng = np.random.default_rng(0)
A3 = rng.integers(100, size=(4, 4))
A3 = A3-50
b3 = np.sum(A3, axis=1)
x_b = np.linalg.solve(A3, b3)
"""

tInv = timeit.timeit(stmt=ResolInv,number=100)/100     # lo resuelvo 10 veces y tomo el promedio...
tDir = timeit.timeit(stmt=ResolDir,number=100)/100

print(tInv,tDir)


# La importancia del número de condición:
A1 = np.array([[400, -201],[-800, 401]])
A2 = np.array([[401, -201],[-800, 401]])
b = np.array([200,-200])
x1 = np.linalg.solve(A1,b)
x2 = np.linalg.solve(A2,b)
print(x1,x2)

CondA1 = np.linalg.cond(A1)
CondA2 = np.linalg.cond(A2)
print(CondA1,CondA2)

# lo mismo ocurre si varío el vector b 
b2 = np.array([201,-199])
x2_b = np.linalg.solve(A2,b2)
print(x2,x2_b)