Ed8dZddlmZmZddlmZddlmZmZm Z m Z m Z m Z m Z mZddlmZddlmZddZdd Zd Zd Zd Zd ZdZdS)zl Convolution (using **FFT**, **NTT**, **FWHT**), Subset Convolution, Covering Product, Intersecting Product )Ssympify expand_mul)fftifftnttinttfwhtifwhtmobius_transforminverse_mobius_transform)iterable)as_intNct|dkrtd|rdnd}|rdnd}td|||fDdkrtd3t ||snfd t DS|rt ||n%|rt||nt||| snfd t DS) a Performs convolution by determining the type of desired convolution using hints. Exactly one of ``dps``, ``prime``, ``dyadic``, ``subset`` arguments should be specified explicitly for identifying the type of convolution, and the argument ``cycle`` can be specified optionally. For the default arguments, linear convolution is performed using **FFT**. Parameters ========== a, b : iterables The sequences for which convolution is performed. cycle : Integer Specifies the length for doing cyclic convolution. dps : Integer Specifies the number of decimal digits for precision for performing **FFT** on the sequence. prime : Integer Prime modulus of the form `(m 2^k + 1)` to be used for performing **NTT** on the sequence. dyadic : bool Identifies the convolution type as dyadic (*bitwise-XOR*) convolution, which is performed using **FWHT**. subset : bool Identifies the convolution type as subset convolution. Examples ======== >>> from sympy import convolution, symbols, S, I >>> u, v, w, x, y, z = symbols('u v w x y z') >>> convolution([1 + 2*I, 4 + 3*I], [S(5)/4, 6], dps=3) [1.25 + 2.5*I, 11.0 + 15.8*I, 24.0 + 18.0*I] >>> convolution([1, 2, 3], [4, 5, 6], cycle=3) [31, 31, 28] >>> convolution([111, 777], [888, 444], prime=19*2**10 + 1) [1283, 19351, 14219] >>> convolution([111, 777], [888, 444], prime=19*2**10 + 1, cycle=2) [15502, 19351] >>> convolution([u, v], [x, y, z], dyadic=True) [u*x + v*y, u*y + v*x, u*z, v*z] >>> convolution([u, v], [x, y, z], dyadic=True, cycle=2) [u*x + u*z + v*y, u*y + v*x + v*z] >>> convolution([u, v, w], [x, y, z], subset=True) [u*x, u*y + v*x, u*z + w*x, v*z + w*y] >>> convolution([u, v, w], [x, y, z], subset=True, cycle=3) [u*x + v*z + w*y, u*y + v*x, u*z + w*x] rz6The length for cyclic convolution must be non-negativeTNc3K|]}|duV dSN).0xs ;lib/python3.11/site-packages/sympy/discrete/convolutions.py zconvolution..Ps& ? ?Q1D= ? ? ? ? ? ?z0Ambiguity in determining the type of convolution)primecFg|]}t|dzSrsum)riclsrs r zconvolution..Us. I I I1R1X!6 I I Ir)dpsc@g|]}t|dSrr)rrr r!s rr"zconvolution..^s)===qSADqD]]===r) r ValueErrorr TypeErrorconvolution_nttrangeconvolution_fwhtconvolution_subsetconvolution_fft) abcycler#rdyadicsubsetr r!s ` @@r convolutionr1sQt u A1u0/00 0 %TTF %TTF ? ?5#vv"> ? ? ???!CLJKKK J Q / / /Irr I I I I I Ia I I II , a # # , 1 % % Qs + + + =22=====E!HH====rc|dd|dd}}t|t|zdz x}}|dkr||dz zrd|z}|tjg|t|z zz }|tjg|t|z zz }t ||t ||}}dt ||D}t ||d|}|S)a Performs linear convolution using Fast Fourier Transform. Parameters ========== a, b : iterables The sequences for which convolution is performed. dps : Integer Specifies the number of decimal digits for precision. Examples ======== >>> from sympy import S, I >>> from sympy.discrete.convolutions import convolution_fft >>> convolution_fft([2, 3], [4, 5]) [8, 22, 15] >>> convolution_fft([2, 5], [6, 7, 3]) [12, 44, 41, 15] >>> convolution_fft([1 + 2*I, 4 + 3*I], [S(5)/4, 6]) [5/4 + 5*I/2, 11 + 63*I/4, 24 + 18*I] References ========== .. [1] https://en.wikipedia.org/wiki/Convolution_theorem .. [2] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29 Nrrc8g|]\}}t||zSrrrrys rr"z#convolution_fft..&///TQAaC///r)len bit_lengthrZerorzipr)r,r-r#nms rr+r+gsB QQQ4111qA FFSVVOa A1uAE q||~~ !&1s1vv: A!&1s1vv: A q#;;As qA//SAYY///A Q RaRA Hrc|dd|ddt|c}}t|t|zdz x}}|dkr||dz zrd|z}|dg|t|z zz }|dg|t|z zz }t|t|}}fdt ||D}t |d|}|S)a= Performs linear convolution using Number Theoretic Transform. Parameters ========== a, b : iterables The sequences for which convolution is performed. prime : Integer Prime modulus of the form `(m 2^k + 1)` to be used for performing **NTT** on the sequence. Examples ======== >>> from sympy.discrete.convolutions import convolution_ntt >>> convolution_ntt([2, 3], [4, 5], prime=19*2**10 + 1) [8, 22, 15] >>> convolution_ntt([2, 5], [6, 7, 3], prime=19*2**10 + 1) [12, 44, 41, 15] >>> convolution_ntt([333, 555], [222, 666], prime=19*2**10 + 1) [15555, 14219, 19404] References ========== .. [1] https://en.wikipedia.org/wiki/Convolution_theorem .. [2] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29 Nrrr3c&g|] \}}||zzSrr)rrr6ps rr"z#convolution_ntt..s%'''TQ1q'''r)rr8r9r r;r )r,r-rr<r=r@s @rr'r's@dAaaaD&--GAq! FFSVVOa A1uAE q||~~ !a#a&&j A!a#a&&j A q!99c!QiiqA''''SAYY'''A Q 2A2A Hrc|r|sgS|dd|dd}}tt|t|}||dz zrd|z}|tjg|t|z zz }|tjg|t|z zz }t |t |}}dt ||D}t|}|S)a Performs dyadic (*bitwise-XOR*) convolution using Fast Walsh Hadamard Transform. The convolution is automatically padded to the right with zeros, as the *radix-2 FWHT* requires the number of sample points to be a power of 2. Parameters ========== a, b : iterables The sequences for which convolution is performed. Examples ======== >>> from sympy import symbols, S, I >>> from sympy.discrete.convolutions import convolution_fwht >>> u, v, x, y = symbols('u v x y') >>> convolution_fwht([u, v], [x, y]) [u*x + v*y, u*y + v*x] >>> convolution_fwht([2, 3], [4, 5]) [23, 22] >>> convolution_fwht([2, 5 + 4*I, 7], [6*I, 7, 3 + 4*I]) [56 + 68*I, -10 + 30*I, 6 + 50*I, 48 + 32*I] >>> convolution_fwht([S(33)/7, S(55)/6, S(7)/4], [S(2)/3, 5]) [2057/42, 1870/63, 7/6, 35/4] References ========== .. [1] https://www.radioeng.cz/fulltexts/2002/02_03_40_42.pdf .. [2] https://en.wikipedia.org/wiki/Hadamard_transform Nrr3c8g|]\}}t||zSrrr5s rr"z$convolution_fwht.. r7r)maxr8r9rr:r r;r r,r-r<s rr)r)sP A QQQ4111qA CFFCFFA!a%y q||~~ !&1s1vv: A!&1s1vv: A 77DGGqA//SAYY///A aA Hrc |r|sgSt|rt|stdd|D}d|D}tt|t|}||dz zrd|z}|t jg|t|z zz }|t jg|t|z zz }t jg|z}t|D]v}|}|dkr=||xxt|||||z zz cc<|dz |z}|dk=||xxt|||||z zz cc<w|S)a Performs Subset Convolution of given sequences. The indices of each argument, considered as bit strings, correspond to subsets of a finite set. The sequence is automatically padded to the right with zeros, as the definition of subset based on bitmasks (indices) requires the size of sequence to be a power of 2. Parameters ========== a, b : iterables The sequences for which convolution is performed. Examples ======== >>> from sympy import symbols, S >>> from sympy.discrete.convolutions import convolution_subset >>> u, v, x, y, z = symbols('u v x y z') >>> convolution_subset([u, v], [x, y]) [u*x, u*y + v*x] >>> convolution_subset([u, v, x], [y, z]) [u*y, u*z + v*y, x*y, x*z] >>> convolution_subset([1, S(2)/3], [3, 4]) [3, 6] >>> convolution_subset([1, 3, S(5)/7], [7]) [7, 21, 5, 0] References ========== .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf z3Expected a sequence of coefficients for convolutionc,g|]}t|Srrrargs rr"z&convolution_subset..G#######rc,g|]}t|SrrGrHs rr"z&convolution_subset..HrJrrr3r) rr&rCr8r9rr:r(r)r,r-r<r masksmasks rr*r*sR A A;;OhqkkOMNNN#####A#####A CFFCFFA!a%y q||~~ !&1s1vv: A!&1s1vv: A  Aa88ai % dGGGz!E(QtEz]":;; ;GGGQY$Eai % $:ah4:6777 Hrc|r|sgS|dd|dd}}tt|t|}||dz zrd|z}|tjg|t|z zz }|tjg|t|z zz }t |t |}}dt ||D}t|}|S)a Returns the covering product of given sequences. The indices of each argument, considered as bit strings, correspond to subsets of a finite set. The covering product of given sequences is a sequence which contains the sum of products of the elements of the given sequences grouped by the *bitwise-OR* of the corresponding indices. The sequence is automatically padded to the right with zeros, as the definition of subset based on bitmasks (indices) requires the size of sequence to be a power of 2. Parameters ========== a, b : iterables The sequences for which covering product is to be obtained. Examples ======== >>> from sympy import symbols, S, I, covering_product >>> u, v, x, y, z = symbols('u v x y z') >>> covering_product([u, v], [x, y]) [u*x, u*y + v*x + v*y] >>> covering_product([u, v, x], [y, z]) [u*y, u*z + v*y + v*z, x*y, x*z] >>> covering_product([1, S(2)/3], [3, 4 + 5*I]) [3, 26/3 + 25*I/3] >>> covering_product([1, 3, S(5)/7], [7, 8]) [7, 53, 5, 40/7] References ========== .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf Nrr3c8g|]\}}t||zSrrr5s rr"z$covering_product..r7rrCr8r9rr:r r;rrDs rcovering_productrQesX A QQQ4111qA CFFCFFA!a%y q||~~ !&1s1vv: A!&1s1vv: A A   0 3 3qA//SAYY///A ##A Hrc|r|sgS|dd|dd}}tt|t|}||dz zrd|z}|tjg|t|z zz }|tjg|t|z zz }t |dt |d}}dt ||D}t|d}|S)a Returns the intersecting product of given sequences. The indices of each argument, considered as bit strings, correspond to subsets of a finite set. The intersecting product of given sequences is the sequence which contains the sum of products of the elements of the given sequences grouped by the *bitwise-AND* of the corresponding indices. The sequence is automatically padded to the right with zeros, as the definition of subset based on bitmasks (indices) requires the size of sequence to be a power of 2. Parameters ========== a, b : iterables The sequences for which intersecting product is to be obtained. Examples ======== >>> from sympy import symbols, S, I, intersecting_product >>> u, v, x, y, z = symbols('u v x y z') >>> intersecting_product([u, v], [x, y]) [u*x + u*y + v*x, v*y] >>> intersecting_product([u, v, x], [y, z]) [u*y + u*z + v*y + x*y + x*z, v*z, 0, 0] >>> intersecting_product([1, S(2)/3], [3, 4 + 5*I]) [9 + 5*I, 8/3 + 10*I/3] >>> intersecting_product([1, 3, S(5)/7], [7, 8]) [327/7, 24, 0, 0] References ========== .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf Nrr3F)r0c8g|]\}}t||zSrrr5s rr"z(intersecting_product..r7rrPrDs rintersecting_productrTsX A QQQ4111qA CFFCFFA!a%y q||~~ !&1s1vv: A!&1s1vv: A Ae , , ,.>q.O.O.OqA//SAYY///A 5111A Hr)rNNNNr)__doc__ sympy.corerrsympy.core.functionrsympy.discrete.transformsrrr r r r r rsympy.utilities.iterablesrsympy.utilities.miscrr1r+r'r)r*rQrTrrrr[sO "!!!!!!!******00000000000000000000/.....''''''O>O>O>O>p/ / / / p. . . n9 9 9 DD D D Z= = = L= = = = = r