o hT@s>dZddlmZddlZddlZddlZddlZddlmZmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!gdZ"d*ddZ#d*d d Z$d+d d Z%GdddZ&d,ddZ'd-ddZ(d.ddZ)d/ddZ*ddZ+d0d d!Z,d1d"d#Z-d$d%Z.d*d&d'Z/d(d)Z0dS)2z. Useful utilities for working with bitarrays. )absolute_importN)bitarray bits2bytes)zerosonescount_nparity_ssqi xor_indices count_andcount_or count_xorany_andsubsetcorrespond_allbyteswap serialize deserializeba2hexhex2baba2basebase2ba sc_encode sc_decode vl_encode vl_decodecanonical_decode)#rrurandomrandom_krandom_p gen_primespprintstriprr sum_indicesr r r r rrrr intervalsrrrrba2intint2barrrrrr huffman_codecanonical_huffmanrcCs"ttt||}||d=|S)zdurandom(n, /, endian=None) -> bitarray Return random bitarray of length `n` (uses `os.urandom()`). N)rosrr)__lengthendianar-Z/var/www/html/HyperOracle/crypto_trader/venv/lib/python3.10/site-packages/bitarray/util.pyr-s rcCsJtjdddkr tdt||}t|ts tdt|j| |S)arandom_k(n, /, k, endian=None) -> bitarray Return (pseudo-) random bitarray of length `n` with `k` elements set to one. Mathematically equivalent to setting (in a bitarray of length `n`) all bits at indices `random.sample(range(n), k)` to one. The random bitarrays are reproducible when giving Python's `random.seed()` with a specific seed value. This function requires Python 3.9 or higher, as it depends on the standard library function `random.randbytes()`. Raises `NotImplementedError` when Python version is too low. N) z6bitarray.util.random_k() requires Python 3.9 or higherint expected, got '%s') sys version_infoNotImplementedError_Random isinstanceint TypeErrortype__name__r)__nkr+rr-r-r.r7s     r?cCs.tjdddkr tdt||}||S)aDrandom_p(n, /, p=0.5, endian=None) -> bitarray Return (pseudo-) random bitarray of length `n`, where each bit has probability `p` of being one (independent of any other bits). Mathematically equivalent to `bitarray((random() < p for _ in range(n)), endian)`, but much faster for large `n`. The random bitarrays are reproducible when giving Python's `random.seed()` with a specific seed value. This function requires Python 3.12 or higher, as it depends on the standard library function `random.binomialvariate()`. Raises `NotImplementedError` when Python version is too low. Nr/)r0 z7bitarray.util.random_p() requires Python 3.12 or higher)r3r4r5r6r)r<pr+r>r-r-r.rNs   rc@sNeZdZdZde>ZdZdddZdd Zd d Zd d Z ddZ ddZ dS)r6g{Gz?rNcCs||_t||_||_dSN)nrnbytesr+)selfrEr+r-r-r.__init__rs  z_Random.__init__cCs$tt|j|j}||jd=|S)zV Return bitarray with each bit having probability p = 1/2 of being 1. N)rrandom randbytesrFr+rE)rGr,r-r-r. random_halfws z_Random.random_halfcCsVd|kr |jksntd|j|ft|jdddd}||dd|jS)z Return bitarray containing operator sequence. Each item represents a bitwise operation: 0: AND 1: OR After applying the sequence (see .combine_half()), we obtain a bitarray with probability q = i / K rz0 < i < %d, got i = %dr/little byteorderrC)K ValueErrorrto_bytesindexM)rGir,r-r-r.op_seqsz_Random.op_seqcCs4|}|D]}|r||O}q||M}q|S)zm Combine random bitarrays with probability 1/2 according to given operator sequence. )rK)rGseqr,r=r-r-r. combine_halfs z_Random.combine_halfc Cs|j}|dks ||kr%|dkrt||jS||krt||jStd|||dkr8|||}||S|dksE||jd|krHd}n||}|dd|t |8}t ||jd}|dkrpt||j}| }n| | |}| |}tj}|dkrt| D]}||}||r||}||sd||<q|S|dkrt|D]}||}||s||}||rd||<q|S) Nrz&k must be in range 0 <= k <= n, got %sr/r0g?g?rC)rErr+rrPrinvertrOmathsqrtr8rWrUcountrI randrangerange) rGr=rEr,rTrAdiffr]_r-r-r.rsL         z_Random.random_kcsdks dks dkr0dkrt|j|jSdkr|Sdkr*t|j|jStd|jdkrEtfddt|jD|jSdkrV|d}| |S|j kre| t |jSt|j}|jd|dkr{|d7}||}||j}|jd kr|jt|d t|kkrtfd dt|jD|jS||}|krÈ|d|}|||O}|S|kr҈|}|||M}|S) Ngr??z*p must be in range 0.0 <= p <= 1.0, got %srXc3|] }tkVqdSrDrI.0r`rAr-r. z#_Random.random_p..rCdr0c3rbrDrcrdrfr-r.rgrh)rrEr+rKrrPrr^rrYSMALL_PrrIbinomialvariater8rOrUrFlenboolrW)rGrAr,rTrVqxr-rfr.rsH     ( z_Random.random_p)rN) r; __module__ __qualname__rSrOrjrHrKrUrWrrr-r-r-r.r6as    0r6Fc Cs@t|}|dkr td|r+td|}d|ddd<d|ddd<d|ddd <d }ntd |}d D] }d|dd|<q2d }||t|dt|9}t|||dd<||d=|r|ddtt|ddD]}d|d}d|||dd|<ql|S|ddtt|dD] }d|||dd|<q|S)a_gen_primes(n, /, endian=None, odd=False) -> bitarray Generate a bitarray of length `n` in which active indices are prime numbers. By default (`odd=False`), active indices correspond to prime numbers directly. When `odd=True`, only odd prime numbers are represented in the resulting bitarray `a`, and `a[i]` corresponds to `2*i+1` being prime or not. rzbitarray length must be >= 0irCNr0r/01110110)r/r0rsrt00110101rBra )r8rPrrlrsearchrZr[)r<r+oddrEr,frTjr-r-r.r s0   $  r rCcCsV|dvr td|d}t||krt||S|d}||dd}|d|dd}t||d|}|j}d}t|D]h} t|| || d|} td |j| d } |rn| |dkrn| jrgt| } d| | d <| } | r|| } | |kr~|nt| }|dkr|| | |7}q@| |kr|nt| d}|| | d|| |7}q@|S) zsum_indices(a, /, mode=1) -> int Return sum of indices of all active bits in bitarray `a`. Equivalent to `sum(i for i, v in enumerate(a) if v)`. `mode=2` sums square of indices. )rCr/zunexpected mode %rirBrCr/r0rN)buffer) rPrlr padbitsr^ memoryviewrr+readonlyr\)__amoderEmo1o2nblocksr~smrTvblockr=yz1z2r-r-r.r#&s8    r#rBPc Cs|durtj}t|tsddl}|j||||ddSt|}|dkr'tdt|}|dkr3tdt|}||krAtd||||d}||}|dkrW||d}t|j}t |d t |t |||k} | rsd } n|rxd } nd } | d || ft |D]-\} } | r| |dkr| d|d| |dkr| |dkr| d| t | q| r| d| d| | dS)apprint(bitarray, /, stream=None, group=8, indent=4, width=80) Pretty-print bitarray object to `stream`, defaults is `sys.stdout`. By default, bits are grouped in bytes (8 bits), and 64 bits per line. Non-bitarray objects are printed using `pprint.pprint()`. Nr)streamindentwidthrCzgroup must be >= 1zindent must be >= 0zwidth must be > %d (indent)r/rz''''z%s(%sz %s  z%s) )r3stdoutr7rr!r8rPr:r;rlwrite enumeratestrflush) rrgrouprr_pprintgplepl type_name multilinequotesrTbr-r-r.r!SsJ    $   r!rightcCst|tstdt|j|dvrtd||dkrdn|d}|dkr-|ddS|d kr3dn|jddd d}|||S) zstrip(bitarray, /, mode='right') -> bitarray Return a new bitarray with zeros stripped from left, right or both ends. Allowed values for mode are the strings: `left`, `right`, `both` zstr expected for mode, got '%s')leftrbothz.mode must be 'left', 'right' or 'both', got %rrNrCrrr)r7rr9r:r;rPfind)rrstartstopr-r-r.r"s   r"ccsz|d}Wn tyYdSwt|}d}||krD|}z || |}Wn ty2|}Ynwt|||fV| }||ksdSdS)zintervals(bitarray, /) -> iterator Compute all uninterrupted intervals of 1s and 0s, and return an iterator over tuples `(value, start, stop)`. The intervals are guaranteed to be in order, and their size is always non-zero (`stop - start > 0`). rN) IndexErrorrlrRrPr8)rvaluerErrr-r-r.r$s$   r$cCst|tstdt|jt|}|dkrtd|jr1t|j|j }|j dkr-||n||}t j | |j d}|rI||d?rI|d|>8}|S)zba2int(bitarray, /, signed=False) -> int Convert the given bitarray to an integer. The bit-endianness of the bitarray is respected. `signed` indicates whether two's complement is used to represent the integer. zbitarray expected, got '%s'rznon-empty bitarray expectedrLrMrC) r7rr9r:r;rlrPr~rr+r8 from_bytestobytes)rsignedlengthpadresr-r-r.r%s  r%c Cst|tstdt|j|dur#t|tstd|dkr#td|rT|dur-tdd|d>}| |kr>|ksIntd| ||f|dkrS|d|>7}n|rd||?rdtd d|>|ftd|}|jt | |j d }| ||j d k}|dur|rt ||rd Sd S|dSt||kr|r|d|S|| dSt||kr|St|t||j }|r||S||S)aint2ba(int, /, length=None, endian=None, signed=False) -> bitarray Convert the given integer to a bitarray (with given bit-endianness, and no leading (big-endian) / trailing (little-endian) zeros), unless the `length` of the bitarray is provided. An `OverflowError` is raised if the integer is not representable with the given number of bits. `signed` determines whether two's complement is used to represent the integer, and requires `length` to be provided. r2Nz"int expected for argument 'length'rzlength must be > 0z!signed requires argument 'length'rCz+signed integer not in range(%d, %d), got %dz,unsigned integer not in range(0, %d), got %drMrLrr0)r7r8r9r:r;rP OverflowErrorrrQr bit_lengthr+ frombytesr"rlr) __irr+rrr,rlerr-r-r.r&sD             r&c Csddlm}m}Gdddt}g}|D]\}}|}||_||_|||qt|dkrS|}||||f|_|jdj|jdj|_|||t|dks/|dS)z_huffman_tree(dict, /) -> Node Given a dict mapping symbols to their frequency, construct a Huffman tree and return its root node. r)heappushheappopc@seZdZdZddZdS)z_huffman_tree..Nodez There are to tyes of Node instances (both have 'freq' attribute): * leaf node: has 'symbol' attribute * parent node: has 'child' attribute (tuple with both children) cSs |j|jkSrD)freq)rGotherr-r-r.__lt__ s z"_huffman_tree..Node.__lt__N)r;rprq__doc__rr-r-r-r.Nodes rrC) heapqrrobjectitemssymbolrrlchild) __freq_maprrrminheapsymr{leafparentr-r-r. _huffman_trees      rcst|tstdt|jt|dkr+t|dkrtdt|d}|td|iSitd|ffdd t |S)a:huffman_code(dict, /, endian=None) -> dict Given a frequency map, a dictionary mapping symbols to their frequency, calculate the Huffman code, i.e. a dict mapping those symbols to bitarrays (with given bit-endianness). Note that the symbols are not limited to being strings. Symbols may be any hashable object. dict expected, got '%s'r/r*cannot create Huffman code with no symbolsrcsNz||j<WdSty&|jd|d|jd|dYdSw)NrrrC1rAttributeErrorr)ndprefixresulttraverser-r.r?s  zhuffman_code..traverse) r7dictr9r:r;rlrPlistrr)rr+rr-rr.r'&s     r'c s2t|tstdt|jt|dkr1t|dkrtdt|d}|tddiddg|gfSidfdd t |t d d d }|d d}i}|ddg}d}t |D].\}\}}t ||d||<||d7<|dt|kr|d7}|||dd|K}q`||dd|DfS)acanonical_huffman(dict, /) -> tuple Given a frequency map, a dictionary mapping symbols to their frequency, calculate the canonical Huffman code. Returns a tuple containing: 0. the canonical Huffman code as a dict mapping symbols to bitarrays 1. a list containing the number of symbols of each code length 2. a list of symbols in canonical order Note: the two lists may be used as input for `canonical_decode()`. rr/rrrbigrCcsNz||j<WdSty&|jd|d|jd|dYdSw)NrrCr)rr code_lengthrr-r.rbs  z#canonical_huffman..traversecSs|dS)NrCr-)itemr-r-r.psz#canonical_huffman..)keyrcSsg|]}|dqSrr-)rerr-r-r. ~sz%canonical_huffman..Nr)r7rr9r:r;rlrPrrrsortedrrr&) rrtablemaxbitscodedictr\coderTrr-rr.r(Js.      r(rD)r?N)NF)rC)NrBrrr)F)NNF)1r __future__rr)r3rZrIrrbitarray._utilrrrrr r r r r rrrrrrrrrrrrrrr__all__rrrr6r r#r!r"r$r%r&rr'r(r-r-r-r.s0 h    ) - 6  1 ' $