
    wg+                     P    d dl mZmZ d dlZ G d de      Zd Zd Zd Zd Zd	 Z	y)
    )BasicIntegerNc                       e Zd ZdZdZdZdZd ZddZe	d        Z
e	d        Zd	 Zd
 Ze	d        Ze	d        Zed        Zy)GrayCodea  
    A Gray code is essentially a Hamiltonian walk on
    a n-dimensional cube with edge length of one.
    The vertices of the cube are represented by vectors
    whose values are binary. The Hamilton walk visits
    each vertex exactly once. The Gray code for a 3d
    cube is ['000','100','110','010','011','111','101',
    '001'].

    A Gray code solves the problem of sequentially
    generating all possible subsets of n objects in such
    a way that each subset is obtained from the previous
    one by either deleting or adding a single object.
    In the above example, 1 indicates that the object is
    present, and 0 indicates that its absent.

    Gray codes have applications in statistics as well when
    we want to compute various statistics related to subsets
    in an efficient manner.

    Examples
    ========

    >>> from sympy.combinatorics import GrayCode
    >>> a = GrayCode(3)
    >>> list(a.generate_gray())
    ['000', '001', '011', '010', '110', '111', '101', '100']
    >>> a = GrayCode(4)
    >>> list(a.generate_gray())
    ['0000', '0001', '0011', '0010', '0110', '0111', '0101', '0100',     '1100', '1101', '1111', '1110', '1010', '1011', '1001', '1000']

    References
    ==========

    .. [1] Nijenhuis,A. and Wilf,H.S.(1978).
           Combinatorial Algorithms. Academic Press.
    .. [2] Knuth, D. (2011). The Art of Computer Programming, Vol 4
           Addison Wesley


    Fr   Nc                     |dk  st        |      |k7  rt        d|z        t        |      }|f|z   }t        j                  | g| }d|v rG|d   |_        t        |j
                        |kD  r#t        dt        |j
                        |fz        |S d|v rft        |d         |d   k7  rt        d|d   z        t        |d         |j                  z  |_        |j                  ||j                        |_        |S )ax  
        Default constructor.

        It takes a single argument ``n`` which gives the dimension of the Gray
        code. The starting Gray code string (``start``) or the starting ``rank``
        may also be given; the default is to start at rank = 0 ('0...0').

        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> a = GrayCode(3)
        >>> a
        GrayCode(3)
        >>> a.n
        3

        >>> a = GrayCode(3, start='100')
        >>> a.current
        '100'

        >>> a = GrayCode(4, rank=4)
        >>> a.current
        '0110'
        >>> a.rank
        4

           z6Gray code dimension must be a positive integer, not %istart?Gray code start has length %i but should not be greater than %irankz1Gray code rank must be a positive integer, not %i)
int
ValueErrorr   r   __new___currentlen
selections_rankunrank)clsnargskw_argsobjs        a/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/combinatorics/graycode.pyr   zGrayCode.__new__6   s   : q5CFaKH1LN NAJtd{mmC'$'g"7+CL3<< 1$  "036s||3Da2H"I J J 
 w76?#wv6  ""6?"+ , ,GFO,s~~=CI::a3CL
    c                 d    t        | j                  | j                  |z   | j                  z        S )aX  
        Returns the Gray code a distance ``delta`` (default = 1) from the
        current value in canonical order.


        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> a = GrayCode(3, start='110')
        >>> a.next().current
        '111'
        >>> a.next(-1).current
        '010'
        )r   )r   r   r   r   )selfdeltas     r   nextzGrayCode.nextf   s'      dii%&74??%JKKr   c                      d| j                   z  S )z
        Returns the number of bit vectors in the Gray code.

        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> a = GrayCode(3)
        >>> a.selections
        8
           )r   r   s    r   r   zGrayCode.selectionsx   s     $&&yr   c                      | j                   d   S )z
        Returns the dimension of the Gray code.

        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> a = GrayCode(5)
        >>> a.n
        5
        r   )r   r!   s    r   r   z
