Código practica 3 psal

# -*- coding: utf-8 -*-
"""
Práctica 3

"""

# Librerías útiles
import math
import random

import numpy as np
from scipy import stats
import matplotlib.pyplot as plt


# Funciones útiles
from scipy.stats import linregress


def pintar_histograma_2D(muestras_x, muestras_y, titulo="Histograma 2D", bins=20):
    plt.hist2d(muestras_x, muestras_y, bins=bins)
    plt.title(titulo)
    plt.show()


def pintar_histograma(muestras, titulo="Histograma", bins=20):
    plt.hist(muestras, bins=bins)
    plt.title(titulo)
    plt.show()



# %% APARTADO A
import numpy as np
import matplotlib.pyplot as plt

experimentos = 10000
a = 5
A = 20 
B = 5


#Generamos coordenadas X
ejex = np.linspace(-a, a, 100)
#Generamos coordenadas Y
ejey = np.linspace(-a, a, 100)
#Generamos todas las tuplas hechas a partir de las coordenadas X e Y
xs, ys = np.meshgrid(ejex, ejey) 

zs = ((a - np.abs(xs)) * (a - np.abs(ys))) / a ** 4

h = plt.contourf(ejex, ejey, zs)
plt.axis('scaled')
plt.colorbar()
plt.show()

#REVISAR ESTO####################################
err_coords: np.array = np.array((xs.flatten(), ys.flatten()))
#Adaptamos la forma de err_coords:
err_code_transposed = np.copy(err_coords)
lista_errores = []
lista_errores: np.array = err_coords
#################################################

# %% APARTADO B
r: np.array = np.sqrt(err_coords[0]**2, err_coords[1]**2)
angles: np.array = np.arctan2(lista_errores[0], lista_errores[1])

lista_errores_polares: np.array = [r, angles]
# %% APARTADO C
muestras_U_polares = r
muestras_V_polares = angles
pintar_histograma_2D(muestras_U_polares, muestras_V_polares)
pintar_histograma(r)
pintar_histograma(angles)



# %% APARTADO D
A = 20

randx: np.array = (np.random.rand(10000)*2*A) - A
randy: np.array = (np.random.rand(10000)*2*A) - A

posiciones_escenario_A = [np.copy(randx), np.copy(randy)]




# %% APARTADO E
posiciones_escenario_A_error: np.array = [np.copy(posiciones_escenario_A[0]) + np.copy(err_coords[0])
                                        , np.copy(posiciones_escenario_A[1]) +  np.copy(err_coords[1])]




# %% APARTADO F
muestras_X = posiciones_escenario_A[0]
muestras_Y = posiciones_escenario_A[1]
pintar_histograma_2D(muestras_X, muestras_Y, titulo="Posiciones A")
muestras_X_error = posiciones_escenario_A_error[0]
muestras_Y_error = posiciones_escenario_A_error[1]
pintar_histograma_2D(muestras_X_error, muestras_Y_error, titulo="Posiciones A con error")



# %% APARTADO G
pintar_histograma(muestras_X)
pintar_histograma(muestras_X_error)



# %% APARTADO H
contador = 0
repeticiones_fuera_recinto_A = 0
for i in range(len(posiciones_escenario_A_error[0])): 
    if np.abs(posiciones_escenario_A_error[0][i]) > 20  or np.abs(posiciones_escenario_A_error[1][i] > 20):
        repeticiones_fuera_recinto_A += 1 
    contador += 1
print("La probabilidad de que un registro con error caiga fuera del recinto A es: ",
      repeticiones_fuera_recinto_A / experimentos)
    



# %% APARTADO I
##CREAR 4 FUNCIONES QUE SEAN FUNCIONES MATEMÁTICAS. 
##--> PARA ESO UTILIZAREMOS FUNCIONES ANÓNIMAS (LAMBDA)
'''
Estas funciones tienen que  tener dos coordenadas como return pues estamos tra-
tando en un campo 2d.

Obtenemos dos coordenadas a base de dos puntos de forma que podamos formar la 
ecuación de la respectiva recta.

** (b^2 / 2)^1/2 = (b**2 / 2)**(1/2)
'''

B = 5
#y = mx + n
lado = (B**2 / 2)**(1/2)
'''
f1 = lambda x: x()
'''

##mayor que
f1 = lambda x: x + lado #Lado 1######
f2  = lambda x: -x + 2*A  #Lado 2 ##

##menor que
f3  = lambda x: -x - 2*A + lado #Lado 3
f4  = lambda x: x - lado #Lado 4 ########

diccionario_funciones = {
    0 : f1,
    1 : f2, 
    2 : f3,
    3 : f4,
}

posiciones_escenario_B = []
def comprobar_b(posiciones_escenario):
    i = -1
    posiciones_return: list = []
    for x, y in zip(posiciones_escenario[0], posiciones_escenario[1]):
        i += 1
        if y > f1(x) or y > f2(x) or y < f3(x) or y < f4(x):
            continue
        posiciones_return.append((i, x, y))
        print('x')
        
    return posiciones_return
    
posiciones_escenario_B = comprobar_b(posiciones_escenario_A)
            


# %% APARTADO J
err_transposed: np.array = np.copy(np.transpose(err_coords))
posiciones_escenario_B_error = []


'''
iteramos por todos los elemntos que están dentro de B y le aplicamos el error 
correspondiente de la lista de errores ya hecha en los anteriores apartados.
'''
for i in posiciones_escenario_B:
    posiciones_escenario_B_error.append(i[1:3] + err_transposed[i[0]])

repeticiones_dentro_recinto_B = 0
repeticiones_dentro_recinto_B = len(comprobar_b(posiciones_escenario_B_error))


#Se que está mal pero no encuentro el error.
print("La probabilidad de que un registro caiga dentro del recinto B es: ", repeticiones_dentro_recinto_B/experimentos)


# %% APARTADO K
muestras_X = list(posicion[1] for posicion in posiciones_escenario_B)
muestras_Y = list(posicion[2] for posicion in posiciones_escenario_B)
pintar_histograma_2D(list(muestras_X), list(muestras_Y), titulo="Posiciones B")
muestras_X_error = list(posicion[0] for posicion in posiciones_escenario_B_error )
muestras_Y_error = list(posicion[1] for posicion in posiciones_escenario_B_error)
pintar_histograma_2D(list(muestras_X_error), list(muestras_Y_error), titulo="Posiciones B con error")
'''
 Se observa como al aplicar el error hay valores que se salen del recinto donde 
 se define la región de B.
'''


# %% APARTADO L
pintar_histograma(list(muestras_X))
pintar_histograma(list(muestras_X_error))
'''
Se observa como al aplicar el error los valores se centran más en el centro,
lo que coincide con el hecho de que la función que nos genera los errores genera
errores cada vez más pequeños según nos vamos acercando al origen.
'''


# %% APARTADO M

'''
Hacerlo mismo que en el apartado j pero dividiendo entre la cantidad de puntos
que están dentro de B en vez de experimentos
'''


print(
    "La probabilidad de que un registro con error caiga dentro del recinto B sabiendo que la posición original "
    "se encuentra dentro es: ", repeticiones_dentro_recinto_B / len(posiciones_escenario_B))



# %% APARTADO N
media_x = ...
desv_x = ...
cov_xy = ...
recta = linregress(...)

plt.scatter(..., ..., label="Posiciones escenario B con error")
plt.plot(..., ..., color="r", label="Recta regresión Teórica")
plt.plot(..., ..., color="orange", label="Recta regresión Scipy")
plt.legend()
plt.show()