U
    9%eA                     @   s  d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	m
Z
 ddlmZ ddlmZmZ dd	lmZ dd
lmZ ddlmZmZ ddlmZ ddlmZ ddlmZ ddlmZmZ ddl m!Z! ddl"m#Z# ddl$m%Z% ddlm&Z& ddlm'Z' ddl m(Z( ddl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5 G dd de6Z7G dd de*Z8G dd de8Z9G dd de+e8Z:G dd  d e,e:Z;G d!d" d"e5e3Z<G d#d$ d$e-Z=G d%d& d&e/e=Z>G d'd( d(e.e=Z?d)S )*zq
Finite Discrete Random Variables Module

See Also
========
sympy.stats.frv_types
sympy.stats.rv
sympy.stats.crv
    )product)Sum)Basic)cacheit)Lambda)Mul)InanEq)S)DummySymbolsympifyexp)	Piecewise)AndOr)Intersection)Dict)Logic)
Relational)_sympify	FiniteSet)RandomDomainProductDomainConditionalDomainPSpaceIndependentProductPSpaceSinglePSpacerandom_symbolssumsetsrv_subsNamedArgsMixinDensityDistributionc                   @   s$   e Zd ZdZdd Zedd ZdS )FiniteDensityz'
    A domain with Finite Density.
    c                 C   s    t |}|| kr| | S dS dS )z
        Make instance of a class callable.

        If item belongs to current instance of a class, return it.

        Otherwise, return 0.
        r   Nr   )selfitem r,   N/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/stats/frv.py__call__(   s    zFiniteDensity.__call__c                 C   s   t | S )z,
        Return item as dictionary.
        )dictr*   r,   r,   r-   r/   6   s    zFiniteDensity.dictN)__name__
__module____qualname____doc__r.   propertyr/   r,   r,   r,   r-   r)   $   s   r)   c                   @   sP   e Zd ZdZdZedd Zedd Zedd Zd	d
 Z	dd Z
dd ZdS )FiniteDomainzS
    A domain with discrete finite support

    Represented using a FiniteSet.
    Tc                 C   s   t dd | jD S )Nc                 s   s   | ]\}}|V  qd S Nr,   .0symvalr,   r,   r-   	<genexpr>G   s     z'FiniteDomain.symbols.<locals>.<genexpr>r   elementsr0   r,   r,   r-   symbolsE   s    zFiniteDomain.symbolsc                 C   s
   | j d S Nr   argsr0   r,   r,   r-   r>   I   s    zFiniteDomain.elementsc                 C   s   t dd | jD  S )Nc                 S   s   g | ]}t t|qS r,   )r   r/   )r9   elr,   r,   r-   
<listcomp>O   s     z%FiniteDomain.dict.<locals>.<listcomp>r=   r0   r,   r,   r-   r/   M   s    zFiniteDomain.dictc                 C   s
   || j kS r7   )r>   r*   otherr,   r,   r-   __contains__Q   s    zFiniteDomain.__contains__c                 C   s
   | j  S r7   )r>   __iter__r0   r,   r,   r-   rH   T   s    zFiniteDomain.__iter__c                 C   s   t dd | D  S )Nc                 S   s   g | ]}t d d |D  qS )c                 S   s   g | ]\}}t ||qS r,   r
   r8   r,   r,   r-   rD   X   s     z6FiniteDomain.as_boolean.<locals>.<listcomp>.<listcomp>)r   )r9   r+   r,   r,   r-   rD   X   s     z+FiniteDomain.as_boolean.<locals>.<listcomp>)r   r0   r,   r,   r-   
as_booleanW   s    zFiniteDomain.as_booleanN)r1   r2   r3   r4   	is_Finiter5   r?   r>   r/   rG   rH   rI   r,   r,   r,   r-   r6   =   s   


r6   c                   @   sX   e Zd ZdZdd Zedd Zedd Zedd	 Zed
d Z	dd Z
dd ZdS )SingleFiniteDomainzi
    A FiniteDomain over a single symbol/set

    Example: The possibilities of a *single* die roll.
    c                 C   s*   t |tst |tst| }t| ||S r7   )
