#%% TP 18

## Exo 1

import random as rd

# q1
def bernoulli(p):
    t = rd.random()
    if t<p :
        return 1
    else :
        return 0

# q2
def binom(n,p):
    X = 0
    for k in range(n):
        X += bernoulli(p)
    return X

# q3
def esperanceX(n,p,N): # à tester avec N=10**4
    s = 0
    for k in range(N):
        s += binom(n,p)
    return s/N

def varianceX(n,p,N):
    s = 0
    s_2 = 0
    for k in range(N):
        X = binom(n,p)
        s += X
        s_2 += X**2
    return s_2/N - (s/N)**2
#valeur exacte : E(X)=n*p=0.2*10=2 ; V(x)=np*(1-p)=10*0.2*0.8=1.6

# q4
def uniforme(a,b):
    return rd.randint(a,b)

# q5
def esperanceY(a,b,N):
    s = 0
    for k in range(N):
        s += uniforme(a,b)
    return s/N

def varianceY(a,b,N):
    s = 0
    s_2 = 0
    for k in range(N):
        Y = uniforme(a,b)
        s += Y
        s_2 += Y**2
    return s_2/N - (s/N)**2
#valeur exacte : E(Y)=(n+1)/2=(6+1)/2=3.5 ; V(Y)=(n**2-1)/12=(35/12)2.9

#%%
## EXO 2
#q1
def bX():
    return binom(10,2/5)
#q2
L = [bX() for k in range(10**4)]
#q3
repartition = [0]*11 # une liste avec uniquement des zéros
for x in L:
    repartition[x] += 1
for k in range(11):
    repartition[k] = repartition[k]/(10**4)


# repartition[i] est une approximation de P(X=i)
#q4
import matplotlib.pyplot as plt
absi = [k for k in range(11)]
plt.plot(absi,repartition)
plt.show()

#q5
# X_N ne suit pas une loi binomiale car les 10 individus sélectionnés sont distincts,
# il ne s'agit donc pas de compter le nombre de porteurs du gêne lors de la répétition de la même
# expérience, puisque la population (donc la proportion de porteurs du gêne) diffère

#q6
def X(N):
    popu = ['g','g','ng','ng','ng']*N
    choisis = rd.sample(popu,10)
    S = 0
    for x in choisis :
        if x=='g':
            S = S+1
    return S

#q7
N = 1000
Lbis = [X(N) for k in range(10**4)]
repartitionbis = [0]*11
for x in Lbis:
    repartitionbis[x] += 1
for k in range(11):
    repartitionbis[k] = repartitionbis[k]/(10**4)
plt.plot(absi,repartition)
plt.plot(absi,repartitionbis,'r')
plt.show()

# pour N petit les deux graphes sont assez éloignés, mais pour N grand il sont très proches.

#%%
## EXO 3
def loi1():
    t = rd.random()
    if t<=0.1:
        return -2
    elif t<=0.5: # 0.1+0.4
        return 3
    elif t<=0.7: # 0.1+0.4+0.2
        return 4
    else:
        return 10

# q2 : les p_i doivent être positifs et leur somme doit faire 1
def verif(P):
    for x in P:
        if x<0:
            return False
    return sum(P)==1

#q3
def prob_sum(P):
    n=len(P)
    P_sum=[0]*n
    for k in range(n):
        P_sum[k]=P_sum[k-1]+P[k]
    return P_sum
#q4

def indi(t,L):
    n=len(L)
    if t<L[0]:
        return 0
    else: 
        for k in range (1,n):
            if L[k-1]<=t<L[k]:
                return k
    if t>=L[n-1]:
        return n

V=[-2,3,4,10]
P=[0.1,0.4,0.3,0.2]
def simule (V,P):
    if verif(P):
        t=rd.random()
        P_s=prob_sum(P)
        k=indi(t,P_s)
        return V[k]
     

  
#%%    
## EXO 4
#q1
L=[1,2,3,4]
def indice(L,a):
    for k in range (len(L)):
        if L[k]==a:
            return k
#q2
def sim_X(n):
    A=[1,2,3]
    B=[]
    for k in range(n):
        t=rd.randint(1,3)
        if t in A:
            k=indice(A,t)
            A.pop(k)
            B.append(t)
        else :
            K=indice(B,t)
            A.append(t)
            B.append(K)
    return len(A)
#q3
a,b,c,d=0,0,0,0
N=10000
for k in range(N):
    X=sim_X(100000)
    if X==0:
        a=a+1
    if X==1:
        b=b+1
    if X==2:
        c=c+1
    if X==3:
        d=d+1
print(a/N,b/N,c/N,d/N)