o
    ohA                     @   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                   @   $   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 )z
        Make instance of a class callable.

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

        Otherwise, return 0.
        r   r   )selfitem r-   c/var/www/html/construction_image-detection-poc/venv/lib/python3.10/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.   r0   6   s   zFiniteDensity.dictN)__name__
__module____qualname____doc__r/   propertyr0   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   elementsr1   r-   r-   r.   symbolsE      zFiniteDomain.symbolsc                 C   
   | j d S Nr   argsr1   r-   r-   r.   r@   I      
zFiniteDomain.elementsc                 C      t dd | jD  S )Nc                 S   s   g | ]}t t|qS r-   )r   r0   )r:   elr-   r-   r.   
<listcomp>O       z%FiniteDomain.dict.<locals>.<listcomp>r?   r1   r-   r-   r.   r0   M   rB   zFiniteDomain.dictc                 C   
   || j v S r8   )r@   r+   otherr-   r-   r.   __contains__Q      
zFiniteDomain.__contains__c                 C   s
   | j  S r8   )r@   __iter__r1   r-   r-   r.   rQ   T   rP   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
   r9   r-   r-   r.   rJ   X       z6FiniteDomain.as_boolean.<locals>.<listcomp>.<listcomp>)r   )r:   r,   r-   r-   r.   rJ   X   s    z+FiniteDomain.as_boolean.<locals>.<listcomp>)r   r1   r-   r-   r.   
as_booleanW   s   zFiniteDomain.as_booleanN)r2   r3   r4   r5   	is_Finiter6   rA   r@   r0   rO   rQ   rS   r-   r-   r-   r.   r7   =   s    


r7   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 r8   )
isinstancer   r   r   __new__)clssymbolsetr-   r-   r.   rW   b   s
   
zSingleFiniteDomain.__new__c                 C   rC   rD   rE   r1   r-   r-   r.   rY   h   rG   zSingleFiniteDomain.symbolc                 C   
   t | jS r8   r   rY   r1   r-   r-   r.   rA   l   rG   zSingleFiniteDomain.symbolsc                 C   rC   N   rE   r1   r-   r-   r.   rZ   p   rG   zSingleFiniteDomain.setc                    s   t  fdd jD  S )Nc                    s   g | ]
}t  j|ffqS r-   	frozensetrY   r:   elemr1   r-   r.   rJ   v       z/SingleFiniteDomain.elements.<locals>.<listcomp>)r   rZ   r1   r-   r1   r.   r@   t   s   zSingleFiniteDomain.elementsc                        fdd j D S )Nc                 3   s     | ]}t  j|ffV  qd S r8   r_   ra   r1   r-   r.   r=   y   s    z.SingleFiniteDomain.__iter__.<locals>.<genexpr>rZ   r1   r-   r1   r.   rQ   x      zSingleFiniteDomain.__iter__c                 C   s$   t |d \}}|| jko|| jv S rD   )tuplerY   rZ   )r+   rN   r;   r<   r-   r-   r.   rO   {   s   zSingleFiniteDomain.__contains__N)r2   r3   r4   r5   rW   r6   rY   rA   rZ   r@   rQ   rO   r-   r-   r-   r.   rU   [   s    



rU   c                   @   r)   )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 r8   )r$   )r:   itemsr-   r-   r.   r=      r>   z/ProductFiniteDomain.__iter__.<locals>.<genexpr>)r   domains)r+   proditerr-   r-   r.   rQ      s   
zProductFiniteDomain.__iter__c                 C   s   t |  S r8   r   r1   r-   r-   r.   r@      s   zProductFiniteDomain.elementsN)r2   r3   r4   r5   rQ   r6   r@   r-   r-   r-   r.   rh      s
    rh   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   rW   )rX   domain	conditioncondr-   r-   r.   rW      s   zConditionalFiniteDomain.__new__c                 C   s>   | j t|}|dv r|S |jr|j|jkS tdt| )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 %s)rn   xreplacer0   is_Equalitylhsrhs