isinstancer   r   r   __new__)clssymbolsetr,   r,   r-   rM   b   s
    
zSingleFiniteDomain.__new__c                 C   s
   | j d S r@   rA   r0   r,   r,   r-   rO   h   s    zSingleFiniteDomain.symbolc                 C   s
   t | jS r7   r   rO   r0   r,   r,   r-   r?   l   s    zSingleFiniteDomain.symbolsc                 C   s
   | j d S N   rA   r0   r,   r,   r-   rP   p   s    zSingleFiniteDomain.setc                    s   t  fdd jD  S )Nc                    s   g | ]}t  j|ffqS r,   	frozensetrO   r9   elemr0   r,   r-   rD   v   s     z/SingleFiniteDomain.elements.<locals>.<listcomp>)r   rP   r0   r,   r0   r-   r>   t   s    zSingleFiniteDomain.elementsc                    s    fdd j D S )Nc                 3   s   | ]}t  j|ffV  qd S r7   rT   rV   r0   r,   r-   r<   y   s     z.SingleFiniteDomain.__iter__.<locals>.<genexpr>rP   r0   r,   r0   r-   rH   x   s    zSingleFiniteDomain.__iter__c                 C   s$   t |d \}}|| jko"|| jkS r@   )tuplerO   rP   )r*   rF   r:   r;   r,   r,   r-   rG   {   s    zSingleFiniteDomain.__contains__N)r1   r2   r3   r4   rM   r5   rO   r?   rP   r>   rH   rG   r,   r,   r,   r-   rK   [   s   



rK   c                   @   s$   e Zd ZdZdd Zedd ZdS )ProductFiniteDomainz
    A Finite domain consisting of several other FiniteDomains

    Example: The possibilities of the rolls of three independent dice
    c                 C   s   t | j }dd |D S )Nc                 s   s   | ]}t |V  qd S r7   )r$   )r9   itemsr,   r,   r-   r<      s     z/ProductFiniteDomain.__iter__.<locals>.<genexpr>)r   domains)r*   proditerr,   r,   r-   rH      s    