GrayCode.n   s     yy|r   c              +   F  K   | j                   }d}d|v r|d   }n'd|v r#t        j                  | j                   |d         }||| _        | j                  }t        |      }t        |      | j                   kD  rt        dt        |      |fz        t        |d      | _        t        dj                  |      d      }t        |d|z        D ]H  }| j                  rd| _        n| j                   ||dz   z  }||dz	  z  }	| j                  |	z  | _        J d	| _        yw)
a  
        Generates the sequence of bit vectors of a Gray Code.

        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> a = GrayCode(3)
        >>> list(a.generate_gray())
        ['000', '001', '011', '010', '110', '111', '101', '100']
        >>> list(a.generate_gray(start='011'))
        ['011', '010', '110', '111', '101', '100']
        >>> list(a.generate_gray(rank=4))
        ['110', '111', '101', '100']

        See Also
        ========

        skip

        References
        ==========

        .. [1] Knuth, D. (2011). The Art of Computer Programming,
               Vol 4, Addison Wesley

        Nr	   r   r
   r     r   Fr   )r   r   r   r   currentgray_to_binr   r   r   joinrange_skip)
r   hintsbitsr	   r%   graycode_bingraycode_intibbtcgbtcs
             r   generate_grayzGrayCode.generate_gray   s&    8 vve'NEu_OODFFE&M:E!DM,,"7+|tvv% %(+L(94'@A B BGQ277<0!4|Q$Y/ 	3Azz"
ll"QKDDAI&D!]]T1DM	3 s   DD!c                     d| _         y)a  
        Skips the bit generation.

        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> a = GrayCode(3)
        >>> for i in a.generate_gray():
        ...     if i == '010':
        ...         a.skip()
        ...     print(i)
        ...
        000
        001
        011
        010
        111
        101
        100

        See Also
        ========

        generate_gray
        TN)r)   r!   s    r   skipzGrayCode.skip   s    6 
r   c                 z    | j                   $t        t        | j                        d      | _         | j                   S )a  
        Ranks the Gray code.

        A ranking algorithm determines the position (or rank)
        of a combinatorial object among all the objects w.r.t.
        a given order. For example, the 4 bit binary reflected
        Gray code (BRGC) '0101' has a rank of 6 as it appears in
        the 6th position in the canonical ordering of the family
        of 4 bit Gray codes.

        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> a = GrayCode(3)
        >>> list(a.generate_gray())
        ['000', '001', '011', '010', '110', '111', '101', '100']
        >>> GrayCode(3, start='100').rank
        7
        >>> GrayCode(3, rank=7).current
        '100'

        See Also
        ========

        unrank

        References
        ==========

        .. [1] https://web.archive.org/web/20200224064753/http://statweb.stanford.edu/~susan/courses/s208/node12.html

        r    )r   r   r&   r%   r!   s    r   r   zGrayCode.rank   s0    F ::[6:DJzzr   c                     | j                   xs d}t        |t              st        |      dd }|j	                  | j
                  d      S )z
        Returns the currently referenced Gray code as a bit string.

        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> GrayCode(3, start='100').current
        '100'
        0r    N)r   
isinstancestrbinrjustr   )r   rvs     r   r%   zGrayCode.current  s@     ]]!c"c"RBxx$$r   c                      fd ||      S )a  
        Unranks an n-bit sized Gray code of rank k. This method exists
        so that a derivative GrayCode class can define its own code of
        a given rank.

        The string here is generated in reverse order to allow for tail-call
        optimization.

        Examples
        ========

        >>> from sympy.combinatorics import GrayCode
        >>> GrayCode(5, rank=3).current
        '00010'
        >>> GrayCode.unrank(5, 3)
        '00010'

        See Also
        ========

        rank
        c                     |dk(  rt        | dz        S d|dz
  z  }| |k  rd | |dz
        z   S d || |z  z
  dz
  |dz
        z   S )Nr   r    r6   1)r8   )kr   m_unranks      r   rA   z GrayCode.unrank.<locals>._unrank8  sd    Av1q5z!AE
