#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Oct  8 11:12:05 2026

@author: legrand
"""

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




# ====================================================================
# Exercice 1
# ====================================================================
# 1)
# On procède en discrétisant l'espace, et en simulant des points avec une loi de Bernoulli
# Définition de la densité, notée f, qui prend en argument une paire/un array de deux flottants :
def f(x):
    x1,x2 = x 
    return np.exp( - np.abs(x1) - np.abs(x2) )

# Création du nuage de point, en discrétisant [0,2]^2 :
points = [] # Initialisation d'une liste vide
num = 200 # Nombre de points dans la discrétisation
tvals = np.linspace(0,2,num) # Intervalle [0,2] discrétisé. On utilisera la même discrétisation pour les deux coordonnées
delta = (2/(num-1))**2 # Volume d'un carré de la discrétisation de [0,2]^2
for x1 in tvals:
    for x2 in tvals:
        # On rajoute le point (x1,x2) au nuage avec probabilité min(f((x1,x2))*delta, 1).
        rand = st.uniform.rvs() # Simulation d'une variable uniforme (si on ne met pas de paramètre, elle est par défaut dans [0,1])
        if rand < f((x1,x2))*delta: # Vrai avec probabilité min(f((x1,x2))*delta, 1)
            points += [(x1,x2)]
# À la fin de l'exécution de ces boucles, la liste points contient des 2-uplets correspondant à une réalisation (discrétisée) d'une
# mesure ponctuelle de Poisson d'intensité f(x) dx sur [0,2]^2

# 2) Représentation graphique. On va stocker séparément les coordonées x1 et x2.
x1vals = []
x2vals = [] # On initialise deux listes vides
for x in points:
    x1,x2 = x
    x1vals += [x1]
    x2vals += [x2]
plt.scatter(x1vals,x2vals)
# Note: si vous exécutez le code, ne soyez pas surpris si vous obtenez un graphique vide: il y a une grande probabilité
# que la mesure ponctuelle soit nulle avec ce choix de paramètres
# Suggestion: pour une représentation graphique plus soignée, on peut écrire ceci plutôt:
plt.figure()
plt.scatter(x1vals,x2vals)
plt.axis('scaled')
plt.xlim(0,2)
plt.ylim(0,2)
plt.show()



# ====================================================================
# Exercice 2
# ====================================================================
# 1)
def Simu(lam,T,p):
    N = st.poisson.rvs(lam*T)
    x = st.uniform.rvs(0,T,size = N)
    rand = st.uniform.rvs(0,1,size = N)
    y = [0]*N
    for i in range(N):
        if rand[i]<p:
            y[i] = 1
    return np.array([x,y])
# Ce code génère une réalisation PPM homogène sur [0,T] d'intensité lam, puis ajoute indépendamment à chaque point
# une étiquette 1 avec probabilité p, et 0 avec probabilité 1-p
# Autrement dit, c'est une réalisation de processus temporel de Poisson à deux types

# 2)
# On fixe des valeurs arbitraires pour les paramètres, pour pouvoir faire la représentation graphique
lam = 2 
T = 10
p = .3
Points = Simu(lam,T,p) # On crée une réalisation du PPM. Elle est enregistrée en mémoire sous la forme d'un array à deux lignes
N = np.shape(Points)[1] # On extrait le nombre de colonnes, c'est à dire le nombre de points dans la réalisation
# Pour la représentation graphique, on va différentier les deux types de points en les stockants dans deux listes distinctes en fonction de leur type
Points0 = []
Points1 = []
for i in range(N):
    if Points[1,i]==0:
        Points0 += [Points[0,i]]
    else:
        Points1 += [Points[0,i]]
# On va maintenant faire la représentation graphique avec un plt.scatter en 1D. On extrait le nombre de points dans chaque liste
N0 = len(Points0)
N1 = len(Points1) # Equivalent à N1 = N - N0
Y0 = [0]*N0 # On crée des arrays vides pour les ordonnées
Y1 = [0]*N1
plt.figure()
plt.plot([0,T],[0,0], color='k', linewidth=.5) # On crée une ligne noire pour l'esthétique, mais ce n'est pas nécessaire
plt.scatter(Points0,Y0,color = 'b', marker = '|')
plt.scatter(Points1,Y1,color = 'r', marker = '|')
plt.show()