zProductFiniteDomain.__iter__c                 C   s   t |  S r7   r   r0   r,   r,   r-   r>      s    zProductFiniteDomain.elementsN)r1   r2   r3   r4   rH   r5   r>   r,   r,   r,   r-   rZ      s   rZ   c                   @   sD   e Zd ZdZdd Zdd Zdd Zdd	 Zed
d Z	dd Z
dS )ConditionalFiniteDomainz
    A FiniteDomain that has been restricted by a condition

    Example: The possibilities of a die roll under the condition that the
    roll is even.
    c                 C   s"   |dkr|S t |}t| ||S )zH
        Create a new instance of ConditionalFiniteDomain class
        T)r%   r   rM   )rN   domain	conditioncondr,   r,   r-   rM      s    zConditionalFiniteDomain.__new__c                 C   sB   | j t|}|dkr|S |jr.|j|jkS tdt| dS )z
        Test the value. If value is boolean, return it. If value is equality
        relational (two objects are equal), return it with left-hand side
        being equal to right-hand side. Otherwise, raise ValueError exception.
        )TFzUndecidable if %sN)r`   xreplacer/   Zis_Equalitylhsrhs
ValueErrorstr)r*   rW   r;   r,   r,   r-   _test   s    zConditionalFiniteDomain._testc                 C   s   || j ko| |S r7   )
fulldomainrg   rE   r,   r,   r-   rG      s    z$ConditionalFiniteDomain.__contains__c                    s    fdd j D S )Nc                 3   s   | ]}  |r|V  qd S r7   rg   rV   r0   r,   r-   r<      s     
 z3ConditionalFiniteDomain.__iter__.<locals>.<genexpr>)rh   r0   r,   r0   r-   rH      s    z ConditionalFiniteDomain.__iter__c                    s2   t  jtr&t fdd jjD  S tdd S )Nc                    s&   g | ]}t  jj|ff kr|qS r,   )rU   rh   rO   rV   r0   r,   r-   rD      s    z/ConditionalFiniteDomain.set.<locals>.<listcomp>z7Not implemented on multi-dimensional conditional domain)rL   rh   rK   r   rP   NotImplementedErrorr0   r,   r0   r-   rP      s
    zConditionalFiniteDomain.setc                 C   s
   t | S r7   )r6   rI   r0   r,   r,   r-   rI      s    z"ConditionalFiniteDomain.as_booleanN)r1   r2   r3   r4   rM   rg   rG   rH   r5   rP   rI   r,   r,   r,   r-   r^      s   	
r^   c                   @   s   e Zd Zdd Zedd Zeedd Zdd Z	ed	d
 Z
edd Zedd Zedd Zedd Zedd Zdd Zdd ZdS )SingleFiniteDistributionc                 G   s   t tt|}tj| f| S r7   )listmapr   r   rM   )rN   rB   r,   r,   r-   rM      s    z SingleFiniteDistribution.__new__c                  G   s   d S r7   r,   rA   r,   r,   r-   check   s    zSingleFiniteDistribution.checkc                    s"    j rt S  fdd jD S )Nc                    s   i | ]}|  |qS r,   pmf)r9   kr0   r,   r-   
<dictcomp>   s      z1SingleFiniteDistribution.dict.<locals>.<dictcomp>)is_symbolicr'   rP   r0   r,   r0   r-   r/      s    zSingleFiniteDistribution.dictc                 G   s
   t  d S r7   rj   r*   rB   r,   r,   r-   rp      s    zSingleFiniteDistribution.pmfc                 C   s
   t  d S r7   rt   r0   r,   r,   r-   rP      s    zSingleFiniteDistribution.setc                 C   s   | j jS r7   )r/   valuesr0   r,   r,   r-   <lambda>       z!SingleFiniteDistribution.<lambda>c                 C   s   | j jS r7   )r/   r[   r0   r,   r,   r-   rw      rx   c                 C   s   dS )NFr,   r0   r,   r,   r-   rw      rx   c                 C   s   | j jS r7   )r/   rH   r0   r,   r,   r-   rw      rx   c                 C   s   | j jS r7   )r/   __getitem__r0   r,   r,   r-   rw      rx   c                 G   s
   | j | S r7   ro   ru   r,   r,   r-   r.      s    z!SingleFiniteDistribution.__call__c                 C   s
   || j kS r7   rX   rE   r,   r,   r-   rG      s    z%SingleFiniteDistribution.__contains__N)r1   r2   r3   rM   staticmethodrn   r5   r   r/   rp   rP   rv   r[   rs   rH   ry   r.   rG   r,   r,   r,   r-   rk      s    

rk   c                   @   s   e Zd ZdZdZdd Zdd Zdd Zd	d
 Ze	dd Z
e	d!ddZe	dd Ze	dd Zd"ddZdd Zdd Zdd Zd#dd ZdS )$FinitePSpacezd
    A Finite Probability Space

    Represents the probabilities of a finite number of events.
    Tc                 C   s2   dd |  D }t|}t| ||}||_|S )Nc                 S   s   i | ]\}}t |t |qS r,   r   r9   keyr;   r,   r,   r-   rr      s    z(FinitePSpace.__new__.<locals>.<dictcomp>)r[   r   r    rM   _density)rN   r_   densityZpublic_densityobjr,   r,   r-   rM      s    zFinitePSpace.__new__c                 C   sL   t |}| j}tt| d tr2||tjS |t	|d d tjS )Nr   rS   )
r   r~   rL   rl   keysr   getr   ZerorY   )r*   rW   r   r,   r,   r-   prob_of   s
    zFinitePSpace.prob_ofc                    s*   t  fddt|D stt j|S )Nc                 3   s   | ]}|j  jkV  qd S r7   )rO   r?   )r9   rr0   r,   r-   r<     s     z%FinitePSpace.where.<locals>.<genexpr>)allr#   AssertionErrorr^   r_   r*   r`   r,   r0   r-   where  s    zFinitePSpace.wherec                 C   sP   t || j}t }| jD ]2}|t|}| |}||tj	| ||< q|S r7   )