A1uWQA...a!eq!a%888r    )r   r   r   rA   s      @r   r   zGrayCode.unrank   s    0	9 tQr   )r   )__name__
__module____qualname____doc__r)   r   r   r   r   propertyr   r   r1   r3   r   r%   classmethodr   rB   r   r   r   r      s    )V EHE.`L$    3j: $ $L % %     r   r   c                     dj                  t        |       D cg c]  }t        j                  d       c}      S c c}w )z
    Generates a random bitlist of length n.

    Examples
    ========

    >>> from sympy.combinatorics.graycode import random_bitstring
    >>> random_bitstring(3) # doctest: +SKIP
    100
    r$   01)r'   r(   randomchoice)r   r.   s     r   random_bitstringrM   B  s.     77q:AFMM$':;;:s   <c           	          | d   g}t        dt        |             D ]%  }|t        t        ||dz
     | |   k7              z  }' dj	                  |      S )a  
    Convert from Gray coding to binary coding.

    We assume big endian encoding.

    Examples
    ========

    >>> from sympy.combinatorics.graycode import gray_to_bin
    >>> gray_to_bin('100')
    '111'

    See Also
    ========

    bin_to_gray
    r   r   r$   r(   r   r8   r   r'   bin_listbr.   s      r   r&   r&   P  s\    $ 
!A1c(m$ /	SQq1uX!,-../771:r   c           
          | d   g}t        dt        |             D ].  }|t        t        | |         t        | |dz
           z        z  }0 dj	                  |      S )a  
    Convert from binary coding to gray coding.

    We assume big endian encoding.

    Examples
    ========

    >>> from sympy.combinatorics.graycode import bin_to_gray
    >>> bin_to_gray('111')
    '100'

    See Also
    ========

    gray_to_bin
    r   r   r$   rO   rP   s      r   bin_to_grayrT   h  sa    $ 
!A1c(m$ :	SXa[!CQ$8899:771:r   c                     t        |       t        |      k7  rt        d      t        |      D cg c]  \  }}||   dk(  r| |    c}}S c c}}w )ai  
    Gets the subset defined by the bitstring.

    Examples
    ========

    >>> from sympy.combinatorics.graycode import get_subset_from_bitstring
    >>> get_subset_from_bitstring(['a', 'b', 'c', 'd'], '0011')
    ['c', 'd']
    >>> get_subset_from_bitstring(['c', 'a', 'c', 'c'], '1100')
    ['c', 'a']

    See Also
    ========

    graycode_subsets
    z$The sizes of the lists are not equalr>   )r   r   	enumerate)	super_set	bitstringr.   js       r   get_subset_from_bitstringrZ     sX    $ 9~Y'?@@%.y%9 $TQ|s" aL $ $ $s   Ac              #      K   t        t        t        |             j                               D ]  }t	        | |        yw)a`  
    Generates the subsets as enumerated by a Gray code.

    Examples
    ========

    >>> from sympy.combinatorics.graycode import graycode_subsets
    >>> list(graycode_subsets(['a', 'b', 'c']))
    [[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'],     ['a', 'c'], ['a']]
    >>> list(graycode_subsets(['a', 'b', 'c', 'c']))
    [[], ['c'], ['c', 'c'], ['c'], ['b', 'c'], ['b', 'c', 'c'],     ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'], ['a', 'b', 'c', 'c'],     ['a', 'b', 'c'], ['a', 'c'], ['a', 'c', 'c'], ['a', 'c'], ['a']]

    See Also
    ========

    get_subset_from_bitstring
    N)listr   r   r1   rZ   )gray_code_setrX   s     r   graycode_subsetsr^     s>     * (3}#56DDFG B	'yAABs   A A)

sympy.corer   r   rK   r   rM   r&   rT   rZ   r^   rB   r   r   <module>r`      s4    % y u y x	<00$0Br   