ValueErrorstr)r+   rb   r<   r-   r-   r.   _test   s   zConditionalFiniteDomain._testc                 C   s   || j v o	| |S r8   )
fulldomainrv   rM   r-   r-   r.   rO      rf   z$ConditionalFiniteDomain.__contains__c                    rd   )Nc                 3   s    | ]
}  |r|V  qd S r8   rv   ra   r1   r-   r.   r=      s    z3ConditionalFiniteDomain.__iter__.<locals>.<genexpr>)rw   r1   r-   r1   r.   rQ      rf   z ConditionalFiniteDomain.__iter__c                    s.   t  jtrt fdd jjD  S td)Nc                    s&   g | ]}t  jj|ff v r|qS r-   )r`   rw   rY   ra   r1   r-   r.   rJ      s    z/ConditionalFiniteDomain.set.<locals>.<listcomp>z7Not implemented on multi-dimensional conditional domain)rV   rw   rU   r   rZ   NotImplementedErrorr1   r-   r1   r.   rZ      s
   zConditionalFiniteDomain.setc                 C   s
   t | S r8   )r7   rS   r1   r-   r-   r.   rS      rP   z"ConditionalFiniteDomain.as_booleanN)r2   r3   r4   r5   rW   rv   rO   rQ   r6   rZ   rS   r-   r-   r-   r.   rl      s    	
rl   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 r8   )listmapr   r   rW   )rX   rF   r-   r-   r.   rW      s   z SingleFiniteDistribution.__new__c                  G   s   d S r8   r-   rE   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)r:   kr1   r-   r.   
<dictcomp>   rK   z1SingleFiniteDistribution.dict.<locals>.<dictcomp>)is_symbolicr'   rZ   r1   r-   r1   r.   r0      s   zSingleFiniteDistribution.dictc                 G      t  r8   ry   r+   rF   r-   r-   r.   r      s   zSingleFiniteDistribution.pmfc                 C   r   r8   r   r1   r-   r-   r.   rZ      s   zSingleFiniteDistribution.setc                 C      | j jS r8   )r0   valuesr1   r-   r-   r.   <lambda>       z!SingleFiniteDistribution.<lambda>c                 C   r   r8   )r0   ri   r1   r-   r-   r.   r      r   c                 C   s   dS )NFr-   r1   r-   r-   r.   r      s    c                 C   r   r8   )r0   rQ   r1   r-   r-   r.   r      r   c                 C   r   r8   )r0   __getitem__r1   r-   r-   r.   r      r   c                 G   s
   | j | S r8   r~   r   r-   r-   r.   r/      rP   z!SingleFiniteDistribution.__call__c                 C   rL   r8   re   rM   r-   r-   r.   rO      rP   z%SingleFiniteDistribution.__contains__N)r2   r3   r4   rW   staticmethodr}   r6   r   r0   r   rZ   r   ri   r   rQ   r   r/   rO   r-   r-   r-   r.   rz      s"    

rz   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   r:   keyr<   r-   r-   r.   r      s    z(FinitePSpace.__new__.<locals>.<dictcomp>)ri   r   r    rW   _density)rX   rm   densitypublic_densityobjr-   r-   r.   rW      s   zFinitePSpace.__new__c                 C   sL   t |}| j}tt| d tr||tjS |t	|d d tjS )Nr   r^   )
r   r   rV   r{   keysr   getr   Zerorg   )r+   rb   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 r8   )rY   rA   )r:   rr1   r-   r.   r=     s    z%FinitePSpace.where.<locals>.<genexpr>)allr#   rl   rm   r+   rn   r-   r1   r.   where  s   zFinitePSpace.wherec                 C   sP   t || j}t }| jD ]}|t|}| |}||tj	| ||< q|S r8   )
r%   r   r*   rm   rp   r0   r   r   r   r   )r+   exprdrb   r<   probr-   r-   r.   compute_density  s   

zFinitePSpace.compute_densityc                 C   sH   |  |}tj}g }t|D ]}|| }||7 }|||f qt|S r8   )r   r   r   sortedappendr0   )r+   r   r   cum_probcdfr   r   r-   r-   r.   compute_cdf  s   
zFinitePSpace.compute_cdfFc                 C   s<   |  |}t| }t|dd d}|rdd |D }|S )Nc                 S   s   | d S r]   r-   )val_cumprobr-   r-   r.   r     r   z)FinitePSpace.sorted_cdf.<locals>.<lambda>)r   c                 S   s   g | ]
\}}|t |fqS r-   )float)r:   vr   r-   r-   r.   rJ   !  s    z+FinitePSpace.sorted_cdf.<locals>.<listcomp>)r   r{   ri   r   )r+   r   python_floatr   ri   sorted_itemsr-   r-   r.   
sorted_cdf  s   
zFinitePSpace.sorted_cdfc                    6   |  |}tddd t t fdd| D S )NtTrealc                 3   s(    | ]\}}t t|   | V  qd S r8   )r   r   r:   r   r   r   r-   r.   r=   *  s   & z?FinitePSpace.compute_characteristic_function.<locals>.<genexpr>r   r   r   sumri   r+   r   r   r-   r   r.   compute_characteristic_function%     
 z,FinitePSpace.compute_characteristic_functionc                    r   )Nr   Tr   c                 3   s$    | ]\}}t |  | V  qd S r8   r   r   r   r-   r.   r=   1  s   " zBFinitePSpace.compute_moment_generating_function.<locals>.<genexpr>r   r   r-   r   r.   "compute_moment_generating_function,  r   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   ra   r1   r-   r.   rJ   6  s    z4FinitePSpace.compute_expectation.<locals>.<listcomp>c                 S   s   g | ]
}t |d  d qS )r   r^   )rg   ra   r-   r-   r.   rJ   8  rc   c                       g | ]	}  t|qS r-   rp   r0   ra   r   r-   r.   rJ   9  rR   c                    r   r-   r   ra   r   r-   r.   rJ   ;  rR   c                 S   s   g | ]}d qS )Tr-   ra   r-   r-   r.   rJ   <  s    c                 s   s.    | ]\}}}t || |ftjd fV  qdS )TN)r   r   r   )r:   r   rb   blvr-   r-   r.   r=   =  s     z3FinitePSpace.compute_expectation.<locals>.<genexpr>)r   r%   rm   rV   r   r   r   zip)r+   r   rvskwargsprobsparse_domain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 }qt|t| S )NpTr   r   r^   )r   r   r	   ri   r   r   )r+   r   r   r   rZ   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rG|j	j
j	sGt jtr6 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 r8   )rY   )r:   rsr-   r-   r.   r=   I  s    z+FinitePSpace.probability.<locals>.<genexpr>z)Cannot compare foreign random symbols, %sc                 3   s>    | ]}t | t|d  d ftjdfV  qdS )r   r^   TN)r   r   subsr{   r   r   ra   rn   rvr+   r-   r.   r=   Q  s     c                 3   s    | ]}  |V  qd S r8   r   ra   r1   r-   r.   r=   T  s    )r`   r#   r%   issubsetrA   rt   ru   rV   r   free_symbolsrm   rs   r   rr   r   r   r   )r+   rn   cond_symbolsro   r-   r   r.   probabilityH  s   
 zFinitePSpace.probabilityc                    s8   |  | | | fdd| j D }t |S )Nc                    $   i | ]\}}  |r|| qS r-   rx   r   rm   r   r-   r.   r   Y      z2FinitePSpace.conditional_space.<locals>.<dictcomp>)r   r   r   ri   r   r+   rn   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+   sizelibraryseedr-   r-   r.   r   ]  s   zFinitePSpace.sample)Fr8   )r-   r   N)r2   r3   r4   r5   rT   rW   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 r8   )rU   rY   r   rZ   r1   r-   r-   r.   rm   p  s   zSingleFinitePSpace.domainc                 C   r   )z
        Helper property to check if the distribution
        of the random variable is having symbolic
        dimension.
        )r   r   r1   r-   r-   r.   _is_symbolict  s   zSingleFinitePSpace._is_symbolicc                 C   rC   r]   rE   r1   r-   r-   r.   r   }  rG   zSingleFinitePSpace.distributionc                 C   s   | j |S r8   )r   r   r+   r   r-   r-   r.   r        zSingleFinitePSpace.pmfc                    s    fdd j j D S )Nc                    s    i | ]\}}t  j|f|qS r-   r\   )r:   r<   r   r1   r-   r.   r     s    z/SingleFinitePSpace._density.<locals>.<dictcomp>)r   r0   ri   r1   r-   r1   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   kir^   )r   r   r   r   r   r   r   rF   lowhighr%   r   r   rm   r   r   r+   r   r   r   r   r-   r-   r.   r     s   