r%   rv   r)   r_   rb   r/   r   r   r   r   )r*   exprdrW   r;   probr,   r,   r-   compute_density  s    

zFinitePSpace.compute_densityc                 C   sH   |  |}tj}g }t|D ]"}|| }||7 }|||f qt|S r7   )r   r   r   sortedappendr/   )r*   r   r   cum_probcdfr}   r   r,   r,   r-   compute_cdf  s    
zFinitePSpace.compute_cdfFc                 C   s<   |  |}t| }t|dd d}|r8dd |D }|S )Nc                 S   s   | d S rR   r,   )Zval_cumprobr,   r,   r-   rw     rx   z)FinitePSpace.sorted_cdf.<locals>.<lambda>)r}   c                 S   s   g | ]\}}|t |fqS r,   )float)r9   vr   r,   r,   r-   rD   !  s   z+FinitePSpace.sorted_cdf.<locals>.<listcomp>)r   rl   r[   r   )r*   r   Zpython_floatr   r[   sorted_itemsr,   r,   r-   
sorted_cdf  s    
zFinitePSpace.sorted_cdfc                    s6   |  |}tddd t t fdd| D S )NtTrealc                 3   s&   | ]\}}t t|   | V  qd S r7   )r   r   r9   rq   r   r   r,   r-   r<   *  s     z?FinitePSpace.compute_characteristic_function.<locals>.<genexpr>r   r   r   sumr[   r*   r   r   r,   r   r-   compute_characteristic_function%  s    
z,FinitePSpace.compute_characteristic_functionc                    s6   |  |}tddd t t fdd| D S )Nr   Tr   c                 3   s"   | ]\}}t |  | V  qd S r7   r   r   r   r,   r-   r<   1  s     zBFinitePSpace.compute_moment_generating_function.<locals>.<genexpr>r   r   r,   r   r-   "compute_moment_generating_function,  s    
z/FinitePSpace.compute_moment_generating_functionNc                    s   |pj }t | fddjD }t ttfr\dd jD } fddjD }n$ fddjD }dd jD }tdd t|||D S )Nc                    s   g | ]}  |qS r,   r   rV   r0   r,   r-   rD   6  s     z4FinitePSpace.compute_expectation.<locals>.<listcomp>c                 S   s   g | ]}t |d  d qS )r   rS   )rY   rV   r,   r,   r-   rD   8  s     c                    s   g | ]}  t|qS r,   rb   r/   rV   r   r,   r-   rD   9  s     c                    s   g | ]}  t|qS r,   r   rV   r   r,   r-   rD   ;  s     c                 S   s   g | ]}d qS Tr,   rV   r,   r,   r-   rD   <  s     c                 S   s*   g | ]"\}}}t || |ftjd fqS r   )r   r   r   )r9   r   rW   Zblvr,   r,   r-   rD   =  s   )rv   r%   r_   rL   r   r   r   zip)r*   r   rvskwargsprobsZparse_domainZboolsr,   )r   r*   r-   compute_expectation3  s    


z FinitePSpace.compute_expectationc                 C   s^   |  |}tddd}t|dk |dkB ff}| D ]\}}||||kff }q4t|t| S )NpTr   r   rS   )r   r   r	   r[   r   r   )r*   r   r   r   rP   r}   valuer,   r,   r-   compute_quantile@  s    
zFinitePSpace.compute_quantilec                    s   t dd t D }t }|js@tdt|j  t tr|j	j
j	st jtrl jn jt fddj
D S ttfdd D S )Nc                 s   s   | ]}|j V  qd S r7   )rO   )r9   rsr,   r,   r-   r<   I  s     z+FinitePSpace.probability.<locals>.<genexpr>z)Cannot compare foreign random symbols, %sc                 3   s<   | ]4}t | t|d  d ftjdfV  qdS )r   rS   TN)r   r   subsrl   r   r   rV   r`   rvr*   r,   r-   r<   Q  s
    c                 3   s   | ]}  |V  qd S r7   r   rV   r0   r,   r-   r<   T  s     )rU   r#   r%   issubsetr?   re   rf   rL   r   Zfree_symbolsr_   rd   r   rc   r   r   r   )r*   r`   Zcond_symbolsra   r,   r   r-   probabilityH  s    
