gx=dZddlmZddlmZmZmZddlmZmZ ddl m Z m Z ddl ZddlmZddlmZmZd d lmZmZmZd d gZeeefZ eeeeed ffefZ GddeZd dZd!dZd"dZd#dZ dS)$z Bindings array class ) annotations)MappingUnionTuple)Iterabler)chainisliceN) ArrayLike) ParameterQuantumCircuit) ShapedMixin ShapeInput shape_tuple ParameterLikeBindingsArrayLike.ceZdZdZ d d!fd Zd"d Zd Zed#d Zed$dZ d%d&dZ d'dZ d(dZ d"dZ d)dZed*dZdZxZS)+ BindingsArrayafStores parameter binding value sets for a :class:`qiskit.QuantumCircuit`. A single parameter binding set provides numeric values to bind to a circuit with free :class:`qiskit.circuit.Parameter`\s. An instance of this class stores an array-valued collection of such sets. The simplest example is a 0-d array consisting of a single parameter binding set, whereas an n-d array of parameter binding sets represents an n-d sweep over values. The storage format is a dictionary of arrays attached to parameters, ``{params_0: values_0,...}``. A convention is used where the last dimension of each array indexes (a subset of) circuit parameters. For example, if the last dimension of ``values_0`` is 25, then it represents an array of possible binding values for the 25 distinct parameters ``params_0``, where its leading shape is the array :attr:`~.shape` of its binding array. This allows flexibility about whether values for different parameters are stored in one big array, or across several smaller arrays. .. code-block:: python # 0-d array (i.e. only one binding) BindingsArray({"a": 4, ("b", "c"): [5, 6]}) # single array, last index is parameters parameters = tuple(f"a{idx}" for idx in range(100)) BindingsArray({parameters: np.ones((10, 10, 100))}) # multiple arrays, where each last index is parameters. notice that it's smart enough to # figure out that a missing last dimension corresponds to a single parameter. BindingsArray( {("c", "a"): np.zeros((10, 10, 2)), "b": np.ones((10, 10))} ) NdataBindingsArrayLike | NoneshapeShapeInput | Nonec,t|i|_n#d|D|_|t |jnt ||_d|_|dS)a Initialize a :class:`~.BindingsArray`. The ``shape`` argument does not need to be provided whenever it can unambiguously be inferred from the provided arrays. Ambiguity arises whenever the key of an entry of ``data`` contains only one parameter and the corresponding array's shape ends in a one. In this case, it can't be decided whether that one is an index over parameters, or whether it should be incorporated in :attr:`~shape`. Since :class:`~.Parameter` objects are only allowed to represent float values, this class casts all given values to float. If an incompatible dtype is given, such as complex numbers, a ``TypeError`` will be raised. Args: data: A mapping from one or more parameters to arrays of values to bind them to, where the last axis is over parameters. shape: The leading shape of every array in these bindings. Raises: ValueError: If all inputs are ``None``. ValueError: If the shape cannot be automatically inferred from the arrays, or if there is some inconsistency in the shape of the given arrays. TypeError: If some of the vaules can't be cast to a float type. Nci|]Z\}}t|ttfrt|fnt|t j|t [S)dtype) isinstancer str _format_keynpasarrayfloat).0keyvals a/granary/edev/quantum/lib/python3.11/site-packages/qiskit/primitives/containers/bindings_array.py z*BindingsArray.__init__..xsmC,6cIs;K+L+LbK'''R]^aRbRb:c///) super__init___dataitems _infer_shaper_shape_num_parametersvalidate)selfrr __class__s r&r*zBindingsArray.__init__Vs:  <DJJ!% DJ38-l4:...[QVEWEW # r(returnc fd|jD} tt|jdd}n#t $rd}YnwxYwt||S)Nc(i|]\}}||Sr6)r#paramsr%argss r&r'z-BindingsArray.__getitem__..s#HHHkfcD HHHr(r6)r+r,nextitervaluesr StopIterationr)r1r8rrs ` r& __getitem__zBindingsArray.__getitem__s IHHHTZ5E5E5G5GHHH dkkmm,,--3CRC8EE   EEE T5)))s;A$$ A32A3c d|jd|jg}|jrttt t t jt t|j d}t||jkr| d| dd |dt|jdd |d S) Nzshape=znum_parameters=z...z parameters=[z, ]z())rnum_parameterslistr mapreprr from_iterablerr+lenappendjointype__name__)r1 descriptionsnamess r&__repr__zBindingsArray.__repr__s---/VAT/V/VW   DD%*=c+tz>Z>Z*[*[ \ \^_``aaE5zzD/// U###    Btyy/?/? B B B C C Ct**%DD<)@)@DDDDr(!dict[tuple[str, ...], np.ndarray]c|jS)z!The keyword values of this array.)r+r1s r&rzBindingsArray.datas zr(intc|j5td|jD|_|jS)zThe total number of parameters.Nc30K|]}|jdVdSr9Nr)r#r%s r& z/BindingsArray.num_parameters..s(&T&Tsy}&T&T&T&T&T&Tr()r/sumr+r<rQs r&rBzBindingsArray.num_parameterssC   '#&&T&T @Q@Q@S@S&T&T&T#T#TD ##r( parametersIterable[ParameterLike] | None np.ndarrayc  d tjt|j|j}|;|jD] }|jd}||d |zf< |z !nt|}t||jkr(td|jdt|ddt|D |j D]q\}} fd |D}nT#t$rG}t fd tt|D}td |d |d}~wwxYw||d|f<r|S) aReturn the contents of this bindings array as a single NumPy array. The parameters are indexed along the last dimension of the returned array. Parameters: parameters: Optional parameters that determine the order of the output. Returns: This bindings array as a single NumPy array. Raises: ValueError: If ``parameters`` are provided, but do not match those found in ``data``. rNr9. Expected z parameters but z received.c4i|]\}}t||Sr6 _param_name)r#idx parameters r&r'z*BindingsArray.as_array..s&bbb.#y+i00#bbbr(c@g|]}t|zSr6r_)r#param idx_lookuppositions r& z*BindingsArray.as_array..s+^^^%J{5'9'9:XE^^^r(c3$K|] }|v|V dSNr6)r#pres r&rWz)BindingsArray.as_array..s."b"baWaNaNa1NaNaNaNa"b"br(z(Could not find placement for parameter 'z'.)r emptyrrrBrr<rCrG ValueError enumerater,KeyErrorr:rDr`) r1rYretarrsize arr_paramsidxsexmissingrerfs @@r&as_arrayzBindingsArray.as_arraysh{4:t/BCCDD  y'')) ! !y}7:CHtO334D  ! j))J:$"555 ` 3``S__```cbIV`LaLabbbJ#'9??#4#4 % % Ce^^^^^S]^^^DDeee""b"b"b"bc+z.J.J"b"b"bbbG$%[PW%[%[%[\\bdde"%CI s5D EAEEcircuitr loctuple[int, ...]ct|jkrtdd|jdfd|jD}||S)a[Return a new circuit bound to the values at the provided index. Args: circuit: The circuit to bind. loc: A tuple of indices, on for each dimension of this array. Returns: The bound circuit. Raises: ValueError: If the index doesn't have the right number of values. r]z to index all dimensions of .cTi|]$\}}t||D]\}}|| %Sr6)zip)r#r7valsrdr%rxs r&r'z&BindingsArray.bind..sX   !&$s)44  s 3    r()rGndimrlrr+r,assign_parameters)r1rwrxrYs ` r&bindzBindingsArray.binds s88ty WWW$*WWWXX X    $ 0 0 2 2   ((444r(ctj|jt}tj|jD]}|||||<|S)zReturn an object array of bound circuits with the same shape. Args: circuit: The circuit to bind. Returns: An object array of the same shape containing all bound circuits. r)r rkrobjectndindexr)r1rwrpras r&bind_allzBindingsArray.bind_allsShtz000:dj)) / /Cyy#..CHH r(c6||jS)a Return a new :class:`~BindingsArray` with one dimension. The returned bindings array has a :attr:`shape` given by ``(size, )``, where the size is the :attr:`~size` of this bindings array. Returns: A new bindings array. )reshaperqrQs r&ravelzBindingsArray.ravels||DI&&&r(int | Iterable[int]cttdDrJtjdDt}|j|zt fdDtjt|jkrtdfd|j D}t|S)akReturn a new :class:`~BindingsArray` with a different shape. This results in a new view of the same arrays. Args: shape: The shape of the returned bindings array. Returns: A new bindings array. Raises: ValueError: If the provided shape has a different product than the current size. c3"K|] }|dkV dSrNr6r#dims r&rWz(BindingsArray.reshape..s&((3sQw((((((r(cg|] }|dk| S)rr6rs r&rgz)BindingsArray.reshape..s$F$F$FSSAXXSXXXr(rc3,K|]}|dkr|nVdSrr6)r#r missing_dims r&rWz(BindingsArray.reshape..s/LLs##{LLLLLLr(z5Reshaping cannot change the total number of elements.c bi|]+\}}|||jddz,SrU)rr)r#psr%rs r&r'z)BindingsArray.reshape..s:ZZZGBCKK "## 677ZZZr(rV) ranyr prodrRrqtuplerlr+r,r)r1r positive_sizerrs ` @r&rzBindingsArray.reshapesE"" ((%((( ( ( MG$F$FE$F$F$FcRRRM)}4KLLLLeLLLLLE 75 $ $ $ 1 1TUU UZZZZtzGWGWGYGYZZZT////r(bindings_arrayrc| |}nYt|tr ||}n7t|tr|Stdt |d|S)zCoerce an input that is :class:`~BindingsArrayLike` into a new :class:`~BindingsArray`. Args: bindings_array: An object to be bindings array. Returns: A new bindings array. N)rzUnsupported type z is given.)r_Mappingr TypeErrorrJ)clsrs r&coercezBindingsArray.coerces  ! SUUNN  1 1 R Sn555NN  6 6 R! !P^0D0DPPPQQ Qr(c|jD]W\}}t||jx}|j|<t ||jdkrt d|d|XdS)z+Validate the consistency in bindings_array.r9z Length of z% inconsistent with last dimension of N)r+r,_standardize_shaper.rGrrl)r1rYr%s r&r0zBindingsArray.validate3s#z//11  OJ+=c4;+O+O OC$*Z(:#)B-// WWWRUWW0  r()NN)rrrr)r3r)r3rO)r3rRri)rYrZr3r[)rwr rxryr3r )rwr r3r[)rrr3r)rrr3r)rK __module__ __qualname____doc__r*r>rNpropertyrrBrvrrrr classmethodrr0 __classcell__)r2s@r&rr6sUB*.#',,,,,,,\ * * * *EEEX$$$X$ ,,,,,\5555.     ' ' ' '00006[&r(rr%r[rryr3c|j|kr |d}nH|jdz t|ks|jdd|krtd|jd||S)auReturn ``val`` or ``val[..., None]``. Args: val: The array whose shape to standardize. shape: The shape to standardize to. Returns: An array with one more dimension than ``len(shape)``, and whose leading dimensions match ``shape``. Raises: ValueError: If the leading shape of ``val`` does not match the ``shape``. ).Nr Nr9zArray with shape z inconsistent with )rrrGrl)r%rs r&rr=sm yE)n AU # #sy"~'>'>RSYRR5RRSSS Jr(r'dict[tuple[Parameter, ...], np.ndarray]cdfd}|D]r\}}t|dkr||jdd1|jr*|jddkr||jddb||jsdStdkrtt Stdkrt dt dd ) aReturn a shape tuple that consistently defines the leading dimensions of all arrays. Args: data: A mapping from tuples to arrays, where the length of each tuple should match the last dimension of the corresponding array. Returns: A shape tuple that matches the leading dimension of every array. Raises: ValueError: If this cannot be done unambiguously. NcXt|dS|dSri)setintersection_update)possible_shapesonly_possible_shapess r& examine_arrayz#_infer_shape..examine_arrayas7  '#&#7#7 4 4_ E E E E Er(r r9r6rz$Could not find any consistent shape.zDCould not unambiguously determine the intended shape, all shapes in z7 are consistent with the input; specify shape manually.)r,rGrr:r;rl)rrrYr%rs @r&r-r-RsJ FFFFF ::<< % % C z??a   M#)CRC. ) ) ) ) Y %39R=A-- M#)CRC. ) ) ) ) M#) $ $ $ $#r   A%%D-../// ! " "a ' '?@@@  Y  Y Y Y  r(r$tuple[Parameter | str, ...]cFttt|Sri)rrDr`)r$s r&rrs [#&& ' ''r(rdParameter | strrc>t|tr|jn|Sri)rr name)rds r&r`r`s#E955 @5::5@r()r%r[rryr3r[)rrr3ry)r$r)rdrr3r)!r __future__rtypingrrrcollections.abcrr itertoolsrr numpyr numpy.typingr qiskit.circuitr r rrrr__all__rrrrrr-rr`r6r(r&rs#"""""((((((((((99999999########""""""444444447777777777 / 0in% $E-}c7I1J"JKYVW"DDDDDKDDDN*++++\((((AAAAAAr(