bid=dZddlmZddlmZmZddlmZddlm Z ddl m Z m Z ddl ZddlmZddlmZddlmZdd lmZdd lmZmZmZ Gd d e ZeGd dZGddeZGddeZGddeZ GddeZ!GddeZ"GddeZ#Gdde#eZ$Gdde$Z%Gdd e$Z&y)!a1 Copyright 2022, the CVXPY authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ) annotations)ABCabstractmethod) dataclass)Enum)AnyCallableNconvolve)LinOp)NUMPY_CANON_BACKENDRUST_CANON_BACKENDSCIPY_CANON_BACKENDceZdZdZy)ConstantN)__name__ __module__ __qualname__IDV/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/cvxpy/lin_ops/canon_backend.pyrr)s BrrceZdZUdZded<ded<ded<ded<ded<d Zedd Zdd Zdd Z edd Z ddZ ddZ y)TensorRepresentationz Sparse representation of a 3D Tensor. Semantically similar to COO format, with one extra dimension. Here, 'row' is axis 0, 'col' axis 1, and 'parameter_offset' axis 2. np.ndarraydatarowcolparameter_offsettuple[int, int]shapec|jj|jjcxk(r4|jjcxk(r|jjk(sJJyN)rr"rrr selfs r __post_init__z"TensorRepresentation.__post_init__9sDyy$((..aDHHNNadF[F[FaFaaaaaarctjgtjgtjgtjgf\}}}}D]}tj||j}tj||j}tj||j }tj||j }tfdDsJ|||||djS)zz Concatenates the row, col, parameter_offset, and data fields of a list of TensorRepresentations. c3VK|] }|jdjk("yw)rNr").0ttensorss r z/TensorRepresentation.combine..Js$@1177gaj...@s&)r) nparrayappendrrrr allr")clsr-rrrr r,s ` rcombinezTensorRepresentation.combine<s ,.88B<"rxxPR|UWU]U]^`Ua+a(c3( OA99T166*D))C'C))C'C!yy)91;M;MN   O @@@@@4c#3WQZ5E5EFFrct|txrtj|j|jk(xrtj|j |j k(xrutj|j |j k(xrGtj|j|jk(xr|j|jk(Sr$) isinstancerr/r2rrrr r"r&others r__eq__zTensorRepresentation.__eq__Ms%!56& FF499 * +& FF488uyy( )& FF488uyy( )& FF4((E,B,BB C & JJ%++ %  &rc |j|jk7r tdttj|j |j gtj|j |j gtj|j|jgtj|j|jg|jS)NzShapes must match for addition.) r" ValueErrorrr/ concatenaterrrr r7s r__add__zTensorRepresentation.__add__Us :: $>? ?# NNDIIuzz2 3 NNDHHeii0 1 NNDHHeii0 1 NND1153I3IJ K JJ   rc |tjgttjgttjgttjgt|S)Ndtype)r/r0floatint)r3r"s rempty_with_shapez%TensorRepresentation.empty_with_shape`sJ HHRu % HHRs # HHRs # HHRs #    rc|jjtjtj|jdz|j jtjz}|j jtj}tj|jtj|f}tj|j||ff|S)zW Flatten into 2D scipy csc-matrix in column-major order and transpose. rr?r*) rastyper/int64r"rr prodsp csc_arrayr)r&num_param_slicesrowscolsr"s rflatten_tensorz#TensorRepresentation.flatten_tensorjs)BHHTZZ],CCdhhooVXV^V^F__$$++BHH528846FG||TYYt 5UCCrc|j|k(}tj|j||j||j |ff|j S)zT Returns a single slice of the tensor for a given parameter offset. )r rHrIrrrr")r& param_offsetmasks rget_param_slicez$TensorRepresentation.get_param_slicessN$$ 4||TYYt_txx~txx~.NOQUQ[Q[\\rNr-zlist[TensorRepresentation]returnr)r8rrSbool)r8rrSr)r"r!rSr)rJrBrS sp.csc_array)rOrBrSrU) rrr__doc____annotations__r' classmethodr4r9r=rCrMrQrrrrr-sk  O O  bGG &    D]rrcDeZdZ ddZeddZeddZy) CanonBackendcJ||_||_||_||_||_y)aq CanonBackend handles the compilation from LinOp trees to a final sparse tensor through its subclasses. Parameters ---------- id_to_col: mapping of variable id to column offset in A. param_to_size: mapping of parameter id to the corresponding number of elements. param_to_col: mapping of parameter id to the offset in axis 2. param_size_plus_one: integer representing shape[2], i.e., the number of slices along axis 2 plus_one refers to the non-parametrized slice of the tensor. var_length: number of columns in A. N)param_size_plus_one id_to_col param_to_size param_to_col var_length)r&r]r^r_r\r`s r__init__zCanonBackend.__init__|s*$7 "*($rcXtttttt i}|||i|S)aO Map the name of a subclass and its initializing arguments to an instance of the subclass. Parameters ---------- backend_name: key pointing to the subclass. args: Arguments required to initialize the subclass. Returns ------- Initialized CanonBackend subclass. )r NumPyCanonBackendrSciPyCanonBackendrRustCanonBackend)r3 backend_nameargskwargsbackendss r get_backendzCanonBackend.get_backends6 !2 !2  0  &x %t6v66rcy)a Main function called from canonInterface. Given a list of LinOp trees, each representing a constraint (or the objective), get the [A b] Tensor for each, stack them and return the result reshaped as a 2D sp.csc_array of shape (total_rows * (var_length + 1)), param_size_plus_one) Parameters ---------- lin_ops: list of linOp trees. Returns ------- 2D sp.csc_array representing the constraints (or the objective). Nr)r&lin_opss r build_matrixzCanonBackend.build_matrixs rN) r]dict[int, int]r^rnr_rnr\rBr`rB)rfstrrSrZrlz list[LinOp]rSrU)rrrrarXrjrrmrrrrZrZ{sG%-%DG%UX%*77(  rrZceZdZdZd&dZd'dZ d(dZeed)dZ eed*dZ ed+dZ ed,dZ d-d Z ed.d Zed.d Zed/d Zeed/d Zeed/dZed.dZed/dZeed.dZed/dZed/dZeed/dZeed0dZd/dZd/dZd/dZed/dZed/dZed/dZed/dZ eed/dZ!ed/dZ"ed/dZ#ed/d Z$ed!Z%ed1d"Z&ed2d#Z'ed3d$Z(y%)4PythonCanonBackendaB Each tensor has 3 dimensions. The first one is the parameter axis, the second one is the rows and the third one is the variable columns. For example: - A new variable of size n has shape (1, n, n) - A new parameter of size n has shape (n, n, 1) - A new constant of size n has shape (1, n, 1) c|j|jd<g}td|D}d}|D]i}tj|j }|j }|j||}|j|j||||z }k|j|} |jjd| j|jS)Nrc3ZK|]#}tj|j%ywr$r/rGr")r+lin_ops rr.z2PythonCanonBackend.build_matrix..sE6.E)+r)r`r]sumr/rGr"get_empty_viewprocess_constraintr1get_tensor_representationconcatenate_tensorspoprMr\) r&rlconstraint_res total_rows row_offsetrv lin_op_rows empty_view lin_op_tensor tensor_ress rrmzPythonCanonBackend.build_matrixs!__rEWEE   &F''&,,/K,,.J 33FJGM  ! !-"I"I*V`"a b + %J  & --n=  2(()A)ABBrc|jdk(rt|jtsJtj st |jdvsJ|j|j|j}|j|jh|dS|jdvrH|j|j}|jtjjh|dS|jdk(rS|j|j|j}|jtjjh|dS|j|j}|jdvr |||Sd }|j D]'}|j#||} ||| } || }#|| z })|J|S) a Depth-first parsing of a linOp node. Parameters ---------- lin_op: a node in the linOp tree. empty_view: TensorView used to create tensors for leaf nodes. Returns ------- The processed node as a TensorView. variable>rT)is_parameter_free> dense_const scalar_const sparse_constparamF>hstackvstackr<N)typer6rrBs ALLOW_ND_EXPRlenr"get_variable_tensorcreate_new_tensor_viewget_data_tensorrrvalueget_param_tensorget_funcrgrz) r&rvrvariable_tensor data_tensor param_tensorfuncresarg arg_coeffarg_ress rrzz%PythonCanonBackend.process_constraints ;;* $fkk3/ //??c&,,&79&D DD"66v||V[[QO44fkk]OGK5M M [[K K..v{{;K44hkk6G6G5H+GK5M M [[G #00v{{KL44hkk6G6G5H,GL5N N ==-D{{AAFJ//C{{ # 33CD vy1;!C7NC  #? "?Jrc~hd}|s;|j|vr-t|jdk(r|j|}|dfS|j ||}|j t jjhk(sJ|jt jj}|s_t|jdk\rGt|jdk(r |jnd|jdg}|j||}|jr|t jjn|}||jfS)z Extract the constant data from a LinOp node. In most cases, lin_op will be of type "*_const" or "param", but can handle arbitrary types. >rrrrTrr) rrr"get_constant_data_from_constrz variable_idsrrrtensorreshape_constant_datar) r&rvviewcolumn constants constant_data constant_view lin_op_shapedata_to_returns rget_constant_dataz$PythonCanonBackend.get_constant_datasD &++2s6<<7HA7M ==fEM $& &//= ))hkk.?.?-@@@@%,,X[[->->? #fll+q0,/v||+<+A6<<6<>>>rcy)P Extract the constant data from a LinOp node of type "*_const". Nr)rvs rrz/PythonCanonBackend.get_constant_data_from_const rcy)z Reshape constant data from column format to the required shape for operations that do not require column format Nr)rrs rrz(PythonCanonBackend.reshape_constant_data& rc,tj|Sz Takes list of tensors which have already been offset along axis 0 (rows) and combines them into a single tensor. rr4)r-s rr|z&PythonCanonBackend.concatenate_tensors/ $++G44rcy)z Returns an empty view of the corresponding TensorView subclass, coupling the CanonBackend subclass with the TensorView subclass. Nrr%s rryz!PythonCanonBackend.get_empty_view7rrc>id|jd|jd|jd|jd|jd|j d|j d|jd |jd |jd |jd |jd |jd|jd|jd|jd|j |j"|j$|j&|j(|j*d}||S)z Map the name of a function as given by the linOp to the implementation. Parameters ---------- func_name: The name of the function. Returns ------- The function implementation. rxmulpromote broadcast_tonegmul_elem sum_entriesdivreshapeindexdiag_vecrrr< transpose upper_tridiag_mat)rmultraceconvkron_lkron_r)sum_oprrrrrrrrrrrrr<rrrrrrrr)r& func_namemappings rrzPythonCanonBackend.get_func?sR 4;; 488  t||  D--  488     4++  488  t||  TZZ     dkk  dkk  4++   ! "  # $IIZZIIkkkk- 0y!!rc|S)zJ Sum (along axis 1) is implicit in Ax+b, so it is a NOOP. r_linrs rrzPythonCanonBackend.sum_ope  rc|S)z[ Reshaping only changes the shape attribute of the LinOp, so it is a NOOP. rrs rrzPythonCanonBackend.reshapelrrcy) Multiply view with constant data from the left. When the lhs is parametrized, multiply each slice of the tensor with the single, constant slice of the rhs. Otherwise, multiply the single slice of the tensor with each slice of the rhs. Nrr&linrs rrzPythonCanonBackend.muls rcy)z? Promote view by repeating along axis 0 (rows) Nrrrs rrzPythonCanonBackend.promote}rrcy)z0 Broadcast view to a new shape. Nrrs rrzPythonCanonBackend.broadcast_torrc.d}|j||S)8 Given (A, b) in view, return (-A, -b). c| Sr$r)xs rrz$PythonCanonBackend.neg..func 2Ir apply_allrrrs rrzPythonCanonBackend.negs   t rcy)o Given (A, b) in view and constant data d, return (A*d, b*d). d is broadcasted along dimension 1 (columns). When the lhs is parametrized, multiply elementwise each slice of the tensor with the single, constant slice of the rhs. Otherwise, multiply elementwise the single slice of the tensor with each slice of the rhs. Nrrs rrzPythonCanonBackend.mul_elem rcy)zN Given (A, b) in view, return (sum(A,axis=0), sum(b, axis=0)) Nrrs rrzPythonCanonBackend.sum_entriesrrcy)aU Given (A, b) in view and constant data d, return (A*(1/d), b*(1/d)). d is broadcasted along dimension 1 (columns) This function is semantically identical to mul_elem but the view x is multiplied with the reciprocal of the lin_op data instead. Note: div currently doesn't support parameters. Nrrs rrzPythonCanonBackend.divs rc|jDcgc]7}tj|j|j|j 9}}t |dkDsJ|d}tj|jdjg}tdt |D]B}||dz }tjj||||zjd}|}D|j||Scc}w)z Given (A, b) in view, select the rows corresponding to the elements of the expression being indexed. Supports an arbitrary number of dimensions. rrForder)rr/arangestartstopsteprcumprodrgr"rangeaddouterflatten select_rows) rrrindicesrKcum_prodi product_sizeoffsets rrzPythonCanonBackend.indexs @CxxH!299QWWaffaff5HH7|aqz::sxx{0012q#g,' A#AE?LVV\\$ \(ABJJQTJUFD    Is0 for diagonals above the main diagonal, and k<0 for diagonals below the main diagonal. Nrrs rrzPythonCanonBackend.diag_vecrrcy) Returns a function that takes in a tensor, modifies the shape of the tensor by extending it to total_rows, and then shifts the entries by offset along axis 0. Nr)rrs rget_stack_funcz!PythonCanonBackend.get_stack_funcrrc6d}td|jD}d}|jD]e}|j||}|j||}|j |t j |j} || z }||}a||z }g|J|S)z Given views (A0,b0), (A1,b1),..., (An,bn), stack all tensors along axis 0, i.e., return (A0, b0) A1, b1 ... An, bn. rc3ZK|]#}tj|j%ywr$rur+rs rr.z,PythonCanonBackend.hstack..s@+@rwN)rxrgrzrrr/rGr") r&rrrrrrarg_viewrarg_rowss rrzPythonCanonBackend.hstacks@sxx@@ 88 C..sD9H&&z6:D   t $wwsyy)H h F{x  rc^|j||}|jd}|Btjt d|j D}|j ||Sd}g}|j D]h}tj|j} |jtj| j|jd|z|| z }jtj||jdjt}|j ||S)aZConcatenate multiple tensors along a specified axis. This method performs the concatenation of multiple tensors, following NumPy's behavior. It correctly maps the indices from the input tensors to the concatenated output tensor, ensuring that elements are placed in the correct positions in the resulting tensor. rrc3ZK|]#}tj|j%ywr$rurs rr.z1PythonCanonBackend.concatenate..s!I"''#))"4!Irwrraxis)rrr/rrxrgrrGr"r1rr<rrErB) r&rrrr rrrrrs rr<zPythonCanonBackend.concatenateskkck-xx{ <IIc!I!IIJE OOE "J88 Cwwsyy)H NN299X.66syy#6NQWW X h F wt4<<3<GNNsS  rc|j||}d}g}|jD]h}tj|j}|j tj |j|jd|z||z }jtj|jdjt}|j||S)z Given views (A0,b0), (A1,b1),..., (An,bn), first, stack them along axis 0 via hstack. Then, permute the rows of the resulting tensor to be consistent with stacking the arguments vertically instead of horizontally. rrrr) rrgr/rGr"r1rrrrrErBr) r&rrrrrrrrs rrzPythonCanonBackend.vstacks kkck-88 Cwwsyy)H NN299X.66syy6LvU V h F  '"***5<0 for diagonals above the main diagonal, and k<0 for diagonals below the main diagonal. rr)r"rabsr/rrrErB)rrrKr original_rows diag_indicess rrzPythonCanonBackend.diag_mat;syy| HHs1v 699T?dQh7L U99T?ma.?@=STCTTL99T?ma.?@1DL ,,S12 rcy)a Multiply view with constant data from the right. When the rhs is parametrized, multiply each slice of the tensor with the single, constant slice of the lhs. Otherwise, multiply the single slice of the tensor with each slice of the lhs. Nrrs rrzPythonCanonBackend.rmulOrrcy)w Select the rows corresponding to the diagonal entries in the expression and sum along axis 0. Nrrs rrzPythonCanonBackend.traceYrrcy) Returns view corresponding to a discrete convolution with data 'a', i.e., multiplying from the left a repetition of the column vector of 'a' for each column in A, shifted down one row after each column, i.e., a Toeplitz matrix. If lin_data is a row vector, we must transform the lhs to become a column vector before applying the convolution. Note: conv currently doesn't support parameters. Nrrs rrzPythonCanonBackend.convbs rcy)z Returns view corresponding to Kronecker product of data 'a' with view x, i.e., kron(a,x). Note: kron_r currently doesn't support parameters. Nrrs rrzPythonCanonBackend.kron_rorrcy)z Returns view corresponding to Kronecker product of view x with data 'a', i.e., kron(x,a). Note: kron_l currently doesn't support parameters. Nrrs rrzPythonCanonBackend.kron_lxrrc tj|}tj|}tjtj|j |d}tjtj|j |d}tj ||tj ||tj|zzj djt}|S)z Internal function that computes the row indices corresponding to the kronecker product of two sparse tensors. rr) r/onesrrGrkronrrErB) lhs_shape rhs_shaperhs_oneslhs_ones rhs_arange lhs_arange row_indicess r_get_kron_row_indicesz(PythonCanonBackend._get_kron_row_indicess 779%779%YYrwwy12::9C:P YYrwwy12::9C:P wwx4wwz8bggi6H+HIJ W3W s  rcy)z Returns tensor of a variable node, i.e., eye(n) across axes 0 and 1, where n is the size of the variable. Nr)r&r" variable_ids rrz&PythonCanonBackend.get_variable_tensorrrcy)zE Returns tensor of constant node as a column vector. Nr)r&rs rrz"PythonCanonBackend.get_data_tensor rcy)z Returns tensor of a parameter node, i.e., eye(n) across axes 0 and 2, where n is the size of the parameter. Nr)r&r" parameter_ids rrz#PythonCanonBackend.get_param_tensorrrNrp)rvr r TensorViewrSr/)rvr rr/rrTrSz%tuple[np.ndarray | sp.spmatrix, bool])rvr rSnp.ndarray | sp.spmatrix)rrrr!rSrrR)rSr/)rrorSr )rr rr/rSr/)rr rr/rSr/rrBrrBrSr )r"tuple[int, ...]r*rBrSr)rrrSr)r"r2r.rBrSr))rrrrVrmrzr staticmethodrrrr|ryrrrrrrrrrrrrrrr<rrrrrrrrrr(rrrrrrrrrrsC"-^?4?4    55  $"L                  "    22"    &                   rrrceZdZdZddZy)rez The rust canonicalization backend is currently WIP and cannot be used. For additional information, a proof of concept pull request can be found here: https://github.com/phschiele/cvxpy/pull/31 cDddl}|j|jd<|j||j|j|j |j |j\}\}}}|jjdtj|||ff|S)Nrr) cvxpy_rustr`r]rmr\r^r_r}rHrI)r&rlr6rrrr"s rrmzRustCanonBackend.build_matrixs!__r$.$;$;G<@.parametrized_mul@wwqzQ&-8->->-@ATQ1q5AAA=c|zSr$rrrIs rrz#NumPyCanonBackend.mul..func "Q&ris_param_free_function)rrr6dictrKnextitervaluesr"r=r/r eyendarrayaccumulate_over_variables) r&rrlhsis_param_free_lhsrepsrr?rJrrIs @rrzNumPyCanonBackend.muls"&!7!7$u!7!U  c4 99T#**,%7 8 ; A A" EEDCF99;O41a1bggbffTlA66OK B$Dc2::. ..99 " -D''"&&,4K '--dK\-]]Ps4D>cttj|jfd}|j ||S)z@ Promote view by repeating along axis 1 (rows). c6tj|ddfSNr)r/tile)r num_entriess rrz'NumPyCanonBackend.promote..funcs771q+q12 2r)rBr/rGr"r)rrrr`s @rrzNumPyCanonBackend.promotes4 "''#)),-  3 t rc<|j}|jdj}tjtj|t j |d}tj||jd}|j||Sz^ Broadcast view by calling np.broadcast_to on the rows and indexing the view. rr?rr r"rgr/rrGrBrrrrrrbroadcast_shaper rKs rrzNumPyCanonBackend.broadcast_to { ))!**yys;<DD^[^D_t_5==C=H  rc|j|j|d\}ttrfd}|}nfd}|j ||S)rTrDc|jddk(sJjDcic] \}}|||z c}}Scc}}wrFrG)rrr?rYs rrJz4NumPyCanonBackend.mul_elem..parametrized_mul"s=wwqzQ&-0YY[9TQ1q5999rLc|zSr$rrrYs rrz(NumPyCanonBackend.mul_elem..func(s QwrrP)rrr6rRrX)r&rrrZrJrrYs @rrzNumPyCanonBackend.mul_elemsX"&!7!7$t!7!T  c4  :$D --dK\-]]rc4fd}|j||S)a Given (A, b) in view, return the sum of the representation on the row axis, ie: (sum(A, axis=axis), sum(b, axis=axis)). Note for new n-dimensional version: We now pass an axis parameter to the sum. The new implementation keeps the columns of the tensor fixed and reshapes the remaining dimensions in the original shape of the expression. The sum is then performed along the axis parameter. Finally, the tensor is reshaped back to the desired output shape. Example: # Suppose we want to sum a Variable(2,2,2) x = np.eye(8) out = x.reshape(2,2,2,8).sum(axis=axis).reshape(n // prod(shape[axis]),8) c j\}}||jddS jdj}|jd}|jd}t |t rIt j|Dcgc]}|| c}t}t |Dcgc]}|dz c}}n ||}|dz }|j|f|z|fzdj| }|j|||z|fdScc}wcc}w) NrT)r keepdimsrrr?rrr) rrxrgr"r6tupler/rGrBr) rr _r"nprdars rrz+NumPyCanonBackend.sum_entries..func=siiGD!|uu!du33 ! **GGBKGGAJdE*4 8aq 8DA !6A!a%!67Dd AAIDIIqd5j!oSI9==4=Hyy!QT1Sy99!9!6s D" D rrs` rrzNumPyCanonBackend.sum_entries,s" :$ t rc|j|j|d\}|sJjddk(sJtjdk7t fd}|j ||S)N Given (A, b) in view and constant data d, return (A*(1/d), b*(1/d)). d is broadcasted along dimension 1 (columns). This function is semantically identical to mul_elem but the view x is multiplied with the reciprocal of the lin_op data. Note: div currently doesn't support parameters. TrDrr)wherer@c|zSr$rrjs rdiv_funcz'NumPyCanonBackend.div..div_funca 7NrrP)rrr"r/ reciprocalrArXr&rrrZrxrYs @rrzNumPyCanonBackend.divRsy"&!7!7$t!7!T    yy|q   mmCsaxu= --hO`-aarc|jd|jdk(sJ|j|jdt|jddzfd}|j||S)af Diagonal vector to matrix. Given (A, b) with n rows in view, add rows of zeros such that the original rows now correspond to the diagonal entries of the n x n expression. An optional offset parameter `k` can be specified, with k>0 for diagonals above the main diagonal, and k<0 for diagonals below the main diagonal. rrrch|jd}t|j}|d<dk(rtj|dzz}nEdkDr"tj|dzzzz}ntj|dzzz }tj|}||dd|ddf<|SNrr)r"listr/rzeros)rx_rowsr"new_rowsmatrixrrKrs rrz(NumPyCanonBackend.diag_vec..funcssWWQZFME!E!HAv99V,q9Q99V,q9D1HD99V,q9A=XXe_F%&F1h> "Mrr"rrBrrrrrrKrs @@@rrzNumPyCanonBackend.diag_vecfshyy|syy|+++ HHyy|1*+   t rcfd}|S)z Returns a function that takes in a tensor, modifies the shape of the tensor by extending it to total_rows, and then shifts the entries by offset along axis 1. c |jd}tj|zjt}tj |jdt |jdf}||dd|ddf<|S)Nrrrr*)r"r/rrErBr)rrKrrrrs r stack_funcz4NumPyCanonBackend.get_stack_func..stack_funcsl<<?D $&088=HXXV\\!_c*ov||TU$WXF%+F1h> "Mrrrrrs`` rrz NumPyCanonBackend.get_stack_funcs  rc  |j|j|d\}}t|jdjdk(r|jdjdn|jdjd}|r|jd}t|jjdk(r||k7rt j |dd}|jd}|j|z}t j |dd}t j|t j|fd} n=tt|jdj} | d}t|jjdk(rl||k7rg|jD cic]\} } | t j | dd}} } tt|jdj} | d}|j|z}|jD cic]D\} } | t jt j | ddt j|Fc} } fd} | } |j| | Scc} } wcc} } w)  Multiply view with constant data from the right. When the rhs is parametrized, multiply each slice of the tensor with the single, constant slice of the lhs. Otherwise, multiply the single slice of the tensor with each slice of the lhs. Note: Even though this is rmul, we still use "lhs", as is implemented via a multiplication from the left in this function. FrDrrrc|zSr$rrNs rrz$NumPyCanonBackend.rmul..funcrOrc|jddk(sJjDcic] \}}|||z c}}Scc}}wrFrGrHs rrJz0NumPyCanonBackend.rmul..parametrized_mulrKrLrP)rrrrgr"r/swapaxesrKr rVrSrTrUr=rX)r&rrrYrZarg_colslhs_rowsr[lhs_transposedrr!rr?rJrIs @rrzNumPyCanonBackend.rmuls"&!7!7$u!7!U +.sxx{/@/@+AQ+F388A;$$Q'CHHUVKL]L]^_L` yy}H388>>"a'H,@kk#r2.yy}H99(D[[b"5N''."&&,?K 'T#**,/0399I }H388>>"a'H,@=@YY[ITQq"++aR00II cjjl!34Q7==  }H99(DX[XaXaXcdPTPQST1bggbkk!R&.funcryrTrP)rgr"r/rrrGrX)rrr"rrrYs @rrzNumPyCanonBackend.traces  !!))E!H%a0299U1X3FFhha01AwJ --d4-PPrc|j|j|d\}|sJt|jjdk(rt j ddfd}|j ||S)rFrDrrrct|Sr$r rjs rrz$NumPyCanonBackend.conv..funcsC# #rrP)rrrr"r/rrX)r&rrrZrrYs @rrzNumPyCanonBackend.convst"&!7!7$u!7!U    sxx~~ ! #++c2r*C $--dK\-]]rc|j|j|d\}|sJtdk(sJdjdk(sJt|jDchc]}|j c}dk(sJ|jdj }|j |jj |dfd }|j||Scc}w) C Returns view corresponding to Kronecker product of data 'a' with view x, i.e., kron(a,x). This function reshapes 'a' into a column vector, computes the Kronecker product with the view of x and reorders the row indices afterwards. Note: kron_r currently doesn't support parameters. TrDrrrcn|jdk(sJtj|}|ddddf}|SNndimr/r )rkron_resrYrow_idxs rrz&NumPyCanonBackend.kron_r..funcs766Q; ;wwsAH7A .HOrrPrrrSrrrrrrgr"r(rX r&rrrZrr"rrYrs @@rrzNumPyCanonBackend.kron_rs"&!7!7$t!7!T    3x1}}!fxx1}}2#CII23q888HHQK%% ,,SXX^^YG  --dK\-]]3!Cc|j|j|d\}|sJtdk(sJdjdk(sJt|jDchc]}|j c}dk(sJ|jdj }|j ||jj dfd }|j||Scc}w) C Returns view corresponding to Kronecker product of view x with data 'a', i.e., kron(x,a). This function reshapes 'a' into a column vector, computes the Kronecker product with the view of x and reorders the row indices afterwards. Note: kron_l currently doesn't support parameters. TrDrrrcn|jdk(sJtj|}|ddddf}|Srr)rrrhsrs rrz&NumPyCanonBackend.kron_l..funcs766Q; ;wwq#H7A .HOrrPrr r&rris_param_free_rhsrr!rrrs @@rrzNumPyCanonBackend.kron_ls"&!7!7$t!7!T    3x1}}!fxx1}}2#CII23q888HHQK%% ,,YG  --dK\-]]3rc|tjk7sJttj|}|tjj tj tj|diiS)z Returns tensor of a variable node, i.e., eye(n) across axes 0 and 1, where n is the size of the variable. This function expands the dimension of an identity matrix of size n on the parameter axis. rrrrrBr/rGr expand_dimsrVr&r"r*rps rrz%NumPyCanonBackend.get_variable_tensorsVhkk)))  hkk//q PQ1RSTTrc|j|}|jdd}tjjtjjt j |diiS)z Returns tensor of constant node as a column vector. This function expands the dimension of the column vector on the parameter axis. rrrrrr)r:rrrrr/rr&rrs rrz!NumPyCanonBackend.get_data_tensor%sT ~~d#gS1 !!HKK$5$5r~~fST7U#VWWrc|tjk7sJttj|}tjj |tj tj|diiS)z Returns tensor of a parameter node, i.e., eye(n) across axes 0 and 2, where n is the size of the parameter. This function expands the dimension of an identity matrix of size n on the column axis. rrr)r&r"r.rps rrz"NumPyCanonBackend.get_param_tensor.sVx{{***   !!L"..QS2T#UVVrct |j}tj|}|S#t$r|}Y$wxYw)zX Internal function that converts a sparse input to a dense numpy array. )toarrayAttributeErrorr/ atleast_2d)rrs rr:zNumPyCanonBackend._to_dense9s=  ))+CmmC   C s ) 77N)rvr rSr)rdict[int, np.ndarray]rr!rSrrR)rSrB)rr rrBrSrB)rr rrBrSrBr1)r"r2r*rBrS dict[int, dict[int, np.ndarray]])rrrSr)r"r2r.rBrSr)rrrr3rrr|ryrrrrrrrrrrrrrrrrr:rrrrcrcs(3,;3@U335#5?^6    ^(##Jb(<  (^TQQ ^*^6^6 U/ UX W/ W  rrccVeZdZeddZe ddZe ddZddZed dZd!dZ d"dZ ed!dZ ed!d Z d!d Z d d Zd#d Zd$d Zd!dZed!dZed%dZd!dZd&dZ d"dZed!dZd!dZd!dZd!dZ d'dZ d(dZ d)dZy)*rdctj|jr|jggn |j}tj|}|j |j k(sJ|Sr9)r/isscalarrrH csr_arrayr")rvrr;s rrz.SciPyCanonBackend.get_constant_data_from_constGsO #%++fkk":  <<%~~---rc ~|jDcic]\}}|tj||c}}Scc}}w)a Reshape constant data from column format to the required shape for operations that do not require column format. This function unpacks the constant data dict and reshapes the stacked slices of the tensor 'v' according to the lin_op_shape argument. )r=rd_reshape_single_constant_tensorr>s rrz'SciPyCanonBackend.reshape_constant_dataQsD*//13Aq$DDQ UU3 33!9c|jddk(sJtj|jtj|z}|jd|z|jdf}|j}|j|j }}tj ||d\}}tj ||d\} } ||dz| z} ||dz|df} tj|| | ff| S)z Given v, which is a matrix of shape (p * lin_op_shape[0] * lin_op_shape[1], 1), reshape v into a matrix of shape (p * lin_op_shape[0], lin_op_shape[1]). rrr*) r"r/rGtocoorrdivmodrHrI) r?rrq old_shapecoor stacked_rowsslicesrKnew_colsrnew_stacked_shapes rrz1SciPyCanonBackend._reshape_single_constant_tensor]swwqzQ GGAGG  5 5WWQZ1_aggaj1 ggi XXswwlyyy|< YYt\!_=(LO+h6a0,q/B||THh#78@QRRrctj|j|j|j|j |j S)z Returns an empty view of the corresponding SciPyTensorView subclass, coupling the SciPyCanonBackend subclass with the SciPyTensorView subclass. )SciPyTensorViewryr\r]r^r_r`r%s rryz SciPyCanonBackend.get_empty_viewrs? --d.F.F6:6H6H$J[J[6:ooG Grc.d}|j||S)rc| Sr$r)r_ps rrz#SciPyCanonBackend.neg..funcrrrrs rrzSciPyCanonBackend.neg{s   t rc|j|j|d\}}|rU|j|jdz}|dkDr,t j t j |d|n|fd}n]|jtt|jjdz}|dkDr|j||n|fd}|}|j|| S) rFrDrrcsrformatc|dk(r|zjStjtj|d|zj SNrcscrtocsrrHr  eye_arraytocscrrqrIs rrz#SciPyCanonBackend.mul..funcH6'!O2244WWR\\!E%BKPTUU\\^^rc^jDcic] \}}|||z c}}Scc}}wr$r=rHs rrJz/SciPyCanonBackend.mul..parametrized_muls,-8->->-@ATQ1q5AAAs)rP) rrrKr"rHr rrSrTrU_stacked_kron_rrX) r&rrrYrZr[rrJrIs @rrzSciPyCanonBackend.muls"&!7!7$u!7!U  99 " -Dax!wwr||D'GM !  _ 99T#**,%7 8 > >r BBDax"223= !  B$D--dK\-]]rcRt}|jD]\}}|j|}|jd|z|jdf}|j }|j |j |j} } } tj| |d\} } tj| | |dz|zz|tjtj||dzt| z} tj| |tjtj||dzt| z}tj| |}|jd|z|jd|zf}tj|| |ff|||<|S)a7 Given a stacked lhs [[A_0], [A_1], ... apply the Kronecker product with the identity matrix of size reps (kron(eye(reps), lhs)) to each slice, e.g., for reps = 2: [[A_0, 0], [0, A_0], [A_1, 0], [0, A_1], ... rrr*)rRr=r^r"rrrrr/rrepeatr_rrrHrI)r&rYr[rparam_idr?rqrrrrKrLrrrnew_data new_shapes rrz!SciPyCanonBackend._stacked_kron_rsrf99; CKHa""8,Aq!''!*5I'')C"xx#''$D99T9Q<8LFDyy1(=(D!DdK $)A,6D BCHyyt, $)A,6D BCHyyt,Hd*AGGAJ,=>ILLHh/0 CCM C rcttj|j}tj|j t}|j ||S)z@ Promote view by repeating along axis 0 (rows). )rBr/rGr"rrEr)rrr`rKs rrzSciPyCanonBackend.promotesG "''#)),- xx $++C0  rc<|j}|jdj}tjtj|t j |d}tj||jd}|j||Srbrcrds rrzSciPyCanonBackend.broadcast_torfrcj|j|d\}|rfd}nfd}|}|j||S)a; Given (A, b) in view and constant data d, return (A*d, b*d). When dealing with parametrized constant data, we need to repeat the variable tensor p times and stack them vertically to ensure shape compatibility for elementwise multiplication with the parametrized expression. TrDc|dk(rj|Stjg|z}|j|Sr^multiplyrHrrrqnew_lhsrYs rrz(SciPyCanonBackend.mul_elem..funcs=6<<?* ii 2G"++A..rc jDcic];\}}||jtj|gj|z=c}}Scc}}wr$)r=rrHrr^)rrr?rYr&s rrJz4SciPyCanonBackend.mul_elem..parametrized_mulsV$'IIK1 Aq1::biid6H6H6K0K&LMM111sAArP)rrrX)r&rrrZrrJrYs` @rrzSciPyCanonBackend.mul_elemsQ"&!7!7$t!7!T   / 1$D--dK\-]]rcP|jfd}|j||S)az Given (A, b) in view, return the sum of the representation on the row axis, ie: (sum(A, axis=axis), sum(b, axis=axis)). Here, since the slices are stacked, we sum over the rows corresponding to the same slice. Note: we form the sparse output directly using _get_sum_row_indices and column indices in column-major order. cltjdj}j\}}|dk(rS|Bt j |j djd|jdS||}||zS|jd|z}|Qt jt j|dtjd|f|zjS||}t jt j|d||zjS)Nrrr)r"r rr) rnrgr"rrHrrxrr rr/rr) rrqr"r roAmrsum_coeff_matrixs rrz+SciPyCanonBackend.sum_entries..funcs$))A,,,-EiiGD!Av<<<1 (=(=a(LMM(u4@Aq5LGGAJ!O<GGBLL5$A277Aq6?SVWW^^``(u4@AGGBLL5$A1EIPPRRr)_get_sum_coeff_matrixr)r&rrrrs ` @rrzSciPyCanonBackend.sum_entriess* 55 S" t rc tjtt||d}tj||}tj ||}tj ||d}|jdS)a Internal function that computes the row indices corresponding to the sum along a specified axis. Example: shape = (2,2,2) and axis = (1) out_axes = [True, False, True] out_idx[0] = [[[0, 0], [0, 0]], [[1, 1], [1, 1]]] out_idx[1] = [[[0, 1], [0, 1]], [[0, 1], [0, 1]]] out_dims = [2, 2] row_idx = [[[0, 2], [0, 2]], [[1, 3], [1, 3]]] row_idx.flatten(order='F') = [0, 1, 0, 1, 2, 3, 2, 3] T)invertr)dimsrr)r/isinrrrr0ravel_multi_indexr)r&r"r out_axesout_idxout_dimsrs r_get_sum_row_indicesz&SciPyCanonBackend._get_sum_row_indicessi.775U,d4@**U#H-88E?8,&&wXSIS))rc|t|tr|n|f}tj|t}tj|Dcgc]}|| c}t}|j ||}tj |}tjtj|||ff||z|f}|Scc}w)zh Internal function that computes the sum coefficient matrix for a given shape and axis. r?r*) r6rnr/rGrBrrrHrr) r&r"r rprrrrcol_idxrs rrz'SciPyCanonBackend._get_sum_coeff_matrix0s"$.tTG GGE % GGt,!U1X,C 8++E48))A, LL"''!*w&89!Q$ K -s B9c|j|j|d\}|sJtjjt_fd}|j ||S)ruTrDr?c|dk(rj|Stjg|z}|j|Sr^rrs rrxz'SciPyCanonBackend.div..div_funcJs=Av||A&))SEAI.''**rrP)rrr/rzrArXr{s @rrzSciPyCanonBackend.div<sc"&!7!7$t!7!T    ==7 +--hO`-aarc|jd|jdk(sJ|j|jdt|jddzfd}|j||S)rrrrct|j}t|z|d<|j}t j |j |jd|z\}}dk(r |dzz}ndkDr|dzzzz}n |dzzz }||zzjt}tj|j||jff|SrF) rr"rBrr/rrrErHrIrr) rrqr"x_slicex_rowrrrKrs rrz(SciPyCanonBackend.diag_vec..func`sME:>*E!H AYYquuaggajAo>NGUAv D1H-Q D1H-q8 D1H-1 7Z#77??DH<<(AEE): ;UC Crrrs @@@rrzSciPyCanonBackend.diag_vecSsiyy|syy|+++ HHyy|1*+  D t rcfd}|S)rcf|j}|jd|z}|j|z}|j|dzzz}|||z z jtzz}t j |j||jfft |z|jdfS)Nrrr*) rr"rrErBrHrIrr)rrqcoo_reprrrrrrs rrz4SciPyCanonBackend.get_stack_func..stack_funcws||~Hq!Q&A\\Q&F  f'<.funcrrczjDcic]\}}|||zjc}}Scc}}wr$)r=rrHs rrJz0SciPyCanonBackend.rmul..parametrized_muls37B7H7H7JKtq!AE==?*KKKs7rP)rrrrgr"TrKrHr rrSrTr=r^_transpose_stacked_stacked_kron_lrX) r&rrrYrZrr[rrr?rrJrIs @rrzSciPyCanonBackend.rmuls2"&!7!7$u!7!U +.sxx{/@/@+AQ+F388A;$$Q'CHHUVKL]L]^_L` 388>>"a'H ! ,Dee99 ! ,Dax ggceeR\\$u-MN !ee  _ SYY[)*DAqwwqzT%7%7%::H388>>"a'H,@EHIIKPDAqq$11!Q77PPD-.1771:););A)>>99(D@C L11d--a33LCLax"223= !  L$D--dK\-]]#Q Ms *J0J c|jd|j|z|jdf}|jd|dz}|d|df}||dz|df}|j}|j|j|j } }}t j||d\} }| | |dzz} |} tj|| | ff|S)a Given v, which is a stacked matrix of shape (p * n, m), transpose each slice of v, returning a stacked matrix of shape (p * m, n). Example: Input: Output: [[A_0], [[A_0.T], [A_1], [A_1.T], ... ... rrr*) r"r^rrrrr/rrHrI) r&r?rrrqrrrrKrLrrrs rr z$SciPyCanonBackend._transpose_stackedsWWQZ4#5#5h#??L GGAJ)A, &q\9Q<0 1-y|< GGI66155!%%Ddyyy|4 &9Q<//||THh#78@QRRrct}|jD]9\}}|j||j}|j|j |j } }}tj||z|tjtj|t|z} tj| |z|tjtj|t| z} tj||} |jd|z|jd|zf} tj| | | ff| ||<<|S)a} Given a stacked lhs with the following entries: [[a11, a12], [a21, a22], ... Apply the Kronecker product with the identity matrix of size reps (kron(lhs, eye(reps))) to each slice, e.g., for reps = 2: [[a11, 0, a12, 0], [0, a11, 0, a12], [a21, 0, a22, 0], [0, a21, 0, a22], ... rrr*)rRr=r^rrrrr/rr_rrr"rHrI)r&rYr[rrr?rrrKrLrrrrs rr z!SciPyCanonBackend._stacked_kron_lsf99; CKHa   x ('')C"xx#''$Dyyd3bggbiiosSWy6YYHyyd3bggbiiosSWy6YYHyyt,Hd*AGGAJ,=>ILLHh/0 CCM C rc|jdj}tj|d|dztj|dz}tjt |}tj t ||jtf}tj||fdtj|fdfd }|j|dS)z Select the rows corresponding to the diagonal entries in the expression and sum along axis 0. Apply kron(eye(p), lhs) to deal with parametrized expressions. rrr*c|dk(r|zjStjtj|d|zj SrrrrqrYs rrz%SciPyCanonBackend.trace..funcsEAva(( Qu =sCaGNNPPrTrP)rSrU) rgr"r/rrrrrErBrHrrGrX)rrr"rridxrrYs @rrzSciPyCanonBackend.traces !!))E!H%a0299U1X3FFwws7|$xxG %w~~c':;llD#;q"''%..AB Q --d4-PPrc |j|j|d\ }|sJd jdk(sJt|jjdk(r j |jd}t|j djdkDr|j djdnd} j j}tj j|tjtj||zjt}tj j |tjtj||zjt}tj j|} t#j$| ||ff||f fd} |j'| | S) rFrDzBSciPy backend does not support parametrized left operand for conv.rrrr*c&|dk(sJd|zS)NrzCSciPy backend does not support parametrized right operand for conv.rrs rrz$SciPyCanonBackend.conv..func!s$6 VU V67NrrP)rrrrr"rrgrnnzr/r_rrrrErBrrHrrX) r&rrrZrKrLnonzerosrrrrrYs @rrzSciPyCanonBackend.convs~"&!7!7$u!7!U   Q P Q xx1}} sxx~~ ! #%%Cyy|'*388A;+<+<'='Asxx{  #qiik7777377D)BIIbiiox,PPXXY\]77377D)BIIbiiox,PPXXY\]wwsxx&llD7G"45dD\J  --dK\-]]rc|j|j|d\}|sJdjdk(sJt|jDchc]}|j c}dk(sJ|jdj }|j |jj |fd}|j||Scc}w) rTrDzDSciPy backend does not support parametrized left operand for kron_r.rrrc|dk(sJd|jdk(sJtj|j}|ddf}|S)NrzESciPy backend does not support parametrized right operand for kron_r.rrrHr r)rrqrrYrs rrz&SciPyCanonBackend.kron_r..func:sV6 XW X666Q; ;wwsA,,.H +HOrrPrrrrrgr"r(rXrs @@rrzSciPyCanonBackend.kron_r(s"&!7!7$t!7!T   S R S xx1}}2#CII23q888HHQK%% ,,SXX^^YG --dK\-]]3Cc|j|j|d\}|sJdjdk(sJt|jDchc]}|j c}dk(sJ|jdj }|j ||jj fd}|j||Scc}w) rTrDzESciPy backend does not support parametrized right operand for kron_l.rrrc|dk(sJd|jdk(sJtj|j}|ddf}|S)NrzDSciPy backend does not support parametrized left operand for kron_l.rr)rrqrrrs rrz&SciPyCanonBackend.kron_l..funcVsV6 WV W666Q; ;wwq#,,.H +HOrrPrrs @@rrzSciPyCanonBackend.kron_lDs"&!7!7$t!7!T   T S T xx1}}2#CII23q888HHQK%% ,,YG --dK\-]]3rc|tjk7sJttj|}|tjj t j|diiS)z Returns tensor of a variable node, i.e., eye(n) across axes 0 and 1, where n is the size of the variable. This function returns eye(n) in csc format. rr)rrrBr/rGrrHrrs rrz%SciPyCanonBackend.get_variable_tensor`sMhkk)))  hkk//a1NOPPrcXt|tjr'tj|j dd}n4tj |j ddj}tjjtjj|iiS)z Returns tensor of constant node as a column vector. This function reshapes the data and converts it to csc format. rrr) r6r/rWrHrr coo_matrixrrrrrs rrz!SciPyCanonBackend.get_data_tensorksx dBJJ '\\$,,wc,"BCF]]4(000DJJLF !!HKK$5$5v#>??rc|tjk7sJ|j|}tt j ||zdf}t j |t j|t j||zzt j|ff}tj||}tjj||iiS)z Returns tensor of a parameter node, i.e., eye(n) across axes 0 and 2, where n is the size of the parameter. This function returns eye(n).flatten() in csc format. r) rrr^rBr/rGrrrrHrIr)r&r"r. param_sizer param_vecs rrz"SciPyCanonBackend.get_param_tensorxsx{{***'' 5 RWWU^j0115ggj!BIIj$9BIIj*: b.: 5^nS08QQ*#^J^8^8 Q . Q @ . @ > . >rrdceZdZdZ d dZddZeeddZe ddZ eddZ e eddZ eddZedd Zedd Ze dd Zy )r/z A TensorView represents the tensors for A and b, which are of shape rows x var_length x param_size_plus_one and rows x 1 x param_size_plus_one, respectively. The class facilitates the application of the CanonBackend functions. c |||nd|_||_||_||_||_||_||_||_yr$)rrrr\r]r^r_r`) r&rrrr\r]r^r_r`s rrazTensorView.__init__sJ-9,DL$ !2$7 "*($rct||jsJ|j|jz|_|j|j|j|_|j xr |j |_|Sr$)r6 __class__rcombine_potentially_nonerrr7s r__iadd__zTensorView.__iadd__si%000 --0B0BB33DKKN !%!7!7!SE|tjjhk(S)zA Does the TensorView only contain constant data? )rrr)rs ris_constant_datazTensorView.is_constant_datas  1 1222rcy)z3 Number of rows of the TensorView. Nrr%s rrKzTensorView.rowsrrcy)z Returns [A b]. Nr)r&rrs rr{z$TensorView.get_tensor_representationr,rcy)z, Select 'rows' from tensor. Nr)r&rKs rrzTensorView.select_rowsr,rcy)zI Apply 'func' across all variables and parameter slices. Nr)r&rs rrzTensorView.apply_allr,rcy)zZ Create new TensorView with same shape information as self, but new data. Nrr&rrrs rrz!TensorView.create_new_tensor_viewrrN)rzset[int] | NonerrrrTr\rBr]rnr^rnr_rnr`rB)r8r/rSr/)rs Any | Noner.r8rSr8) r\rBr]rnr^rnr_rnr`rBrSr/)rset[int]rSrTrSrBrrBrrBrSrrKrrSNonerr rSr=)rr9rrrrTrSr/)rrrrVrar*r3rr)rXryr1propertyrKr{rrrrrrr/r/s7 %.%%%)%'* % + % !/ % .%!%*  &4DR#&33            rr/c^eZdZdZddZd dZeed dZeedZ d dZ y) DictTensorViewa The DictTensorView abstract class handles the dictionary aspect of the tensor representation, which is shared across multiple backends. The tensor is contained in the following data structure: `Dict[variable_id, Dict[parameter_id, tensor]]`, with the outer dict handling the variable offset, and the inner dict handling the parameter offset. Subclasses have to implement the implementation of the tensor, as well as the tensor operations. c|jjD]I\}}|r|j||n"||tjj |j|<K|j xr||_|S)ar Apply 'func' to A and b. If 'func' is a parameter free function, then we can apply it to all parameter slices (including the slice that contains non-parameter constants). If 'func' is not a parameter free function, we only need to consider the parameter slice that contains the non-parameter constants, due to DPP rules. )rr=apply_to_parametersrrrr)r&rrQr*rs rrXz(DictTensorView.accumulate_over_variabless|$(;;#4#4#6 L K&(,'?'?f'M,0 8I8I1J,K KK $ L"&!7!7!R>!Q' 'rcy)zP Returns element-wise addition of two tensors of the same type. Nrr-s r add_tensorszDictTensorView.add_tensorsrrcy)z; Returns the type of the underlying tensor Nrrrr tensor_typezDictTensorView.tensor_typerrc6i}t|j}t|j}||z}|D]}t||tr/t||tr|j ||||||<Et|||j r9t|||j r|j ||||||<td|j d||z D] }||||< ||z D] }||||< |S)z2 Addition for dict-based tensors. zValues must either be dicts or .)setkeysr6rRrErIrGr;)r&rsr.rkeys_akeys_b intersectkeys rrEzDictTensorView.add_dicts&s,QVVXQVVXVO  ZC!C&$'Jqvt,D>>!C&!C&9CAcFD$4$4$67JqvtO_O_OasO ;; "T$t{{'9'9';"<=DDFGHNNqQ Q rc|jJ||jdzf}g}|jjD]"\}}|jD]\}}|j\} } } |j t |j dtjtjtj| | | |ztjtjtj| | | |j|ztjtj| | | z|j|z| %t j|S)a Returns a TensorRepresentation of [A b] tensor. This function iterates through all the tensor data and constructs the respective representation in COO format. To obtain the data, the tensor must be flattened as it is not in a sparse format. The row and column indices are obtained with numpy tiling/repeating along with their respective offsets. Note: CVXPY currently only supports usage of sparse matrices after the canonicalization. Therefore, we must return tensor representations in a (data, (row,col)) format. This could be changed once dense matrices are accepted. rrrr*)rr`r=r"r1rrr/rr_rr]r_r4) r&rrr"tensor_representationsr*rr.parameter_tensorr rKrLs rr{z)NumPyTensorView.get_tensor_representationIs@{{&&&T__q01!#,0KK,=,=,?  (K2A2G2G2I . .)9)?)?& D$&--.B$,,3,7IIbggbiiot Knn[12GGBIIj14$;?$BSBST`Baa /  $++,BCCrc2fd}|j|y)z Select 'rows' from tensor. The rows of the 3d tensor are in axis=1, this function selects a subset of the original tensor. c|ddddfSr$r)rrKs rrz)NumPyTensorView.select_rows..funcksQaZ= rNrr&rKrs ` rrzNumPyTensorView.select_rowses  ! trc|jjDcic]0\}}||jDcic]\}}|||c}}2c}}}}|_ycc}}wcc}}}}w)z Apply 'func' across all variables and parameter slices. The tensor functions in the NumPyBackend manipulate 3d arrays. Therefore, this function applies 'func' directly to the tensor 'v'. N)rr=r&rvar_idparameter_reprrr?s rrzNumPyTensorView.apply_allpsv6:[[5F5F5HJJ16>,:,@,@,B D$(Aq!"47  DDJ  DJsA' A!A' !A' c t||||j|j|j|j|j S)zn Create new NumPyTensorView with same shape information as self, but new tensor data. )rBr\r]r^r_r`r7s rrz&NumPyTensorView.create_new_tensor_viewzs> |V5FH`H`#~~t/A/A4CTCT#0 0rcb|jDcic]\}}|||c}}Scc}}w)zT Apply 'func' to the entire tensor of the parameter representation. r)rparameter_representationrr?s rrCz#NumPyTensorView.apply_to_parameterss.(@'E'E'GHtq!47 HHHs+c ||zS)zG Apply element-wise addition on two dense numpy arrays rr-s rrGzNumPyTensorView.add_tensors 1u rc"tjS)zP The tensor is represented as a 3-dimensional dense numpy array )r/rWrrrrIzNumPyTensorView.tensor_types zzrNr:r;r<r>)rr9rrrrTrSrB)rr rarrSr)rsrr.rrSr) rrrr?rKr{rrrr3rCrGrIrrrrBrB<s D8 J0260;J0I6KI$II rrBcxeZdZed dZd dZd dZd dZ ddZ ddZ e ddZ e dZ y )rc|jZ|jjD]<}|jD]'\}}|jd|j|zccS>yt d)z Number of rows of the TensorView. This is calculated by dividing the totals rows of the tensor by the number of parameter slices. NrzTensor cannot be None)rrUr=r"r^r;)r& param_dictr param_mats rrKzSciPyTensorView.rowssx ;; ""kk002 N +5+;+;+=N'Hi$??1-1C1CH1MMMN N45 5rc h|jJ||jdzf}g}|jjD]\}}|jD]\}}|j|} |jd| z} |j d} |j t| j| j| z|z| j|j|z| j| ztj| j|j|zz|tj!|S)a Returns a TensorRepresentation of [A b] tensor. This function iterates through all the tensor data and constructs their respective representation in COO format. The row data is adjusted according to the position of each element within a parameter slice. The parameter_offset finds which slice the original row indices belong to before applying the column offset. rrF)copyr*)rr`r=r^r"rr1rrrrr]r/rrr_r4) r&rrr"rVr*rr.parameter_matrixrqrrs rr{z)SciPyTensorView.get_tensor_representations-{{&&&T__q01!#,0KK,=,=,?  (K2A2G2G2I . .&&|4$**1-2+11u1=&--.BMM\\A%3LL4>>+#>>LLA% (=@Q@QR^@_(__ /  $++,BCCrc2fd}|j|y)z Select 'rows' from tensor. If there are multiple parameters 'p', we must select the same 'rows' from each parameter slice. This is done by introducing an offset of size 'm' for every parameter. c|dk(r |ddfS|jd|z}|tj|tjtj||zt zddfSr~)r"r/r_rrr)rrqrrKs rrz)SciPyTensorView.select_rows..funcsfAvqz!GGAJ!Oq)BIIbiilQ6FD ,RRTUUVVrNrrZs ` rrzSciPyTensorView.select_rowss  W trc|jjDcic]>\}}||jDcic]\}}||||j|c}}@c}}}}|_ycc}}wcc}}}}w)z Apply 'func' across all variables and parameter slices. For the stacked-slices backend, we must pass an additional parameter 'p' which is the number of parameter slices. N)rr=r^r\s rrzSciPyTensorView.apply_alls6:[[5F5F5HJJ16>,:,@,@,B D$(Aq!"44+=+=a+@#A A DDJ  DJsA5 !A/A5 /A5 c t||||j|j|j|j|j S)zn Create new SciPyTensorView with same shape information as self, but new tensor data. )rr\r]r^r_r`r7s rrz&SciPyTensorView.create_new_tensor_views? |V5F'+'?'?'+'9'94;L;L'+8 8rc ~|jDcic]\}}||||j|c}}Scc}}w)z Apply 'func' to each slice of the parameter representation. For the stacked-slices backend, we must pass an additional parameter 'p' which is the number of parameter slices. )r=r^)r&rrarr?s rrCz#SciPyTensorView.apply_to_parameterss=?W>\>\>^_da44--a011___rc ||zS)zF Apply element-wise summation on two sparse matrices. rr-s rrGzSciPyTensorView.add_tensorsrcrcBtjtjfS)z The tensor representation of the stacked slices backend is one big sparse matrix instead of smaller sparse matrices in a list. )rHsparrayspmatrixrrrrIzSciPyTensorView.tensor_types  BKK((rNr:r;r<r>)rr9rrrrTrSr)rr radict[int, sp.spmatrix]rSru)rs sp.spmatrixr.rvrSrv) rrrr?rKr{rrrrCr3rGrIrrrrrsz  6 6D4 J 826 8;J 8`6L`%` ))rr)'rV __future__rabcrr dataclassesrenumrtypingrr numpyr/ scipy.sparsesparserH scipy.signalr cvxpy.settingssettingsr cvxpy.lin_opsr r rrrrrZrrrercrdr/rArBrrrrrs##! !   t  J]J] J]Z; 3; |n n b7|7(E*EP >*>Db b JLZL^]n]@e)ne)r