a
    <bA                     @   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 |}|| v 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,   _/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/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       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   r=   z%FiniteDomain.dict.<locals>.<listcomp>r>   r0   r,   r,   r-   r/   M   s    zFiniteDomain.dictc                 C   s
   || j v 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-   rI   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-   rE   X   r=   z6FiniteDomain.as_boolean.<locals>.<listcomp>.<listcomp>)r   )r9   r+   r,   r,   r-   rE   X   r=   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/   rH   rI   rJ   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-   rN   b   s
    
zSingleFiniteDomain.__new__c                 C   s
   | j d S rA   rB   r0   r,   r,   r-   rP   h   s    zSingleFiniteDomain.symbolc                 C   s
   t | jS r7   r   rP   r0   r,   r,   r-   r@   l   s    zSingleFiniteDomain.symbolsc                 C   s
   | j d S N   rB   r0   r,   r,   r-   rQ   p   s    zSingleFiniteDomain.setc                    s   t  fdd jD  S )Nc                    s   g | ]}t  j|ffqS r,   	frozensetrP   r9   elemr0   r,   r-   rE   v   r=   z/SingleFiniteDomain.elements.<locals>.<listcomp>)r   rQ   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   rU   rW   r0   r,   r-   r<   y   r=   z.SingleFiniteDomain.__iter__.<locals>.<genexpr>rQ   r0   r,   r0   r-   rI   x   s    zSingleFiniteDomain.__iter__c                 C   s$   t |d \}}|| jko"|| jv S rA   )tuplerP   rQ   )r*   rG   r:   r;   r,   r,   r-   rH   {   s    zSingleFiniteDomain.__contains__N)r1   r2   r3   r4   rN   r5   rP   r@   rQ   r?   rI   rH   r,   r,   r,   r-   rL   [   s   



rL   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<      r=   z/ProductFiniteDomain.__iter__.<locals>.<genexpr>)r   domains)r*   proditerr,   r,   r-   rI      s    
zProductFiniteDomain.__iter__c                 C   s   t |  S r7   r   r0   r,   r,   r-   r?      s    zProductFiniteDomain.elementsN)r1   r2   r3   r4   rI   r5   r?   r,   r,   r,   r-   r[      s   r[   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u r|S t |}t| ||S )zH
        Create a new instance of ConditionalFiniteDomain class
        T)r%   r   rN   )rO   domain	conditioncondr,   r,   r-   rN      s    zConditionalFiniteDomain.__new__c                 C   sB   | j t|}|dv 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)ra   xreplacer/   Zis_Equalitylhsrhs
ValueErrorstr)r*   rX   r;   r,   r,   r-   _test   s    zConditionalFiniteDomain._testc                 C   s   || j v o| |S r7   )
fulldomainrh   rF   r,   r,   r-   rH      s    z$ConditionalFiniteDomain.__contains__c                    s    fdd j D S )Nc                 3   s   | ]}  |r|V  qd S r7   rh   rW   r0   r,   r-   r<      r=   z3ConditionalFiniteDomain.__iter__.<locals>.<genexpr>)ri   r0   r,   r0   r-   rI      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 v r|qS r,   )rV   ri   rP   rW   r0   r,   r-   rE      s   z/ConditionalFiniteDomain.set.<locals>.<listcomp>z7Not implemented on multi-dimensional conditional domain)rM   ri   rL   r   rQ   NotImplementedErrorr0   r,   r0   r-   rQ      s
    zConditionalFiniteDomain.setc                 C   s
   t | S r7   )r6   rJ   r0   r,   r,   r-   rJ      s    z"ConditionalFiniteDomain.as_booleanN)r1   r2   r3   r4   rN   rh   rH   rI   r5   rQ   rJ   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| g|R  S r7   )listmapr   r   rN   )rO   rC   r,   r,   r-   rN      s    z SingleFiniteDistribution.__new__c                  G   s   d S r7   r,   rB   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>   r=   z1SingleFiniteDistribution.dict.<locals>.<dictcomp>)is_symbolicr'   rQ   r0   r,   r0   r-   r/      s    zSingleFiniteDistribution.dictc                 G   s
   t  d S r7   rk   r*   rC   r,   r,   r-   rq      s    zSingleFiniteDistribution.pmfc                 C   s
   t  d S r7   ru   r0   r,   r,   r-   rQ      s    zSingleFiniteDistribution.setc                 C   s   | j jS r7   )r/   valuesr0   r,   r,   r-   <lambda>   r=   z!SingleFiniteDistribution.<lambda>c                 C   s   | j jS r7   )r/   r\   r0   r,   r,   r-   rx      r=   c                 C   s   dS )NFr,   r0   r,   r,   r-   rx      r=   c                 C   s   | j jS r7   )r/   rI   r0   r,   r,   r-   rx      r=   c                 C   s   | j jS r7   )r/   __getitem__r0   r,   r,   r-   rx      r=   c                 G   s
   | j | S r7   rp   rv   r,   r,   r-   r.      s    z!SingleFiniteDistribution.__call__c                 C   s
   || j v S r7   rY   rF   r,   r,   r-   rH      s    z%SingleFiniteDistribution.__contains__N)r1   r2   r3   rN   staticmethodro   r5   r   r/   rq   rQ   rw   r\   rt   rI   ry   r.   rH   r,   r,   r,   r-   rl      s    

