#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 17 19:11:52 2022
@author: jlebovits
"""
from __future__ import division
import sys
import src.scripts.Mes_fctions.Mes_fctions_deterministes
from src.scripts.Mes_fctions.Mes_fctions_deterministes import *
import math
from random import uniform, Random, randrange, randint
#import numpy as np
#import numpy.random as npr
from sympy import *
from sympy.stats import *
# from sympy import Eq, simplify, S, Symbol, Rational, binomial, expand_func
from sympy.stats import P, E, variance, Die, Normal, DiscreteUniform, Bernoulli, sample, Binomial, density, Normal, sample_iter, given
from sympy import Piecewise, log, piecewise_fold
from sympy import S
from sympy.abc import x, y
import numpy as np
import numpy.random as npr
inf=float("inf")
[docs]
def probabilistes() :
chaine = "probabilistes Ok"
return chaine
# a = 2
# print(' a = ', a, '\n')
#############################################################################################################
#### Première partie ########
#############################################################################################################
#print(npr.rand()) # loi uniforme sur [0,1)
#npr.seed(seed=1) #Ici on décide de fixer la graine et donc tjs le même tirage!
### X = DiscreteUniform('X', symbols('g f'))
### toto = density(X).dict
### #
### ccwprint(toto)
### print('Tout va bien')
# X, Y = Die('X', 6), Die('Y', 6) # Define two six sided dice
# Z = Normal('Z', 0, 1) # Declare a Normal random variable with mean 0, std 1
# # #print('P(X>3) = ', P(X>3)) # Probability X is greater than 3
# E(X+Y) # Expectation of the sum of two dice
# # #print('E(X+Y) = ', E(X+Y))
# X = DiscreteUniform('X', symbols('a b c')) # equally likely over a, b, c
# # #print('density(X).dict = ', density(X).dict,'\n')
# Y = DiscreteUniform('Y', list(range(5))) # distribution over a range
# # #print('density(Y).dict = ', density(Y).dict,'\n')
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#
# l = list(range(5)) # distribution over a range
# ml = list(range(10,-11,-1)) #On va de 10 à -11+1 par pas de -1
# mlp = list(range(-10,11,1)) #On va de -10 à 10-1 par pas de 1
# print('list(range(5)) = ', l,'\n')
# print(' list(range(10,-11,-1)) = ', ml,'\n')
# print(' list(range(10,-11,-1)) = ', mlp,'\n')
# U = DiscreteUniform('U', list(range(-10,11,1)) ) # distribution over a range
# print('density(U).dict = ', density(U).dict,'\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
# W = DiscreteUniform('W', list(range(-9,10,1)) ) # distribution over a range
# #print('density(W).dict = ', density(W).dict,'\n')
# iteratorW = sample_iter(W, numsamples=3) #3 réalisations aléatoires d'une v.a. expr=X^2+3
# #où X suit une loi uniforme sur [-9,9] que les entiers
# ##########
# #print('list(iterator de W):', list(iteratorW),'\n')
# #print('list(iterator de W):', list(range(-9,10,1)),'\n')
# ##########
# T = DiscreteUniform("T", [1, 2, 3])
# print('density(T).dict = ', density(T).dict,'\n')
# #print('E(T) = ', E(T),'\n') # = {a: 1/3, b: 1/3, c: 1/3}
# # g=list(range(10, 16))
# # print('g = ', g,'\n')
# # Définition d'une variable aléatoire pouvant prendre n valeurs!!!!!
# n = Symbol('n', positive=True, integer=True)
# Dn = Die('Dn', n) # n sided Die
# density(Dn).dict # Density(DieDistribution(n))
# # # # density(Dn).dict.subs(n, 4).doit() # Si on veut fixer n=4 on aura ainsi
# # # # une v.a de loi uniforme sur l'intervalle entier [1,4]
# print('density(Dn).dict lorsque n=4 = ', density(Dn).dict.subs(n, 4).doit(),'\n')
# print('density(Dn).dict lorsque n=9, ', density(Dn).dict.subs(n, 9).doit(),'\n')
# Variable aléatoire de Bernouilli de paramètre p=3/4
# print('Soit Z v.a. Ber(p=3/4).')
# Z = Bernoulli('Z', S(3)/4) # 1-0 Bernoulli variable, probability = 3/4
# density(Z).dict
# print('La densité de dstribution de Z est:', density(Z).dict,'\n')
# Rho = Normal('Rho', 0, 1)
# expr = Rho*Rho + 3
# iterator = sample_iter(expr, numsamples=3) #réalisation aléatoires (3) d'une v.a. expr=X^2+3 où X suit une loi normale centrée réduite
# print('list(iterator):', list(iterator),'\n')
#############################################################################################################
#### Autre partie ########
#############################################################################################################
#############################################################################################################
#### Matrices à coefficients symboliques puis aléatoires ########
#############################################################################################################
#
# A=Matrix([[1,2,-2],[2,1,-2],[2,2,-3]])
# P=Matrix([[1,0,1],[1,1,1],[1,1,2]])
# C=A*P
# invP=P**-1
# E=Matrix([[1,1,0],[1,1,0],[0,8,9]])
# D=invP*A*P
# print('L"inverse de la matrice P est P^-1=' , invP,'\n')
# print('D=P^-1 A P=' , D,'\n')
# a = Symbol('a')
# b = Symbol('b')
# c = Symbol('c')
#W = DiscreteUniform('W', list(range(-9,10,1)) ) # distribution over a range
# aprime = list(sample_iter(W, numsamples=11))
# print(' aprime = ' , aprime,'\n')
# #print(' type(aprime) = ' , type(aprime),'\n')
# Aalea = Matrix([[a,2,-2],[2,b,-2],[2,2,c]])
# print('Aalea = ' , Aalea,'\n')
# Aalea = Aalea.subs(a, 4)
# #Aalea = Aalea.subs(a, aprime[0])
# print('Aalea = ' , Aalea,'\n')
# a= sample_iter(W, numsamples=1)
# b= sample_iter(W, numsamples=1)
# c= sample_iter(W, numsamples=1)
# # print('a= ' , a,'\n')
# ALP = Matrix([[1, -1], [-1, 1]])
# #p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1))
# iteratorW = sample_iter(W, numsamples=3) #réalisation aléatoires (3) d'une v.a. expr=X^2+3 où X suit une loi normale centrée réduite
# L = list(iteratorW) # une fois printé, list(iteratorW), se vide. Et il n'y a plus rien du tout.
# print('list(iterator de W):', list(iteratorW),'\n')
# t= list(iteratorW)
# l = len(t)
# ## Dans ce qui suit, tout sera vide, car on a déjà appelé list(iteratorW) dans le print
# print('type(t) =', type(t), '\n')
# print('len(t) =', t, '\n')
# ## Alors que, ci-dessous tout fonctionne
# #u = list(iteratorW)[0]
# print('type(L) =', type(L), '\n')
# print('len(L) =', L, '\n')
# print('len(L) =', L[1], '\n')
#############################################################################################################
#### Autre partie ########
#############################################################################################################
from sympy import Matrix, ImmutableMatrix
# M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# print('M=', M,'\n')
# M[0, 0] = 0
# print('M=', M,'\n')
# IM = ImmutableMatrix(M)
# # IM[1, 1] = 5
# # print('IM=', IM,'\n')
from sympy.matrices import randMatrix
# T=randMatrix(3)
# print('T=', T,'\n')
# # T=randMatrix(r, c=None, min=0, max=99, seed=None, symmetric=False, percent=100)
# T=randMatrix(3, c=None, min=-9, max=9, seed=None, symmetric=False, percent=50)
# print('T=', T,'\n')
# Tseed1=randMatrix(3, c=None, min=-9, max=9, seed=1, symmetric=False, percent=50)
# # La graine étant fixé la matrice ne changera jamais. Elle a été tirée au sort une bonne fois pour toutes....
# print('Tseed1=', Tseed1,'\n')
# T=randMatrix(3, c=None, min=-9, max=9, seed=1, symmetric=False, percent=50)
# print('T=', T,'\n')
# x, y, z, t = symbols('x y z t')
# sole = solve([x - 3, y - 1], dict=True)
# print('type(sole)=', type(sole),'\n')
# print('sole=', sole,'\n')
# print('type(sole[0])=', type(sole[0]),'\n')
# print('sole[0]=', sole[0],'\n')
# sol = latex(solve([x - 3, y - 1], dict=True))
# print('sol=', sol,'\n')
# soles = solve([x - 3 + 2*y, y - x - 1], dict=True)
# print('soles=', soles,'\n')
# solest = solve([x - 3 + 2*y, x - 3 + 2*y - 1], dict=True)
# print('solest =', solest,'\n')
# solestes = solve([x - 3 + 2*y, x - 3 + 2*y], dict=True)
# print('solestes =', solestes,'\n')
#Uliste=[]
# H = DiscreteUniform('H', list(range(1,25,1)) ) # distribution over a range
# #print('density(W).dict = ', density(W).dict,'\n')
# iteratorH = sample_iter(H, numsamples=3) #réalisation aléatoires (3) d'une v.a. expr=X^2+3 où X suit une loi normale centrée réduite
# LH = list(iteratorH)
# print('list(iterator de H):', list(iteratorH),'\n')
# G = DiscreteUniform('G', list(range(1,25,1)) ) # distribution over a range
# iteratorG = sample_iter(G, numsamples=25)
#LG = list(iteratorG)
# #print('list(iterator de G):', list(iteratorG),'\n')
# def my_filter(iterable):
# result=[]
# for i in iterable:
# result.append(i)
# if i==5:
# continue
# yield result
# result=[]
# idx = iter(range(0, 10))
# for i in my_filter(idx):
# print(i)
# Ulist=[]
# it = iter(iteratorG)
# for i in it:
# Ulist.append(i)
# print('i=', i)
# # do something with it
# print('Ulist', Ulist)
#a=Ulist[0]
#x = Symbol("x")
# d=(x-2)**2
# e=latex(d)
# f=latex(2**2)
# print('x', d)
# print('x', e)
# print('x', f)
#l=max(2,4)
#del e, l,
#print('max(2,4)=',e)
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
# pdfX = {10: Rational(1, 4), 11: Rational(1, 2), 12: Rational(1, 4)}
# X = FiniteRV('X', pdfX)
# pdfY = {3: Rational(1, 8), 9: Rational(1, 6), 11: Rational(3, 8), 14: Rational(1, 4), 18: Rational(1, 12)}
# Y= FiniteRV('Y', pdfY)
# alpha = P(Eq(X,10))
# # print('P(X=10)=', alpha)
#############################################################################################################
#### Autre partie ########
#############################################################################################################
[docs]
def randnbres(n,p):
"""Retourne une liste de n rationnels, tirés aléatoirement entre 0 et p, mais dont la somme vaut 1
"""
l=[]
A=0
m=[]
W = DiscreteUniform('W', list(range(0,p,1)) ) # distribution over a range
#print('density(W).dict = ', density(W).dict,'\n')
iteratorW = sample_iter(W, numsamples=n) #réalisation aléatoires (3) d'une v.a. expr=X^2+3 où X suit une loi normale centrée réduite
#print('list(iterator de W):', list(iteratorW),'\n')
#print('type(iteratorW):', type(iteratorW),'\n')
it = iter(iteratorW)
for i in it:
l.append(i)
A=A+i
for i in list(range(0,n,1)):
#print('l[i]=', l[i])
a=l[i]
c=Rational(a,A)
m.append(c)
#print('m=', m)
return m
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# print('randnbres(4)=', randnbres(4,40)[1])
# d=float(randnbres(4,40)[1])
# print('d=', d)
# del d
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randnbresstrictpositifs(n,k,p):
"""Retourne une liste de n entiers, tirés aléatoirement entre k et p
"""
l=[]
A=0
m=[]
W = DiscreteUniform('W', list(range(k,p,1)) ) # distribution over a range
#print('density(W).dict = ', density(W).dict,'\n')
iteratorW = sample_iter(W, numsamples=n) #réalisation aléatoires (3) d'une v.a. expr=X^2+3 où X suit une loi normale centrée réduite
#print('list(iterator de W):', list(iteratorW),'\n')
it = iter(iteratorW)
for i in it:
# if L[i] not in Lprime:
#Lfinale.append(L[i])
l.append(i)
#A=A+i
for i in list(range(0,n,1)):
#print('l[i]=', l[i])
a=l[i]
m.append(a)
#print('m=', m)
return m
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#print('randnbresstrictpositifs(n,p) = ', randnbresstrictpositifs(4,1,5))
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def randnbres_in_L(p,L,Lprime=[]):
"""
EN: Returns a list composed of p elements of the initial list L,
taken at random (uniformly) and which do not belng to Lprime. By default, Lprime is empty.
#
FR: Retourne une liste composée de p élements de la liste initiale L, pris au hasard (uniformément)
et qui ne sont pas dans la liste Lprime. Par défaut, Lprime est vide.
"""
Lfinale = []
l=[]
A=0
m=[]
W = DiscreteUniform('W', list(range(0,len(L),1)))
# distribution over a range
iteratorW = sample_iter(W, numsamples=p)
#réalisation aléatoires de p réalisations de W
#print('list(iterator de W):', list(iteratorW),'\n')
it = iter(iteratorW)
for i in it:
if L[i] not in Lprime:
Lfinale.append(L[i])
#print('Lfinale=', Lfinale)
return Lfinale
#############################################################################################################
#### Début des essais ########
#############################################################################################################
p = 6
L = list(range(-9,10,1))
# print('L =', L, '\n')
L_tau = list(range(-9,10,1))
A = randnbres_in_L(p,L)
# print('A =', A, '\n')
#Lprime = [-9,-8,-7,-6-5,-4,-3,-2,0,3,4,5,6,7,8,9]
Lprime = [0]
B = randnbres_in_L(p,L,Lprime)
# print('B =', B, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Autre Fction ########
#############################################################################################################
[docs]
def Multiple_of_p_in_L(p,L):
"""
Créer, à partir de la liste L, une liste ne contenant que les élements
de L qui sont divisibles par p
"""
Lfinale = []
for i in range(0,len(L),1):
if L[i]%p == 0:
Lfinale.append(L[i])
else:
toto = 2
return Lfinale
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# L = []
# for i in range(0,101,1):
# L.append(i)
#print('L =', L, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#print('Multiple_of_p_in_L(',5,'L) =', Multiple_of_p_in_L(5,L), '\n')
# print('randelementlist(p,L)=', rand_p_elementlist(5,L), '\n')
# print('rand_p_elementlist(5,Multiple_of_p_in_L(5,L))=', rand_p_elementlist(5,Multiple_of_p_in_L(5,L)), '\n')
#############################################################################################################
#############################################################################################################
[docs]
def rand_p_proba_a_partir_list(p,L):
"""Retourne une liste composée de p élements de
la liste initiale L, pris au hasard (uniformément)
"""
Lfinale = []
l=[]
A=0
m=[]
W = DiscreteUniform('W', list(range(0,len(L),1)))
# distribution over a range
iteratorW = sample_iter(W, numsamples=p)
#réalisation aléatoires de p réalisations de W
#print('list(iterator de W):', list(iteratorW),'\n')
it = iter(iteratorW)
for i in it:
Lfinale.append(L[i])
#print('Lfinale=', Lfinale)
return Lfinale
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# L = []
# for i in range(0,101,1):
# L.append(i)
#print('L =', L, '\n')
#print('rand_p_proba_a_partir_list(3,L)=', rand_p_proba_a_partir_list(6,L), '\n')
# d=float(randnbres(4,40)[1])
# print('d=', d)
# del d
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Autre Fction ########
#############################################################################################################
[docs]
def Test_proba_pris_in_list(L, ind, p, nber_max, Lpartielle):
"""teste si le nbre L[ind] peut-être choisi comme valeur d'une proba
sachant que l'on doit avoir au total, à la fin, p proba tirées dans L,
la somme totale ne doit pas dépasser nber_max (car on renormalisera
en divisant tous les poids par nber_max à la fin)
et que pour l'instant on a déjà tireés len(Lpartielle) nbres pour les poids
précédents. La somme de tous les poids devra valoir nber_max.
Cette fction renvoie 1 si L[ind] peut-être acceptée comme poids d'une proba et
0 sinon. EN fait on teste deux choses:
- la somme des poids précédents + L[ind] ne dépasse pas nber_max
- la somme des poids précédents + L[ind] + (q-N_partiel)*L[0]
ne dépasse pas nber_max (i.e. la somme de tous les poids précédemment
choisis + le poids L[ind] + tous les poids futurs
(en prenant le min possible pour chacun) ne dépasse pas nber_max
"""
Sum_par = sum(Lpartielle)
N_par = len(Lpartielle)
q = p - N_par-1 # nbre de poids restant à choisir
r = Sum_par + L[ind] + q*L[0]
if r > nber_max:
Decision = 0
else:
Decision = 1
return Decision
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# L0 = []
# for i in range(0,101,1):
# L0.append(i)
# print('L0 =', L0, '\n')
# L1 = Multiple_of_p_in_L(5,L)
# print('Multiple_of_p_in_L(',5,'L)=', L1, '\n')
# Lpartielle = [10, 15, 30, 25]
# nber_max = 100
# ind = 1
# print('L1[',ind,'] =', L1[ind], '\n')
#ind = 10
#ind = 15
#ind = 20
# U = Test_proba_pris_in_list(L1, ind, 5, 100, Lpartielle)
# print('Test_proba_pris_in_list(L1, 16, 5, 100, Lpartielle) =', U, '\n')
# for i in range(0,len(L1),1):
# ind = i
# print('L1[',ind,'] =', L1[ind], '\n')
# U = Test_proba_pris_in_list(L1, ind, 5, 100, Lpartielle)
# print('Test_proba_pris_in_list(L1, 16, 5, 100, Lpartielle) =', U, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Autre Fction ########
#############################################################################################################
[docs]
def Poids_d_une_proba_in_list(Linit, p, nber_max):
"""Renvoie une liste de poids, pris dans la liste Linit
dont la somme vaut nber_max, pour autant que ce soit possible
"""
Linit
W = DiscreteUniform('W', list(range(0,len(Linit),1)) )
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# L0 = []
# for i in range(0,101,1):
# L0.append(i)
# print('L0 =', L0, '\n')
# L1 = Multiple_of_p_in_L(5,L)
# print('Multiple_of_p_in_L(',5,'L)=', L1, '\n')
# Lpartielle = [10, 15, 30, 25]
# nber_max = 100
# ind = 1
# print('L1[',ind,'] =', L1[ind], '\n')
#ind = 10
#ind = 15
#ind = 20
# U = Test_proba_pris_in_list(L1, ind, 5, 100, Lpartielle)
# print('Test_proba_pris_in_list(L1, 16, 5, 100, Lpartielle) =', U, '\n')
# for i in range(0,len(L1),1):
# ind = i
# print('L1[',ind,'] =', L1[ind], '\n')
# U = Test_proba_pris_in_list(L1, ind, 5, 100, Lpartielle)
# print('Test_proba_pris_in_list(L1, 16, 5, 100, Lpartielle) =', U, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Autre Fction
#############################################################################################################
[docs]
def nor(x):
"""Densité de la loi N(0,1)
"""
b=(sqrt(2)*exp(-x**2/2)/(2*sqrt(pi))).evalf()
return b;
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# print('nor(1)=', nor(1), "\n")
# pdfnew = (nor(x)+nor(-x))*(1-indicatfunctionouvdroite(0,x)) # Normal distribution
# Y = ContinuousRV(x, pdfnew)
# print('On a :', 'pdfnew=', pdfnew, "\n")
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Autre Partie
#############################################################################################################
#############################################################################################################
#### Probabilités conditionnelles ########
#############################################################################################################
# pmfa = {0: Rational(1, 10), 1: Rational(3, 20), 2: Rational(3, 10), 3: Rational(1, 4), 4: Rational(1, 5)}
# X= FiniteRV('X', pmfa)
# Z = given(X, X <= 1)
# #print('P(Z=1)=', P(Eq(Z,1)))
# Y=[0,1]
# Y[0]= given(X, X <= 2)
# U= given(X, X <= 2)
# #print('P(U=1)=', P(Eq(U,1)))
# t=density(U).dict
# #print('density(U).dict=', t)
# #print('P(X=1)=', P(Eq(U,1)))
# L = Die('L', 6)
# #print('E(2*L, L > 3)=', E(2*L, L > 3)) # Expectation of X given that it is above 3
# del L, t, U, Y, X
# Variable aléatoire de Bernouilli de paramètre p=3/4
# print('Soit Z v.a. Ber(p=3/4).')
# Z = Bernoulli('Z', S(3)/4) # 1-0 Bernoulli variable, probability = 3/4
# density(Z).dict
# print('La densité de dstribution de Z est:', density(Z).dict,'\n')
# p = Symbol('p')
# B = Bernoulli('B', p) # 1-0 Bernoulli variable, probability = 3/4
# print('B(Omega)=', density(B).dict)
#p=1/100
#density(B).subs(p, 1/100)
# density(B).dict.subs(p, 1/00).doit()
# print('B(Omega)=', density(B).dict)
# n = Symbol('n', positive=True, integer=True)
# p = Symbol('p', positive=True)
# T = Binomial('T', n, S.Half) # n "coin flips"
# density(T).dict
# density(BinomialDistribution(n, 1/2, 1, 0))
# # density(X).dict.subs(n, 4).doit()
# # {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
del x
[docs]
def AbsRV(Q): #C'est |Q| avec Q r.v.
x = Symbol("x", real=True)
def abs(t):
b=Piecewise((1, x >= 0), (0, x < 0))
c=b.subs(x,t) #i.e. c=i1_[0,\infty)(t)
return c;
b=Q*abs(Q)-Q*abs(-Q)
return b;
# pmfrho = {0: Rational(1, 10), -1: Rational(3, 20), 1: Rational(3, 10), 2: Rational(1, 4), -2: Rational(1, 5)}
# W= FiniteRV('W', pmfrho)
# print('density(W).dict = ',density(W).dict, '\n')
# Wprime = AbsRV(W)
# print('density(Wprime).dict = ',density(Wprime).dict, '\n')
[docs]
def AbsRV_bis(Q): #C'est |Q| avec Q r.v.
x = Symbol("x", real=True)
def abs(t):
b=indi_l_r_symb("[",0,inf,"]")(x)
#b=indfction_v_1("[",0,inf,"]",x)
# les deux b sont possibles et donnent, bien sûr le même résultat.
c=b.subs(x,t) #i.e. c=i1_[0,\infty)(t)
return c;
b=Q*abs(Q)-Q*abs(-Q)
return b;
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# pmfrho = {0: Rational(1, 10), -1: Rational(3, 20), 1: Rational(3, 10), 2: Rational(1, 4), -2: Rational(1, 5)}
# W= FiniteRV('W', pmfrho)
# print('density(W).dict = ',density(W).dict, '\n')
# Wprime = AbsRV(W)
# print('density(Wprime).dict = ',density(Wprime).dict, '\n')
# print('P(Eq(W,0)) = ', P(Eq(W,0)))
# print('P(Eq(W,1)) = ', P(Eq(W,1)))
# print('P(Eq(W,2)) = ', P(Eq(W,2)))
# print('P(Eq(W,-1)) = ', P(Eq(W,-1)))
# print('P(Eq(W,-2)) = ', P(Eq(W,-2)))
# print('E(W)', E(W))
# print('P(Eq(Wprime,0)) = ', P(Eq(Wprime,0)))
# print('P(Eq(Wprime,1)) = ', P(Eq(Wprime,1)))
# print('P(Eq(Wprime,2)) = ', P(Eq(Wprime,2)))
# print('P(Eq(Wprime,-1)) = ', P(Eq(Wprime,-1)))
# print('P(Eq(Wprime,-2)) = ', P(Eq(Wprime,-2)))
# print('E(Wprime)=', E(Wprime))
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#############################################################################################################
#### Transformée de variables aléatoires
#############################################################################################################
#############################################################################################################
# On définit ainsi i1_{U <= V}, où U et V sont deux variables aléatoires
# a = Symbol("a", positive=True)
# U = Uniform("U", 0, a)
# V = Uniform("V", 0, a)
# #print('t(a)=', t(a))
# t=density(U)
# s=density(V)
# Z=indi_l_r_symb("[",0,inf,")")(U-V)
# print('Z =', Z, '\n')
# print('type(Z) =', type(Z), '\n')
#############################################################################################################
#### Début des fctions importantes ########
#############################################################################################################
# def AbsRV_bis(Q): #C'est |Q| avec Q r.v.
# x = Symbol("x", real=True)
# def abs(t):
# b=indi_l_r_symb("[",0,inf,"]")(x)
# #b=indfction_v_1("[",0,inf,"]",x)
# # les deux b sont possibles et donnent, bien sûr le même résultat.
# c=b.subs(x,t) #i.e. c=i1_[0,\infty)(t)
# return c;
# b=Q*abs(Q)-Q*abs(-Q)
# return b;
[docs]
def fctionofafiniteRV(f,X):
"""Pour une va finie donnée, notée X, et une fction notée f, on définit la v.a. finie f(X)
et donc un nom (de la classe sympy.stats.rv.RandomSymbol)
et un dictionnaire (de la classe dict).
Le nom est:
f_of_X (où f et X sont remplacées par les vrais noms de la v.a. X et de la fction f),
accessible via fctionofafiniteRV(f,X,pdfX)
dont le dictionnaire est accessible via density(fctionofafiniteRV(f,X)).dict
"""
stX=str(X)
stf=str(f)
dico={}
for key, value in density(X).dict.items():
newkey=f(key)
if newkey in dico:
dico[newkey]=dico[newkey]+value
else:
dico[newkey]=value
A=0
for key in dico.keys():
A=A+dico[key]
if A == 1:
Name=stf+'_of_'+stX
Y= FiniteRV(Name, dico)
else:
Name='the sum of probabilities'
Y= 'the sum of probabilities does note equal 1'
return Y#, dico#, Nom
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# pdfX = {0: Rational(1, 8), 1: Rational(1, 2), 2: Rational(1, 4), 3: Rational(1, 8)} #keys:
# X= FiniteRV('X', pdfX)
# Sin_X=fctionofafiniteRV(sin,X)
# print('E[X]=',E(X),'\n')
# Pow_2_X=fctionofafiniteRV(powers(2),X)
# print('Pow_2_X',Pow_2_X,'type(Pow_2_X=',type(Pow_2_X),'\n')
#Rho=fctionofafiniteRV(indi_l_r_symb("[",1,3,"]",X)
# Rho = fctionofafiniteRV(indi_l_r_symb("[",1,3,"]"),X)
# print('Rho',Rho,'\n')
# print('E[Rho]=',E(Rho),'\n')
# =============================================================================
# # def k(l,a,b,r):
# # """Définition de la fction x-->x i1_{a,b}(x) """
# # """Cette fction est déjà définie dans le fichier Mes_fctions_deteerministes"""
# # def rere_l_a_b_r(x):
# # e=x*indi_l_r_symb(l,a,b,r)(x)
# # return e;
#
# # return rere_l_a_b_r
#
# =============================================================================
## def h_l_r(l,a,b,r):
## """Pour tout a et b donnés, renvoie la fction x\mpasto x.i1_{a,b}(x), où la nature
## des bornes (ouvertes ou fermées) doivent être précisées"""
## def g_l_a_b_r(x):
## f=x*indfction_v_2(l,a,b,r,x)
## return f;
## return g_l_a_b_r;
# Rhobis = fctionofafiniteRV(k("[",1,3,"]"),X)
# print('Rhobis',Rhobis,'\n')
# print('E[Rhobis]=',E(Rhobis),'\n')
# print('Var(Rhobis)=',variance(Rhobis),'\n')
# Rhoter = fctionofafiniteRV(h_l_r("[",1,3,"]"),X)
# print('Rhoter',Rhoter,'\n')
# print('E[Rhoter]=',E(Rhoter),'\n')
# print('Var(Rhoter)=',variance(Rhoter),'\n')
# Tau=fctionofafiniteRV(powers(2),X)
# print('Tau',Tau,'type(Tau)=',type(Tau),'\n')
# print('E[Tau]=',E(Tau),'\n')
# Taucarre=fctionofafiniteRV(powers(4),X)
# print('E[Taucarre]=',E(Taucarre),'\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
##################################################################################################
[docs]
def ExpandFiniteRV(f,X,name_of_f_of_X_for_LaTeX,ponctu):
"""" pr LaTeX Met dans un align la distribution de la v.a. finie X """""
case=1
U='bP'
# Ponctuation .,
ponctu=str(ponctu)
if ponctu == 'point':
terminaison = '.'
elif ponctu == 'virg':
terminaison = ','
else:
terminaison = ''
T=name_of_f_of_X_for_LaTeX
sentinit ="\\"'begin{align*}\n'
#sentfin_intermediaire ='\n'+"\\"'end{align*}\n'
sentfin ='\n'+"\\"'end{align*}\n'
# Loi de f(X):
alpha = fctionofafiniteRV(f,X)
"""Donc on a alpha= RV dont le nom est f_of_X """
# Répartition des valeurs possibles de f(X) par 4:
listedesprobade_f_de_X=[] #poids
listedesvaleurspossiblesde_f_de_X=[] #valeurs possibles
for key, value in density(alpha).dict.items():
listedesprobade_f_de_X.append(value)
listedesvaleurspossiblesde_f_de_X.append(key)
#print('density(alpha).dict=',density(alpha).dict)
n=len(density(alpha).dict)
quotient=n//4 #quotient = dividende // diviseur
reste=n%4 #reste = dividende % diviseur
#print('n =', n, 'quotient= ',quotient, 'et r vaut:', reste)
listefinale=[]
phrase=[]
phrasepourles_r_derniers=[]
for p in range(0,quotient,1):
#print('p=',p)# Donc on va de 0 à 4(q-1)+3=4q-1 alors que n=4q+r. il y aura donc encore r éléments à traiter
phraseprlesquatuors=[]
listeintermediaire=[]
for j in range(0,4,1):
#print('j=',j)
theta=4*p+j
#print('theta=',theta)
s=str(listedesvaleurspossiblesde_f_de_X[theta])
r=str(listedesprobade_f_de_X[theta])
if j == 3:#
if (4*p+j == n-1):
u='&'+"\\"+U+'['+T+'='+s+')='+r+terminaison+'&'
phraseprlesquatuors.append(u)
else:
u='&'+"\\"+U+'('+T+'='+s+')='+r+','+'&'
phraseprlesquatuors.append(u)
else:
#print('on nest pas entré dans le cas i=3')
#if case == 1:
#u='&'+"\\"+U+'('+T+'='+s+')='+r+','+'&\n'
u='&'+"\\"+U+'('+T+'='+s+')='+r+','+'&\n'
# elif case == 2:
# u='&'+"\\"+U+'['+T+']='+r+','+'&\n'
#print('u la =',u)
phraseprlesquatuors.append(u)
debut=[sentinit]
fin = [sentfin]
listeintermediaire=debut+phraseprlesquatuors+fin
#print('listeintermediaire=',listeintermediaire)
#listefinale.append()
L=len(listeintermediaire)
for i in range(L):
print(listeintermediaire[i], end='')
# A partir de là il ne reste plus que r éléments à traiter
if reste==0:
c=0
elif reste==1: #il n'y a donc qu'un seul nbre isolé
#print('reste=',reste)
s=str(listedesvaleurspossiblesde_f_de_X[4*quotient+reste-1])
r=str(listedesprobade_f_de_X[4*quotient+reste-1])
u='&'+"\\"+U+'['+T+'='+s+')='+r+terminaison+'&'
phrasepourles_r_derniers.append(u)
debut=[sentinit]
fin = [sentfin]
liste_des_r_derniers=debut+phrasepourles_r_derniers+fin
Lr=len(liste_des_r_derniers)
for i in range(Lr):
print(liste_des_r_derniers[i], end='')
elif reste==2: #il n'y a donc que deux nbres isolés
cpteur=0
for i in (0,reste-1,1):
if cpteur == reste-1:
break
else:
m=4*quotient+i
#print('m=',m)
s=str(listedesvaleurspossiblesde_f_de_X[m])
r=str(listedesprobade_f_de_X[m])
u='&'+"\\"+U+'('+T+'='+s+')='+r+','+'& \n'
#u='&'+"\\"+U+'('+T+'='+s+')='+r+','+'& \n'
#print('u=',u)
phrasepourles_r_derniers.append(u)
cpteur=cpteur+1
m=4*quotient+reste-1
s=str(listedesvaleurspossiblesde_f_de_X[m])
r=str(listedesprobade_f_de_X[m])
u='&'+"\\"+U+'['+T+'='+s+')='+r+terminaison+'&'
phrasepourles_r_derniers.append(u)
debut=[sentinit]
fin = [sentfin]
liste_des_r_derniers=debut+phrasepourles_r_derniers+fin
Lr=len(liste_des_r_derniers)
for i in range(Lr):
print(liste_des_r_derniers[i], end='')
elif reste==3: #il n'y a donc que trois nbres isolés
cpteur=0
for i in (0,reste-2,1):
if cpteur == reste-1:
break
else:
m=4*quotient+i
#print('m=',m)
s=str(listedesvaleurspossiblesde_f_de_X[m])
r=str(listedesprobade_f_de_X[m])
u='&'+"\\"+U+'('+T+'='+s+')='+r+','+'& \n'
#u='&'+"\\"+U+'('+T+'='+s+')='+r+','+'& \n'
#print('u=',u)
phrasepourles_r_derniers.append(u)
cpteur=cpteur+1
m=4*quotient+reste-1
s=str(listedesvaleurspossiblesde_f_de_X[m])
r=str(listedesprobade_f_de_X[m])
u='&'+"\\"+U+'['+T+'='+s+')='+r+terminaison+'&'
phrasepourles_r_derniers.append(u)
debut=[sentinit]
fin = [sentfin]
liste_des_r_derniers=debut+phrasepourles_r_derniers+fin
Lr=len(liste_des_r_derniers)
for i in range(Lr):
print(liste_des_r_derniers[i], end='')
else:
e=3
#############################################################################################################
#### Début des essais ########
#############################################################################################################
pdfX = {10: Rational(1, 4), 11: Rational(1, 2), 12: Rational(1, 4)}
X= FiniteRV('X', pdfX)
# pdfY = {10: Rational(1, 8), 11: Rational(2, 8), 12: Rational(1, 8), 13: Rational(1, 8), 14: Rational(3, 8)}
# Y= FiniteRV('Y', pdfY)
# pdfM = {2: Rational(1, 4), 9: Rational(1, 2), 11: Rational(1, 8), 11: Rational(1, 8)}
# Q= FiniteRV('Q', pdfM)
# pdfR = {0: Rational(1, 6), 9: Rational(1, 6), 11: Rational(1, 6), 12: Rational(1, 6), 14: Rational(1, 6), 15: Rational(1, 6)}
# R= FiniteRV('R', pdfR)
# pdfS = {1: Rational(1, 7), 2: Rational(1, 7), 3: Rational(1, 7), 4: Rational(1, 7), 5: Rational(1, 7), 6: Rational(1, 7), 7: Rational(1, 7)}
# S= FiniteRV('S', pdfS)
# pdfK = {1: Rational(1, 11), 2: Rational(1, 11), 3: Rational(1, 11), 4: Rational(1, 11), 5: Rational(1, 11), 6: Rational(1, 11), 7: Rational(1, 11), 8: Rational(1, 11), 9: Rational(1, 11), 10: Rational(1, 11), 11: Rational(1, 11)}
# K= FiniteRV('K', pdfK)
# pdfT = {1: Rational(1, 13), 2: Rational(1, 13), 3: Rational(1, 13), 4: Rational(1, 13), 5: Rational(1, 13), 6: Rational(1, 13), 7: Rational(1, 13), 8: Rational(1, 13), 9: Rational(1, 13), 10: Rational(1, 13), 11: Rational(1, 13), 12: Rational(1, 13), 13: Rational(1, 13)}
# T= FiniteRV('T', pdfT)
# pdfL = {-1: Rational(1, 2), 1: Rational(1, 2)}
# L= FiniteRV('L', pdfL)
# pdfN = {-1: Rational(1, 3), 1: Rational(1, 3), -2: Rational(1, 6), 2: Rational(1, 6)}
# N= FiniteRV('N', pdfN)
# m='ExpandDefde(X,\"virg\")'
#tau=ExpandFiniteRV(Id,X,'X','virg')
# # tau=ExpandFiniteRV(Id,Y,'Y','virg')
# # tau=ExpandFiniteRV(Id,Q,'Q','virg')
# # tau=ExpandFiniteRV(Id,R,'R','virg')
# #tau=ExpandFiniteRV(Id,S,'S','virg')
# tau=ExpandFiniteRV(Id,T,'T','point')
#tau=ExpandFiniteRV(Id,Q,'Q','point')
#tau=ExpandFiniteRV(Id,R,'R','point')
# tau=ExpandFiniteRV(Id,S,'S','point')
# #tau=ExpandFiniteRV(Id,Y,'Y','point')
#tau=ExpandFiniteRV(Id,K,'K','point')
# Rhoter = fctionofafiniteRV(h_l_r("[",1,3,"]"),X)
# tau=ExpandFiniteRV(Id,Rhoter,'X\ i1_{[1,3]}(X)','virg')
# Rhoquarte = fctionofafiniteRV(h_l_r("[",1,3,"]"),X)
# tau=ExpandFiniteRV(h_l_r("[",1,3,"]"),Rhoquarte,'X\ i1_{[1,3]}(X)','virg')
#tau=ExpandFiniteRV(powers(2),R,'R^2','virg')
# tau=ExpandFiniteRV(powers(2),X,'X^2','virg')
# a=9
# b=11
# m='\i1_{['+str(a)+","+str(b)+']}(X)'
#tau=ExpandFiniteRV(Indicatfction(a,b),X,m,'virg')
# tau=ExpandFiniteRV(powers(2),L,'L^2','virg')
# tau=ExpandFiniteRV(powers(2),N,'N^2','point')
# #m='ExpandDefde(X,\"virg\")'
# # tau=ExpandFiniteRV(Id,Z,'Z','virg')
# tau=ExpandFiniteRV(powers(2),Z,'Z^2','virg')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def ExpandExpFiniteRV(f,X,name_of_the_original_rv,latex_name_of_f_of_alpha,name_funct_and_name_rv,ponctu):
"""" Met dans un align le calcul de l'espérance de f(X) i.e. E[f(X)],
où X une v.a. finie. """""
# Ponctuation .,
ponctu = str(ponctu)
if ponctu == 'point':
terminaison = '.'
elif ponctu == 'virg':
terminaison = ','
else:
terminaison = ''
# Loi de f(X):
alpha = fctionofafiniteRV(f,X)
"""Donc on a alpha = RV dont le nom est f_of_X
et density(alpha).dict = dico de f_of_X """
# Répartition des valeurs possibles de f(X) par 5:
listedesprobade_f_de_X=[] #poids
listedesvaleurspossiblesde_f_de_X=[] #valeurs possibles
a=0
for key, value in density(alpha).dict.items():
listedesprobade_f_de_X.append(value)
listedesvaleurspossiblesde_f_de_X.append(key)
a=a+key*value #C'est le résulat final E[f(X)]
result=str(a)#toto'#str(result)
#print('alpha=',density(alpha).dict)
gamma=str(latex_name_of_f_of_alpha)
sentinita ="\\"'begin{align*}\n'
sentinitb="\\"'bE['+name_funct_and_name_rv+']&=\sum_{'+"\\"+'alpha\in'+"\\"+str(name_of_the_original_rv)+'(\Omega)}'+latex_name_of_f_of_alpha+"\\dot"+''+"\\"+'bP('+name_of_the_original_rv+'='+"\\"+'alpha)'+"\\"+"\\"+'\n'#+'&='
sentinit=sentinita+sentinitb
#sentfin_intermediaire ='\n'+"\\"'end{align*}\n'
sentfina ='\n'+'&='+result+'.\n'
sentfinb ="\\"'end{align*}\n'
sentfin=sentfina+sentfinb
n=len(density(alpha).dict)
quotient=n//5 #quotient = dividende // diviseur
reste=n%5 #reste = dividende % diviseur
#print('n =', n, 'quotient= ',quotient, 'et reste vaut:', reste)
phrase=[]
Q=quotient #nbre d'itirérations
while Q != 0:
#print('On est rentré dans la boucle')
for p in range(0,quotient,1):
gamma=5*p
theta=['a','a','a','a','a']
sentence_the_quintets=[]
for j in range(0,5,1):
theta[j]=str(listedesvaleurspossiblesde_f_de_X[gamma+j])+"\\dot "+str(listedesprobade_f_de_X[gamma+j])+"\\"+' '+'+'
if p ==0:
theta[0]='&='+str(listedesvaleurspossiblesde_f_de_X[gamma])+"\\dot "+str(listedesprobade_f_de_X[gamma])+"\\"+' '+'+'
else:
theta[0]='&'+"\\"+'hspace{2ex}+ '+str(listedesvaleurspossiblesde_f_de_X[gamma])+"\\dot "+str(listedesprobade_f_de_X[gamma])+"\\"+' '+'+'
theta[4]=str(listedesvaleurspossiblesde_f_de_X[gamma+4])+"\\dot "+str(listedesprobade_f_de_X[gamma+4])+"\\"+"\\" +' '#+'\n'
for j in range(0,5,1):
#sentence_the_quintets.append(theta[j])
phrase.append(theta[j])
Q=0
#Donc maintenant soit n appartient à {1,2,3,4} soit il ne reste que les r derniers cas à traiter. Dans tous les cas, il reste les r derniers termes à traiter.
if reste==0:
debut=[sentinit]
fin = [sentfin]
final_list=debut+phrase+fin
L=len(final_list)
for i in range(L):
print(final_list[i], end='')
else:
gamma=5*quotient
theta=['a','a','a','a','a']
for j in range(0,reste,1):
theta[j]=str(listedesvaleurspossiblesde_f_de_X[gamma+j])+"\\dot"+' '+str(listedesprobade_f_de_X[gamma+j])+'+'+' '
#ete='=&'
theta[0]='&'+"\\"+'hspace{2ex}+ '+str(listedesvaleurspossiblesde_f_de_X[gamma])+"\\dot"+' '+str(listedesprobade_f_de_X[gamma])+'+'+' '
theta[reste-1]=str(listedesvaleurspossiblesde_f_de_X[gamma+reste-1])+"\\dot"+"\\"+' '+str(listedesprobade_f_de_X[gamma+reste-1])+"\\"+"\\"+''
#print('theta=', theta)
if quotient !=0: #Donc la liste sentence_the_quintets existe
e=1
else: #donc le quotient est nul et sentence_the_quintets n'existe pas
sentence_the_quintets=[]
# A partir de là, sentence_the_quintets existe quoi qu'il arrive
for j in range(0,reste,1):
sentence_the_quintets.append(theta[j])
#print('sentence_the_quintets=', sentence_the_quintets,'\n')
#print('sentence_the_quintets=', sentence_the_quintets,'\n')
debut=[sentinit]
fin = [sentfin]
final_list=debut+phrase+sentence_the_quintets+fin
#print('final_list=', final_list,'\n')
L=len(final_list)
for i in range(L):
print(final_list[i], end='')
#########################################################################################################
####################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# pdfX = {10: Rational(1, 4), 11: Rational(1, 2), 12: Rational(1, 4)}
# X= FiniteRV('X', pdfX)
# pdfD = {10: Rational(1, 4), 11: Rational(1, 4), 12: Rational(1, 4), 13: Rational(1, 4)}
# D= FiniteRV('D', pdfD)
# # Attention, E ne peut être donné comme nom d'une variabel aléatoire!!!!!!!!!!!
# lpdfE = {10: Rational(1, 5), 11: Rational(1, 5), 12: Rational(1, 5), 13: Rational(1, 5), 14: Rational(1, 5)}
# rvE= FiniteRV('E', lpdfE)
# pdfS = {1: Rational(1, 7), 2: Rational(1, 7), 3: Rational(1, 7), 4: Rational(1, 7), 5: Rational(1, 7), 6: Rational(1, 7), 7: Rational(1, 7)}
# S= FiniteRV('S', pdfS)
# rho3="\\sin"+'(X)'
# rho3bis="\\sin"+'('+"\\alpha"+')'
#tau=ExpandExpFiniteRV(powers(2),E,'E',rho1,'E^2','virg')
# tau=ExpandExpFiniteRV(sin,D,'X',rho3bis,rho3,'virg')
# rho4='D^2'
# rho4bis="\\alpha"+'^2'
# tau=ExpandExpFiniteRV(powers(2),D,'D',rho4bis,rho4,'virg')
# rho5='E^2'
# rho5bis="\\alpha"+'^2'
# tau=ExpandExpFiniteRV(powers(2),E,'E',rho5bis,rho5,'virg')
# rho6='S^2'
# rho6bis="\\alpha"+'^2'
# tau=ExpandExpFiniteRV(powers(2),S,'S',rho6bis,rho6,'virg')
# pdfK = {1: Rational(1, 11), 2: Rational(1, 11), 3: Rational(1, 11), 4: Rational(1, 11), 5: Rational(1, 11), 6: Rational(1, 11), 7: Rational(1, 11), 8: Rational(1, 11), 9: Rational(1, 11), 10: Rational(1, 11), 11: Rational(1, 11)}
# K= FiniteRV('K', pdfK)
# rho7='K^2'
# rho7bis="\\alpha"+'^2'
# tau=ExpandExpFiniteRV(powers(2),K,'K',rho7bis,rho7,'virg')
# pdfT = {1: Rational(1, 13), 2: Rational(1, 13), 3: Rational(1, 13), 4: Rational(1, 13), 5: Rational(1, 13), 6: Rational(1, 13), 7: Rational(1, 13), 8: Rational(1, 13), 9: Rational(1, 13), 10: Rational(1, 13), 11: Rational(1, 13), 12: Rational(1, 13), 13: Rational(1, 13)}
# T= FiniteRV('T', pdfT)
# rho8='T^2'
# rho8bis="\\alpha"+'^2'
# tau=ExpandExpFiniteRV(powers(2),T,'T',rho8bis,rho8,'virg')
# pdfL = {-1: Rational(1, 2), 1: Rational(1, 2)}
# L= FiniteRV('L', pdfL)
# pdfN = {-1: Rational(1, 3), 1: Rational(1, 3), -2: Rational(1, 6), 2: Rational(1, 6)}
# N= FiniteRV('N', pdfN)
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def ComputeExpFiniteRV(f,X):
"""" Calcule l'espérance E[f(X)], où X une v.a. finie.
Je pense que c'est maintenant devenu une fction inutile"""""
# Loi de f(X):
alpha = fctionofafiniteRV(f,X)
"""Donc on a alpha= RV dont le nom est f_of_X
et density(alpha).dict= dico de f_of_X """
# Répartition des valeurs possibles de f(X) par 5:
listedesprobade_f_de_X=[] #poids
listedesvaleurspossiblesde_f_de_X=[] #valeurs possibles
a=0
for key, value in density(alpha).dict.items():
listedesprobade_f_de_X.append(value)
listedesvaleurspossiblesde_f_de_X.append(key)
a=a+key*value #C'est le résulat final E[f(X)]
#result=str(a)#toto'#str(result)
return a
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# tau=ComputeExpFiniteRV(powers(2),T)
# print('tau=', tau)
# pdfX = {0: Rational(1, 10), 1: Rational(3, 20), 2: Rational(3, 10), 3: Rational(1, 4), 4: Rational(1, 5)}
# X= FiniteRV('X', pdfX)
#print('type(X)=',type(X))
# pdfX = {0: Rational(1, 8), 1: Rational(1, 2), 2: Rational(1, 4), 3: Rational(1, 8)} #keys:
# X= FiniteRV('X', pdfX)
# # Sin_X=fctionofafiniteRV(sin,X)
# print('E[X]=',E(X),'\n')
# rho3="\\sin"+'(X)'
# rho3bis="\\sin"+'('+"\\alpha"+')'
# print('', '\n')
# #tau=ExpandExpFiniteRV(powers(2),E,'E',rho1,'E^2','virg')
# #tau=ExpandExpFiniteRV(sin,D,'X',rho3bis,rho3,'virg')
# rho4='X'
# rho4bis="\\alpha"
# gamma=ExpandFiniteRV(Id,X,'X','virg')
# # (Id,X,'X',rho4bis,rho4,'virg')
# print('', '\n')
# tau=ExpandExpFiniteRV(Id,X,'X',rho4bis,rho4,'virg')
# print('', '\n')
# rho5='X^3'
# rho5bis='{'+"\\alpha"+'}^3'
# tau=ExpandExpFiniteRV(powers(3),X,'X',rho5bis,rho5,'virg')
# print('Vérifions nos calculs:', '\n')
# print('density(X).dict=',density(X).dict, '\n')
# alpha=fctionofafiniteRV(powers(3),X) # Donc c'est la v.a. X^3
# print('density(X^3)=',density(alpha).dict, '\n')
# a=ComputeExpFiniteRV(powers(3),X)#=ComputeExpFiniteRV(alpha,X)
# print('E[ComputeExpFiniteRV(powers(3),X)]=',a, '\n')
# b=ComputeExpFiniteRV(Id,alpha) #=ComputeExpFiniteRV(X^3)
# print('E[ComputeExpFiniteRV(Id,X^3)]=',b, '\n')
# print('Bref tout concorde!', '\n')
# print('a=',a, '\n')
# print('E[X^3]=')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def VarFiniteRV(f,X):
"""" Calcul de la variance de f(X), où X une v.a. finie. """""
# Loi de f(X):
alpha=fctionofafiniteRV(f,X)
"""Donc on a alpha= RV dont le nom est f_of_X
et density(alpha).dict= dico de f_of_X """
# Répartition des valeurs possibles de f(X) par 5:
listedesprobade_f_de_X=[] #poids
listedesvaleurspossiblesde_f_de_X=[] #valeurs possibles
a=0
b=0
for key, value in density(alpha).dict.items():
listedesprobade_f_de_X.append(value)
listedesvaleurspossiblesde_f_de_X.append(key)
a=a+value*key #C'est le résulat final E[f(X)]
b=b+value*(key**2) #C'est le résulat final E[f(X)^2]
#print('a=',a, "&", 'b=',b, '\n')
c=b-a**2
return c
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#
# pdfX = {0: Rational(1, 10), 1: Rational(3, 20), 2: Rational(3, 10), 3: Rational(1, 4), 4: Rational(1, 5)}
# X= FiniteRV('X', pdfX)
# print('Distribution of T is =', density(X).dict, '\n')
# tau=VarFiniteRV(powers(2),X)
# print('Var(T) =', tau, '\n')
#
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def ComputeExp_p_FiniteRV(f,X,p):
"""" Calcule l'espérance E[f(X)^p], où X une v.a. finie. """""
# Loi de f(X)^p:
g = compo(f,p)
alpha = fctionofafiniteRV(g,X)
#beta=fctionofafiniteRV(powers(p)
"""Donc on a alpha= RV dont le nom est g_of_X
et density(alpha).dict= dico de g_of_X """
# Répartition des valeurs possibles de f(X) par 5:
listedesprobade_g_de_X=[] #poids
listedesvaleurspossiblesde_g_de_X=[] #valeurs possibles
a=0
for key, value in density(alpha).dict.items():
listedesprobade_g_de_X.append(value)
listedesvaleurspossiblesde_g_de_X.append(key)
a=a+key*value #C'est le résulat final E[f(X)]
#result=str(a)#toto'#str(result)
return a
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# pdfX = {0: Rational(1, 10), 1: Rational(3, 20), 2: Rational(3, 10), 3: Rational(1, 4), 4: Rational(1, 5)}
# X= FiniteRV('X', pdfX)
# print('distribution of X=', density(X).dict, '\n')
# print('E[f(X)^p]=', ComputeExp_p_FiniteRV(cos,X,2),'\n')
# print('Vérifions nos calculs:', '\n')
# pdfX = {0: Rational(1, 10), 1: Rational(3, 20), 2: Rational(3, 10), 3: Rational(1, 4), 4: Rational(1, 5)}
# X= FiniteRV('X', pdfX)
# print('density(X).dict=',density(X).dict, '\n')
# alpha=fctionofafiniteRV(powers(3),X) # Donc c'est la v.a. X^3
# print('density(X^3)=',density(alpha).dict, '\n')
# a=ComputeExpFiniteRV(powers(3),X)#=ComputeExpFiniteRV(alpha,X)
# print('E[ComputeExpFiniteRV(powers(3),X)]=',a, '\n')
# b=ComputeExpFiniteRV(Id,alpha) #=ComputeExpFiniteRV(X^3)
# print('E[ComputeExpFiniteRV(Id,X^3)]=',b, '\n')
# c=ComputeExp_p_FiniteRV(Id,X,3)
# print('E[ComputeExpFiniteRV(Id,X^3)]=',c, '\n')
# print('Bref tout concorde!', '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
[docs]
def ExpandFiniteRV_V2(f,X,name_of_the_original_rv,name_funct_and_name_rv,ponctu):
"""" Met dans un align unique la distribution de la v.a. finie f(X), en les rangeant 4 par 4 """""
U="\\"+'bP'
# Ponctuation .,
ponctu=str(ponctu)
if ponctu == 'point':
terminaison = '.'
elif ponctu == 'virg':
terminaison = ','
else:
terminaison = ''
# Loi de f(X):
alpha=fctionofafiniteRV(f,X)
"""Donc on a alpha= RV dont le nom est f_of_X
et density(alpha).dict= dico de f_of_X """
# Répartition des valeurs possibles de f(X) par 5:
listedesprobade_f_de_X=[] #poids
listedesvaleurspossiblesde_f_de_X=[] #valeurs possibles
for key, value in density(alpha).dict.items():
listedesprobade_f_de_X.append(value)
listedesvaleurspossiblesde_f_de_X.append(key)
sentinit ="\\"'begin{align*}\n'
sentfin ='\n'+"\\"'end{align*}\n'+'\n'
n=len(density(alpha).dict)
div=4
quotient=n//div #quotient = dividende // diviseur
reste=n%div #reste = dividende % diviseur
#print('n =', n, 'quotient= ',quotient, 'et reste vaut:', reste)
phrase=[]
Q=quotient #nbre d'itirérations
while Q != 0:
#print('On est rentré dans la boucle')
for p in range(0,quotient,1):
gamma=div*p
theta=[]
for i in range(1,div+1,1):
theta.append('a')
sentence_the_quintets=[]
for j in range(0,div,1):
theta[j]='&'+U+'('+name_funct_and_name_rv+'='+str(listedesvaleurspossiblesde_f_de_X[gamma+j])+')='+str(listedesprobade_f_de_X[gamma+j])+"\\"+'&'+' '
if Q==1 and reste==0:
theta[div-1]='&'+U+'('+name_funct_and_name_rv+'='+str(listedesvaleurspossiblesde_f_de_X[gamma+div-1])+')='+str(listedesprobade_f_de_X[gamma+div-1])+terminaison+'&'+' '
else:
theta[div-1]='&'+U+'('+name_funct_and_name_rv+'='+str(listedesvaleurspossiblesde_f_de_X[gamma+div-1])+')='+str(listedesprobade_f_de_X[gamma+div-1])+'&'+'\\'+'\\'+'\n'
for j in range(0,div,1):
#sentence_the_quintets.append(theta[j])
phrase.append(theta[j])
Q=0
#Donc maintenant soit n appartient à {1,2,3,4} soit il ne reste que les r derniers cas à traiter. Dans tous les cas, il reste les r derniers termes à traiter.
if reste==0:
debut=[sentinit]
fin = [sentfin]
final_list=debut+phrase+fin
L=len(final_list)
for i in range(L):
print(final_list[i], end='')
else:
gamma=div*quotient
theta=[]
for i in range(1,div+1,1):
theta.append('a')
for j in range(0,reste,1):
theta[j]='&'+U+'('+name_funct_and_name_rv+'='+str(listedesvaleurspossiblesde_f_de_X[gamma+j])+')='+str(listedesprobade_f_de_X[gamma+j])+'&'+' '
theta[reste-1]='&'+U+'('+name_funct_and_name_rv+'='+str(listedesvaleurspossiblesde_f_de_X[reste-1])+')='+str(listedesprobade_f_de_X[reste-1])+terminaison+'&'+' '
#print('theta=', theta)
if quotient !=0: #Donc la liste sentence_the_quintets existe
e=1
else: #donc le quotient est nul et sentence_the_quintets n'existe pas
sentence_the_quintets=[]
# A partir de là, sentence_the_quintets existe quoi qu'il arrive
for j in range(0,reste,1):
sentence_the_quintets.append(theta[j])
#print('sentence_the_quintets=', sentence_the_quintets,'\n')
#print('sentence_the_quintets=', sentence_the_quintets,'\n')
debut=[sentinit]
fin = [sentfin]
final_list=debut+phrase+sentence_the_quintets+fin
#print('final_list=', final_list,'\n')
L=len(final_list)
for i in range(L):
print(final_list[i], end='')
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# print('', '\n')
# pdfX = {10: Rational(1, 4), 11: Rational(1, 2), 12: Rational(1, 4)}
# X= FiniteRV('X', pdfX)
# pdfD = {10: Rational(1, 4), 11: Rational(1, 4), 12: Rational(1, 4), 13: Rational(1, 4)}
# D= FiniteRV('D', pdfD)
# pdfU = {10: Rational(1, 5), 11: Rational(1, 5), 12: Rational(1, 5), 13: Rational(1, 5), 14: Rational(1, 5)}
# U= FiniteRV('U', pdfU)
# pdfS = {1: Rational(1, 7), 2: Rational(1, 7), 3: Rational(1, 7), 4: Rational(1, 7), 5: Rational(1, 7), 6: Rational(1, 7), 7: Rational(1, 7)}
# S= FiniteRV('S', pdfS)
# rho3="\\sin"+'(X)'
# rho3bis="\\sin"+'('+"\\alpha"+')'
# tau=ExpandExpFiniteRV(powers(2),U,'U',rho3bis,'U^2','virg')
# # Trois autres vérifications
# a=ComputeExpFiniteRV(powers(2),U)#=ComputeExpFiniteRV(alpha,X)
# print('E[ComputeExpFiniteRV(powers(3),X)]=',a, '\n')
# b=ComputeExpFiniteRV(powers(2),U) #=ComputeExpFiniteRV(X^3)
# print('E[ComputeExpFiniteRV(Id,X^2)]=',b, '\n')
# c=ComputeExp_p_FiniteRV(Id,U,2)
# print('E[ComputeExpFiniteRV(Id,X^2)]=',c, '\n')
#rho5='X^3'
# tau=ExpandFiniteRV_V2(powers(3),X,'X',rho5,'virg')
# rho6='X^2'
# tau=ExpandFiniteRV_V2(powers(2),D,'D',rho6,'virg')
# rho7='X^2'
# tau=ExpandFiniteRV_V2(powers(2),E,'E',rho7,'virg')
# tau=ExpandFiniteRV_V2(powers(2),S,'S',rho7,'virg')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#print('randnbresstrictpositifs(n,p) = ', randnbresstrictpositifs(4,1,5))
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#print('randnbresstrictpositifs(n,p) = ', randnbresstrictpositifs(4,1,5))
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#print('randnbresstrictpositifs(n,p) = ', randnbresstrictpositifs(4,1,5))
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#print('randnbresstrictpositifs(n,p) = ', randnbresstrictpositifs(4,1,5))
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
# X = symbols('X')
# q=6
# W = DiscreteUniform('W', list(range(1,q,1)) ) # distribution over a range
# iteratorW = sample_iter(W, numsamples=1)
# D = list(sample_iter(W, numsamples=1))
# p = D[0]
# u= expand(X**p + 2**p)
# print('u =', u, '\n')
# # p = 6
# # W = DiscreteUniform('W', list(range(1,p,1)) )
# # D = list(sample_iter(W, numsamples=1))
# # A = D[0]
# # print('D[0] = ', A,'\n')
# # from sympy import poly
# # from sympy.abc import x
# # poly(x*(x**2 + x - 1)**2)
# # X = Symbol('X')
# # e = X**A + 2**A
# # Polynomial = Poly(e,X)
# # print('Polynomial =', Polynomial, '\n')
# # poly_latex = latex(Polynomial)
# # print('poly_latex =', poly_latex, '\n')
# L = []
# q = 6
# for i in range(1,q,1):
# b = "\\"'alpha_'+ str(i)
# L.append(b)
# print('L =,', L, '\n')
# alpha = 'alpha'
[docs]
def Content_pr_python_latex(L):
""" Renvoie, sous forme de string, le contenu de toute la liste L, en en séparant les éléments par des virgules (en particulier plus de crochets) """
phrase=""
for k in range(0,len(L)-1,1):
#phrase = phrase+str(latex(L[k]))+','
phrase = phrase+str(L[k])+','
phrase = phrase+str(L[len(L)-1])
return phrase
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# L = []
# q = 6
# for i in range(1,q,1):
# b = "\\"'alpha_'+ str(i)
# L.append(b)
# print('L =,', L, '\n')
# alpha = 'alpha'
# Q = Content_pr_python_latex(L)
# print('Q =', Q, '\n')
# i = 2
# d = "\\"'alpha_'+ str(i)
# print('d =', d, '\n')
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
#############################################################################################################
#### Début des essais ########
#############################################################################################################
#############################################################################################################
#### Fin des essais ########
#############################################################################################################
# L = randnbresstrictpositifs(5,95,105)
# print('L =', L, '\n')
[docs]
def randnbresstrictpositifsreel(n,k,p,s):
"""Retourne une liste de n réels, tirés aléatoirement entre k et p, avec s chiffres significatifs après la virgule
"""
l=[]
Z = []
A=0
m=[]
W = DiscreteUniform('W', list(range(k,p,1)) ) # distribution over a range
#print('density(W).dict = ', density(W).dict,'\n')
iteratorW = sample_iter(W, numsamples=n) #réalisation aléatoire
D = DiscreteUniform('D', list(range(0,10,1)) ) # distribution over a range
#print('density(W).dict = ', density(W).dict,'\n')
iteratorD = sample_iter(D, numsamples=n) #réalisation aléatoire
itD = iter(iteratorD)
for j in itD:
Z.append(j)
it = iter(iteratorW)
cpt = 0
for i in it:
t = Z[cpt]/10
u = i+ t
r = round(u,1)
l.append(r)
cpt = cpt + 1
#print('l =', l, '\n')
return l
#############################################################################################################
#### Début des essais ########
#############################################################################################################
# randnbresstrictpositifsreel(5,1,6,1)
# n = 15
# a = 1
# b = 6
# L = randnbresstrictpositifsreel(n,a,b,1)
# ph = str(L[0])
# for i in range(1,n,1):
# ph = ph + '+' + str(L[i])
# tau = latex(ph)
# #moy = sum(L)/len(L)
# A = Rational(2,4)
# print('A =', A, '\n')
# B = Rational(2,4)
# print('B =', B, '\n')
# x,y,z=symbols("x,y,z")
# R = x + 2*y
# print('R =', R, '\n')
# S = (x + 2*y).subs(x, 10)
# print('S =', S, '\n')
# T = sympify('4/2+7', evaluate=False)
# print('T =', T, '\n')
# q = 2
# r = 4
# U = str(q/r)
# QR = sympify(Rational(q,r), evaluate = False)
# print('QR =', QR, '\n')
# from sympy import symbols, Rational
# Define symbols
# x = symbols('x', integer=True)
# y = symbols('y', integer=True)
# non_zero_condition = Ne(y, 0)
# #y = symbols('y', real=True)
# # # Create a rational expression with symbols in both numerator and denominator
# print(x.is_real)
# print(y.is_real)
# print(x.is_integer)
# print(y.is_integer)
# z = Mul(x,y**(-1))
# expr = z
# print(expr)
# expr_subs = simplify(expr.subs(x,2).subs(y,4), evaluate = False)
# print(expr_subs)
# T = Mul(3, Rational(1, 2), evaluate=False)
# #print('T = ', T, '\n')
# U = Mul(Mul(3, Rational(1, 2), evaluate=False), Pow(Mul(4, Rational(1, 5), evaluate=False), -1, evaluate=False), evaluate=False)
# (3/2)/((4/5))
# #print('U = ', U, '\n')
# Y = Rational(2,4)
# numerator = Y.numerator
# #print('numerator = ', numerator, '\n')
# denominator = Y.denominator
# Q = Mul(2,4**(-1))
#print('Q = ', Q, '\n')
# def affiche(p,q):
# #Affiche p/q en latex
# ps = str(p)
# qs = str(q)
# fin = "\\"+'frac{'+ps+'}{'+ qs +'}'
# return fin
# s = affiche(2,4)
#print('s =', s, '\n')