:z2SingleFinitePSpace.compute_characteristic_functionc                 C   sz   | j r-| |}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   rF   r   r   r%   r   r   rm   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   ry   r%   r   r   rm   r   r   r   r-   r-   r.   r     s   z#SingleFinitePSpace.compute_quantilec              	   C   s   | j r@tt|d }tddd}t|ttfsd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   r   Tintegerr^   )r   r{   r#   r   rV   r   r   r   r   r   r   r   rF   r   r   r   r   r%   r   r   rm   r   r   )r+   r   r   r   ro   r-   r-   r.   r     s   
z"SingleFinitePSpace.compute_densityc                 C   sb   | j r!| |}td}td}t|t|||| jd j|fS t|| j}t	| j
| j|S )Nr   r   r^   )r   r   r   r   r   rF   r   r%   r   r   rm   r   r   )r+   r   r   r   r   r-   r-   r.   r     s   
"zSingleFinitePSpace.compute_cdfNc                 K   s   | j rHt|d }tddd}|||}t|ttfsdn|}|dkr+| || n| || }tt	||ft
jdf|| jj| jjf S t|}t||}t| j| jj||fi |S )Nr   r   Tr   )r   r#   r   r   rV   r   r   r   r   r   r   r   r   r   r   doitr   r%   r   rm   r   )r+   r   r   r   r   r   ro   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   ry   r%   r   rm   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                    r   r-   rx   r   r   r-   r.   r     r   z8SingleFinitePSpace.conditional_space.<locals>.<dictcomp>)r   r   r   r   ri   r   r   r-   r   r.   r     s   