zFinitePSpace.probabilityc                    s8   |  | | | fdd| j D }t |S )Nc                    s$   i | ]\}}  |r|| qS r,   ri   r|   r_   r   r,   r-   rr   Y  s    
 z2FinitePSpace.conditional_space.<locals>.<dictcomp>)r   r   r~   r[   r{   r*   r`   r   r,   r   r-   conditional_spaceV  s    

zFinitePSpace.conditional_spacer,   scipyc                 C   s   | j | j|||iS )zo
        Internal sample method

        Returns dictionary mapping RandomSymbol to realization value.
        )r   distributionsample)r*   sizeZlibraryseedr,   r,   r-   r   ]  s    zFinitePSpace.sample)F)N)r,   r   N)r1   r2   r3   r4   rJ   rM   r   r   r   r   r   r   r   r   r   r   r   r   r   r,   r,   r,   r-   r{      s&   		
	


r{   c                   @   s   e Zd ZdZedd Zedd Zedd Zdd	 Zee	d
d Z
e	dd Ze	dd Zdd Zdd Zdd ZdddZdd Zdd ZdS )SingleFinitePSpacea  
    A single finite probability space

    Represents the probabilities of a set of random events that can be
    attributed to a single variable/symbol.

    This class is implemented by many of the standard FiniteRV types such as
    Die, Bernoulli, Coin, etc....
    c                 C   s   t | j| jjS r7   )rK   rO   r   rP   r0   r,   r,   r-   r_   p  s    zSingleFinitePSpace.domainc                 C   s   | j jS )z
        Helper property to check if the distribution
        of the random variable is having symbolic
        dimension.
        )r   rs   r0   r,   r,   r-   _is_symbolict  s    zSingleFinitePSpace._is_symbolicc                 C   s
   | j d S rR   rA   r0   r,   r,   r-   r   }  s    zSingleFinitePSpace.distributionc                 C   s   | j |S r7   )r   rp   r*   r   r,   r,   r-   rp     s    zSingleFinitePSpace.pmfc                    s    fdd j j D S )Nc                    s    i | ]\}}t  j|f|qS r,   rQ   )r9   r;   r   r0   r,   r-   rr     s    z/SingleFinitePSpace._density.<locals>.<dictcomp>)r   r/   r[   r0   r,   r0   r-   r~     s    

zSingleFinitePSpace._densityc                 C   s~   | j r^| |}tddd}td}t|t||tt| |  || jd j| jd j	fS t
|| j}t| j| j|S Nr   Tr   kirS   )r   r   r   r   r   r   r   rB   lowhighr%   rv   r{   r_   r   r   r*   r   r   r   r   r,   r,   r-   r     s    
:z2SingleFinitePSpace.compute_characteristic_functionc                 C   sz   | j rZ| |}tddd}td}t|t||t||  || jd j| jd jfS t	|| j
}t| j| j|S r   )r   r   r   r   r   r   rB   r   r   r%   rv   r{   r_   r   r   r   r,   r,   r-   r     s    
6z5SingleFinitePSpace.compute_moment_generating_functionc                 C   s.   | j rtdt|| j}t| j| j|S )NzComputing quantile for random variables with symbolic dimension because the bounds of searching the required value is undetermined.)r   rj   r%   rv   r{   r_   r   r   r   r,   r,   r-   r     s    z#SingleFinitePSpace.compute_quantilec              	   C   s   | j rtt|d }tddd}t|ttfs4dn
|||}t|t	| 
|t|| jd jk|| jd jk|ftjdfS t|| j}t| j| j|S )Nr   rq   TintegerrS   )r   rl   r#   r   rL   r   r   r   r   r   rp   r   rB   r   r   r   r   r%   rv   r{   r_   r   r   )r*   r   r   rq   ra   r,   r,   r-   r     s     
 z"SingleFinitePSpace.compute_densityc                 C   sb   | j rB| |}td}td}t|t|||| jd j|fS t|| j}t	| j
| j|S )Nrq   r   rS   )r   r   r   r   r   rB   r   r%   rv   r{   r_   r   r   )r*   r   r   rq   r   r,   r,   r-   r     s    
"zSingleFinitePSpace.compute_cdfNc                 K   s   | j rt|d }tddd}|||}t|ttfs<dn|}|dkrV| || n| || }tt	||ft
jdf|| jj| jjf S t|}t||}t| j| jj||f|S )Nr   rq   Tr   )r   r#   r   r   rL   r   r   rp   r   r   r   r   r   r   r   Zdoitr   r%   r{   r_   r   )r*   r   r   r   r   rq   ra   funcr,   r,   r-   r     s    $
z&SingleFinitePSpace.compute_expectationc                 C   s*   | j rtdt|}t| j| j|S )NzhCurrently, probability queries are not supported for random variables with symbolic sized distributions.)r   rj   r%   r{   r_   r   r   r   r,   r,   r-   r     s    zSingleFinitePSpace.probabilityc                    sB   | j r
|  | | | | fdd| j D }t |S )z
        This method is used for transferring the
        computation to probability method because
        conditional space of random variables with
        symbolic dimensions is currently not possible.
        c                    s$   i | ]\}}  |r|| qS r,   ri   r|   r   r,   r-   rr     s    
 z8SingleFinitePSpace.conditional_space.<locals>.<dictcomp>)r   r   r   r~   r[   r{   r   r,   r   r-   r     s    

z$SingleFinitePSpace.conditional_space)N)r1   r2   r3   r4   r5   r_   r   r   rp   r   r~   r   r   r   r   r   r   r   r   r,   r,   r,   r-   r   f  s*   	



	
		
r   c                   @   sL   e Zd ZdZedd Zeedd Zeedd Zdd	 Z	d
d Z
dS )ProductFinitePSpacezG
    A collection of several independent finite probability spaces
    c                 C   s   t dd | jD  S )Nc                 S   s   g | ]
}|j qS r,   )r_   r9   spacer,   r,   r-   rD     s     z.ProductFinitePSpace.domain.<locals>.<listcomp>)rZ   spacesr0   r,   r,   r-   r_     s    zProductFinitePSpace.domainc                 C   s`   t dd | jD  }i }|D ]:}tt| \}}t|}t| }||tj| ||< qt	|S )Nc                 S   s   g | ]}t |j qS r,   )iterr~   r[   r   r,   r,   r-   rD     s   z0ProductFinitePSpace._density.<locals>.<listcomp>)
r   r   rl   r   r$   r   r   r   r   r   )r*   r]   r   r[   Zelemsr   rW   r   r,   r,   r-   r~     s    zProductFinitePSpace._densityc                 C   s
   t | jS r7   )r   r~   r0   r,   r,   r-   r     s    zProductFinitePSpace.densityc                 C   s   t | |S r7   )r{   r   r   r,   r,   r-   r     s    zProductFinitePSpace.probabilityc                 C   s   t | |S r7   )r{   r   r   r,   r,   r-   r     s    z#ProductFinitePSpace.compute_densityN)r1   r2   r3   r4   r5   r_   r   r~   r   r   r   r,   r,   r,   r-   r     s   
r   N)@r4   	itertoolsr   Zsympy.concrete.summationsr   Zsympy.core.basicr   Zsympy.core.cacher   Zsympy.core.functionr   Zsympy.core.mulr   Zsympy.core.numbersr   r	   Zsympy.core.relationalr   Zsympy.core.singletonr   Zsympy.core.symbolr   r   Zsympy.core.sympifyr   Z&sympy.functions.elementary.exponentialr   Z$sympy.functions.elementary.piecewiser   Zsympy.logic.boolalgr   r   Zsympy.sets.setsr   Zsympy.core.containersr   Zsympy.core.logicr   r   r   r   Zsympy.stats.rvr   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r/   r)   r6   rK   rZ   r^   rk   r{   r   r   r,   r,   r,   r-   <module>   s<   	8%1)||