rl   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-   rs      s   z(FinitePSpace.__new__.<locals>.<dictcomp>)r\   r   r    rN   _density)rO   r`   densityZpublic_densityobjr,   r,   r-   rN      s    zFinitePSpace.__new__c                 C   sL   t |}| j}tt| d tr2||tjS |t	|d d tjS )Nr   rT   )
r   r~   rM   rm   keysr   getr   ZerorZ   )r*   rX   r   r,   r,   r-   prob_of   s
    zFinitePSpace.prob_ofc                    s*   t  fddt|D sJ t j|S )Nc                 3   s   | ]}|j  jv V  qd S r7   )rP   r@   )r9   rr0   r,   r-   r<     r=   z%FinitePSpace.where.<locals>.<genexpr>)allr#   r_   r`   r*   ra   r,   r0   r-   where  s    zFinitePSpace.wherec                 C   sP   t || j}t }| jD ]2}|t|}| |}||tj	| ||< q|S r7   )
r%   rw   r)   r`   rc   r/   r   r   r   r   )r*   exprdrX   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 rS   r,   )Zval_cumprobr,   r,   r-   rx     r=   z)FinitePSpace.sorted_cdf.<locals>.<lambda>)r}   c                 S   s   g | ]\}}|t |fqS r,   )float)r9   vr   r,   r,   r-   rE   !  s   z+FinitePSpace.sorted_cdf.<locals>.<listcomp>)r   rm   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   rr   r   r   r,   r-   r<   *  r=   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  r=   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   rW   r0   r,   r-   rE   6  r=   z4FinitePSpace.compute_expectation.<locals>.<listcomp>c                 S   s   g | ]}t |d  d qS )r   rT   )rZ   rW   r,   r,   r-   rE   8  r=   c                    s   g | ]}  t|qS r,   rc   r/   rW   r   r,   r-   rE   9  r=   c                    s   g | ]}  t|qS r,   r   rW   r   r,   r-   rE   ;  r=   c                 S   s   g | ]}d qS Tr,   rW   r,   r,   r-   rE   <  r=   c                 S   s*   g | ]"\}}}t || |ftjd fqS r   )r   r   r   )r9   r   rX   Zblvr,   r,   r-   rE   =  s   )rw   r%   r`   rM   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   rT   )r   r   r	   r\   r   r   )r*   r   r   r   rQ   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   )rP   )r9   rsr,   r,   r-   r<   I  r=   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   rT   TN)r   r   subsrm   r   r   rW   ra   rvr*   r,   r-   r<   Q  s
    c                 3   s   | ]}  |V  qd S r7   r   rW   r0   r,   r-   r<   T  r=   )rV   r#   r%   issubsetr@   rf   rg   rM   r   Zfree_symbolsr`   re   r   rd   r   r   r   )r*   ra   Zcond_symbolsrb   r,   r   r-   probabilityH  s    
zFinitePSpace.probabilityc                    s8   |  | | | fdd| j D }t |S )Nc                    s$   i | ]\}}  |r|| qS r,   rj   r|   r`   r   r,   r-   rs   Y  s   z2FinitePSpace.conditional_space.<locals>.<dictcomp>)r   r   r~   r\   r{   r*   ra   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   rK   rN   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   )rL   rP   r   rQ   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   rt   r0   r,   r,   r-   _is_symbolict  s    zSingleFinitePSpace._is_symbolicc                 C   s
   | j d S rS   rB   r0   r,   r,   r-   r   }  s    zSingleFinitePSpace.distributionc                 C   s   | j |S r7   )r   rq   r*   r   r,   r,   r-   rq     s    zSingleFinitePSpace.pmfc                    s    fdd j j D S )Nc                    s    i | ]\}}t  j|f|qS r,   rR   )r9   r;   r   r0   r,   r-   rs     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   kirT   )r   r   r   r   r   r   r   rC   lowhighr%   rw   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   rC   r   r   r%   rw   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   rk   r%   rw   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   rr   TintegerrT   )r   rm   r#   r   rM   r   r   r   r   r   rq   r   rC   r   r   r   r   r%   rw   r{   r`   r   r   )r*   r   r   rr   rb   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 )Nrr   r   rT   )r   r   r   r   r   rC   r   r%   rw   r{   r`   r   r   )r*   r   r   rr   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i |S )Nr   rr   Tr   )r   r#   r   r   rM   r   r   rq   r   r   r   r   r   r   r   Zdoitr   r%   r{   r`   r   )r*   r   r   r   r   rr   rb   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   rk   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,   rj   r|   r   r,   r-   rs     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   rq   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-   rE     r=   z.ProductFinitePSpace.domain.<locals>.<listcomp>)r[   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-   rE     s   z0ProductFinitePSpace._density.<locals>.<listcomp>)
r   r   rm   r   r$   r   r   r   r   r   )r*   r^   r   r\   elemsr   rX   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   rL   r[   r_   rl   r{   r   r   r,   r,   r,   r-   <module>   s<   	8%1)||