z$SingleFinitePSpace.conditional_spacer8   )r2   r3   r4   r5   r6   rm   r   r   r   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   rH   )Nc                 S   s   g | ]}|j qS r-   )rm   r:   spacer-   r-   r.   rJ     s    z.ProductFinitePSpace.domain.<locals>.<listcomp>)rh   spacesr1   r-   r-   r.   rm     rB   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   ri   r   r-   r-   r.   rJ     s    z0ProductFinitePSpace._density.<locals>.<listcomp>)
r   r   r{   r   r$   r   r   r   r   r   )r+   rk   r   ri   elemsr   rb   r   r-   r-   r.   r     s   zProductFinitePSpace._densityc                 C   r[   r8   )r   r   r1   r-   r-   r.   r     s   
zProductFinitePSpace.densityc                 C      t | |S r8   )r   r   r   r-   r-   r.   r     r   zProductFinitePSpace.probabilityc                 C   r   r8   )r   r   r   r-   r-   r.   r     r   z#ProductFinitePSpace.compute_densityN)r2   r3   r4   r5   r6   rm   r   r   r   r   r   r-   r-   r-   r.   r     s    
r   N)@r5   	itertoolsr   sympy.concrete.summationsr   sympy.core.basicr   sympy.core.cacher   sympy.core.functionr   sympy.core.mulr   sympy.core.numbersr   r	   sympy.core.relationalr   sympy.core.singletonr   sympy.core.symbolr   r   sympy.core.sympifyr   &sympy.functions.elementary.exponentialr   $sympy.functions.elementary.piecewiser   sympy.logic.boolalgr   r   sympy.sets.setsr   sympy.core.containersr   sympy.core.logicr   r   r   r   sympy.stats.rvr   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r0   r*   r7   rU   rh   rl   rz   r   r   r   r-   r-   r-   r.   <module>   s>    	8%1)||