biL$dZddlZddlmZddlmZddlZddlm Z ddl m Z ddl m Z ddlmZd Zd Zd#d efd Zd#d efd Zd#d efdZdefdZdefdZdefdZdefdZdZd$d edefdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%d Z&d!Z'd"Z(y)%a, Copyright 2013 Steven Diamond 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. N) defaultdictFraction)reshape)vstack)SOC)Variablec |j}tt||z|fdtt||z d|fdtd|zd|fdgdS)NF)orderr)tXaxis)sizerrr)rxylengths V/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/cvxpy/utilities/power_tools.pygmrsc VVF 1vis31Q3F 371Q3F 37  c 6t|sJt|}t|}tfd}||<t |t |z }|dkDr |g|zz }t |t |k(sJt t ||D]0\}\}}|dkDsdgt |z} d| |<||t| <2g} |jD]*\} } d| vs | t|| || d|| dgz } ,t |dk(r|d} | | k(gz } | S)a Form the internal CXVPY constraints to form the weighted geometric mean t <= x^p. t <= x[0]^p[0] * x[1]^p[1] * ... * x[n]^p[n] where x and t can either be scalar or matrix variables. Parameters ---------- t : cvx.Variable The epigraph variable x_list : list of cvx.Variable objects The vector of input variables. Must be the same length as ``p``. p : list or tuple of ``int`` and ``Fraction`` objects The powers vector. powers must be nonnegative and sum to *exactly* 1. Must be the same length as ``x``. Returns ------- constr : list list of constraints involving elements of x (and possibly t) to form the geometric mean. c.tjSN)r shapersrzgm_constrs..EsHQWW-rrr ) is_weightdyad_completion decomposerlen enumerateziptupleitemsr)rx_listpwtreedlong_wivtmp constraintselemchildrenrs` r gm_constrsr3'sE4 Q<<A Q|sP q5L5 AAaC++I6A ac7Q!H rreturncZt|tjxr|dkDxr ||dz z S)a Test if num is a positive integer power of 2. .. note:: Fails if num is a np.integer type like np.int32, np.int64, etc. This seems to be a Python 3 issue. Make sure to convert all integers to the native python ``int`` type. Examples -------- >>> is_power2(4) True >>> is_power2(2**10) True >>> is_power2(1) True >>> is_power2(1.0) False >>> is_power2(0) False >>> is_power2(-4) False rr ) isinstancenumbersIntegral)nums r is_power2rEs0. c7++ , Rq R#q/=RRrct|tjr|dk\ryt|tr|dk\rt |j ryy)a7 Test if frac is a nonnegative dyadic fraction or integer. Examples -------- >>> is_dyad(Fraction(1,4)) True >>> is_dyad(Fraction(1,3)) False >>> is_dyad(0) True >>> is_dyad(1) True >>> is_dyad(-Fraction(1,4)) False >>> is_dyad(Fraction(1,6)) False rTF)rArBrCrrE denominator)fracs ris_dyadrIs@&$(()dai D( # i@P@P6Qrc@t|xrtd|DS)ax Test if a vector is a valid dyadic weight vector. w must be nonnegative, sum to 1, and have integer or dyadic fractional elements. Examples -------- >>> is_dyad_weight((Fraction(1,2), Fraction(1,2))) True >>> is_dyad_weight((Fraction(1,3), Fraction(2,3))) False >>> is_dyad_weight((0, 1, 0)) True c32K|]}t|ywr)rI.0fs r z!is_dyad_weight..s6q 6)rall)r)s ris_dyad_weightrRs Q< 6C6A666rct|tjr|j}t d|D}|xrt |dk(S)a Test if w is a valid weight vector. w must have nonnegative integer or fractional elements, and sum to 1. Examples -------- >>> is_weight((Fraction(1,3), Fraction(2,3))) True >>> is_weight((Fraction(2,3), Fraction(2,3))) False >>> is_weight([.1, .9]) False >>> import numpy as np >>> w = np.array([.1, .9]) >>> is_weight(w) False >>> w = np.array([0, 0, 1]) >>> is_weight(w) True >>> w = (0,1,0) >>> is_weight(w) True c3jK|]+}|dk\xr t|tjtf-ywrNrArBrCrrMr.s rrOzis_weight..s?NFG1fB W%5%5x$@ABNs13r )rAnpndarraytolistrQsum)r) valid_elemss rrrsJ0!RZZ HHJNKLNNK  &3q6Q;&rz Can't reliably represent the input weight vector. Try increasing `max_denom` or checking the denominators of your input fractions. force_dyadctd|Dr tdttjrdkDs tdt|t j r|j}tt||dur t|}n{td|Dr:tfd|D}td|D}|kDr>tttfd |D}t|d k7r t|}t|}td |DkDrtt||fS) a Return a valid fractional weight tuple (and its dyadic completion) to represent the weights given by ``a``. When the input tuple contains only integers and fractions, ``fracify`` will try to represent the weights exactly. Parameters ---------- a : Sequence Sequence of numbers (ints, floats, or Fractions) to be represented with fractional weights. max_denom : int The maximum denominator allowed for the fractional representation. When the fractional representation is not exact, increasing ``max_denom`` will typically give a better approximation. Note that ``max_denom`` is actually replaced with the largest power of 2 >= ``max_denom``. force_dyad : bool If ``True``, we force w to be a dyadic representation so that ``w == w_dyad``. This means that ``w_dyad`` does not need an extra dummy variable. In some cases, this may reduce the number of second-order cones needed to represent ``w``. Returns ------- w : tuple Approximation of ``a/sum(a)`` as a tuple of fractions. w_dyad : tuple The dyadic completion of ``w``. That is, if w has fractions with denominators that are not a power of 2, and ``len(w) == n`` then w_dyad has length n+1, dyadic fractions for elements, and ``w_dyad[:-1]/w_dyad[n] == w``. # ^ That isn't always possible, is it? Alternatively, the ratios between the first n elements of ``w_dyad`` are equal to the corresponding ratios between the n elements of ``w``. The dyadic completion of w is needed to represent the weighted geometric mean with weights ``w`` as a collection of second-order cones. The appended element of ``w_dyad`` is typically a dummy variable. Examples -------- >>> w, w_dyad = fracify([1, 2, 3]) >>> w (Fraction(1, 6), Fraction(1, 3), Fraction(1, 2)) >>> w_dyad (Fraction(1, 8), Fraction(1, 4), Fraction(3, 8), Fraction(1, 4)) >>> w, w_dyad = fracify((1, 1, 1, 1, 1)) >>> w (Fraction(1, 5), Fraction(1, 5), Fraction(1, 5), Fraction(1, 5), Fraction(1, 5)) >>> w_dyad (Fraction(1, 8), Fraction(1, 8), Fraction(1, 8), Fraction(1, 8), Fraction(1, 8), Fraction(3, 8)) >>> w, w_dyad = fracify([.23, .56, .87]) >>> w (Fraction(23, 166), Fraction(28, 83), Fraction(87, 166)) >>> w_dyad (Fraction(23, 256), Fraction(7, 32), Fraction(87, 256), Fraction(45, 128)) >>> w, w_dyad = fracify([3, Fraction(1, 2), Fraction(3, 5)]) >>> w (Fraction(30, 41), Fraction(5, 41), Fraction(6, 41)) >>> w_dyad (Fraction(15, 32), Fraction(5, 64), Fraction(3, 32), Fraction(23, 64)) Can also mix integer, Fraction, and floating point types. >>> w, w_dyad = fracify([3.4, 8, Fraction(3, 2)]) >>> w (Fraction(34, 129), Fraction(80, 129), Fraction(5, 43)) >>> w_dyad (Fraction(17, 128), Fraction(5, 16), Fraction(15, 256), Fraction(127, 256)) Forcing w to be dyadic makes it its own dyadic completion. >>> w, w_dyad = fracify([3.4, 8, Fraction(3, 2)], force_dyad=True) >>> w (Fraction(135, 512), Fraction(635, 1024), Fraction(119, 1024)) >>> w_dyad (Fraction(135, 512), Fraction(635, 1024), Fraction(119, 1024)) A standard basis unit vector should yield itself. >>> w, w_dyad = fracify((0, 0.0, 1.0)) >>> w (Fraction(0, 1), Fraction(0, 1), Fraction(1, 1)) >>> w_dyad (Fraction(0, 1), Fraction(0, 1), Fraction(1, 1)) A dyadic weight vector should also yield itself. >>> a = (Fraction(1,2), Fraction(1,8), Fraction(3,8)) >>> w, w_dyad = fracify(a) >>> a == w == w_dyad True Be careful when converting floating points to fractions. >>> a = (Fraction(.9), Fraction(.1)) >>> w, w_dyad = fracify(a) Traceback (most recent call last): ... ValueError: Can't reliably represent the input weight vector. Try increasing `max_denom` or checking the denominators of your input fractions. The error here is because ``Fraction(.9)`` and ``Fraction(.1)`` evaluate to ``(Fraction(8106479329266893, 9007199254740992)`` and ``Fraction(3602879701896397, 36028797018963968))``. c3&K|] }|dk ywrUrWs rrOzfracify..ns Q1q5 z!Input powers must be nonnegative.rz%Input denominator must be an integer.Tc3\K|]$}t|tjtf&ywrrVrWs rrOzfracify..|s" DQZG,,h7 8 Ds*,c36K|]}t|ywrr)rMr.totals rrOzfracify..}s5ax5)5c34K|]}|jywrrGrWs rrOzfracify..~s.! .c3jK|]*}tt|z j,ywr)rfloatr6)rMr.r4rds rrOzfracify..s*XQRxa/AA)LXs03r c34K|]}|jywrrgrWs rrOzfracify..s )Q1== )rh)any ValueErrorrArBrCrXrYrZ next_pow2r[ make_fracrQr%max__EXCEED_DENOMINATOR_LIMIT__r )ar4r]w_fracr+w_dyadrds ` @rfracifyrus!p ! <== y'"2"2 3 A @AA!RZZ HHJ)$I FET1i( D! D D5155 .v. . y=9: :XVWXX v;! q),F V $F )& ))I5566 6>rcdtj|tt|z }|zj t }|tz |z }tj |dt|z }||xxdz cc<t |j}tfd|DS)ax Approximate ``a/sum(a)`` with tuple of fractions with denominator *exactly* ``denom``. >>> a = [.123, .345, .532] >>> make_frac(a,10) (Fraction(1, 10), Fraction(2, 5), Fraction(1, 2)) >>> make_frac(a,100) (Fraction(3, 25), Fraction(7, 20), Fraction(53, 100)) >>> make_frac(a,1000) (Fraction(123, 1000), Fraction(69, 200), Fraction(133, 250)) dtypeNr c36K|]}t|ywrr)rMr.denoms rrOzmake_frac..s/!U#/re) rXarrayrjr[astyper7argsortrZr%)rrrzberrindss ` rroros % Q'A 3A E%L.1 C ::c?,USV^ -DdGqLG JE  A /Q/ //rc@td|D}|Dcgc]$}t|jr|j&}}t|dkDrGt |t tfd|Dt z fz}t|S|Scc}w)a Return the dyadic completion of ``w``. Return ``w`` if ``w`` is already dyadic. We assume the input is a tuple of nonnegative Fractions or integers which sum to 1. Examples -------- >>> w = (Fraction(1,3), Fraction(1,3), Fraction(1, 3)) >>> dyad_completion(w) (Fraction(1, 4), Fraction(1, 4), Fraction(1, 4), Fraction(1, 4)) >>> w = (Fraction(1,3), Fraction(1,5), Fraction(7, 15)) >>> dyad_completion(w) (Fraction(5, 16), Fraction(3, 16), Fraction(7, 16), Fraction(1, 16)) >>> w = (1, 0, 0.0, Fraction(0,1)) >>> dyad_completion(w) (Fraction(1, 1), Fraction(0, 1), Fraction(0, 1), Fraction(0, 1)) c32K|]}t|ywrrrWs rrOz"dyad_completion..s %ahqk %rPrc3<K|]}t|zywrr)rMr.r+r(s rrOz"dyad_completion..s21hqsA&2s)r%rErGr"rprnrr )r)r. non_dyad_densw_augr+r(s @@rr r s*  %1 %%A,-NqYq}}5MQ]]NMN =A   aL222hqsA6F5HHu%%Os BBc td|DsJt|sJt|t|k(sJtj|t t |z }t tdt||DS)ac Return the :math:`\ell_\infty` norm error from approximating the vector a_orig/sum(a_orig) with the weight vector w_approx. That is, return .. math:: \|a/\mathbf{1}^T a - w_{\mbox{approx}} \|_\infty >>> e = approx_error([1, 1, 1], [Fraction(1,3), Fraction(1,3), Fraction(1,3)]) >>> e <= 1e-10 True c3&K|] }|dk\ ywrUr`rWs rrOzapprox_error..s&!qAv&rarwc3>K|]\}}t||z ywr)abs)rMv1v2s rrOzapprox_error..sDFBSBZDs) rQrr"rXr{rjr[rpr$)a_origw_approxw_origs r approx_errorrsr &v& && & X   v;#h- '' ' XXfE *3v; 6F Dc&(.CDD EErc^|dkrydt|jz}|dz |k(r|S|S)z Return first power of 2 >= n. >>> next_pow2(3) 4 >>> next_pow2(8) 8 >>> next_pow2(0) 1 >>> next_pow2(1) 1 rr )r7 bit_length)nn2s rrnrns: Av c!f! !B Qw!| rct|r tsy|k(rytt|dzk(r|tfdddDk(Sy)aCheck that w_dyad is a valid dyadic completion of w. Parameters ---------- w : Sequence Tuple of nonnegative fractional or integer weights that sum to 1. w_dyad : Sequence Proposed dyadic completion of w. Returns ------- bool True if w_dyad is a valid dyadic completion of w. Examples -------- >>> w = (Fraction(1,3), Fraction(1,3), Fraction(1,3)) >>> w_dyad =(Fraction(1,4), Fraction(1,4), Fraction(1,4), Fraction(1,4)) >>> check_dyad(w, w_dyad) True If the weight vector is already dyadic, it is its own completion. >>> w = (Fraction(1,4), 0, Fraction(3,4)) >>> check_dyad(w, w) True Integer input should also be accepted >>> w = (1, 0, 0) >>> check_dyad(w, w) True w is not a valid weight vector here because it doesn't sum to 1 >>> w = (Fraction(2,3), 1) >>> check_dyad(w, w) False w_dyad isn't the correct dyadic completion. >>> w = (Fraction(2,5), Fraction(3,5)) >>> w_dyad = (Fraction(3,8), Fraction(4,8), Fraction(1,8)) >>> check_dyad(w, w_dyad) False The correct dyadic completion. >>> w = (Fraction(2,5), Fraction(3,5)) >>> w_dyad = (Fraction(2,8), Fraction(3,8), Fraction(3,8)) >>> check_dyad(w, w_dyad) True FTr c3BK|]}t|ddz yw)r Nr)rMr.rts rrOzcheck_dyad..1s I(1ar l3IsNr)rrRr"r%)r)rts `r check_dyadrsTp aL^F3F{ 6{c!fqj EIVCR[IIIIrc6d|vrytdd}tdgt|z}td|D} t|D]J\}}||k\r||xx|zcc<||xx|z cc<t |dk(s4t |t |fcS|dz}^)a4 Split a tuple of dyadic rationals into two children so that d_tup = 1/2*(child1 + child2). Here, d_tup, child1, and child2 have nonnegative dyadic rational elements, and each tuple sums to 1. Basis vectors such as d_tup = (0, 1, 0) will return no children, since they cannot be split. r r`rc3&K|] }d|z yw)rNr`rLs rrOzsplit..Hs&!!A#&rar)rr"listr#r[r%rmformat)rtbitchild1child2indvals rsplitr6s F{ 1a.Cqk]3v; &F &v& &F !&) 4HCczs s" s s" 6{aV}eFm33  4 q rct|stdj|i}t|g}|D]&}||vst |||<|t ||z }(|S)a9 Recursively split dyadic tuples to produce a DAG. A node can have multiple parents. Interior nodes in the DAG represent second-order cones which must be formed to represent the corresponding weighted geometric mean. Return a dictionary keyed by dyadic tuples. The values are a list of that tuple's children. The dictionary will allow us to re-use nodes whose tuple we have already seen, which reduces the number of second-order cones that need to be formed. We use an OrderedDict so that the root node is the first element of tree.keys(). z-input must be a dyadic weight vector. got: {})rRrmrr%rr)rtr*todors rr!r!Vsp & !HOOPVWXX D &M?D " D=AhDG DaM !D" Krc>ddjd|DzdzS)z: Use the string representation of objects in a tuple. (z, c32K|]}t|ywr)strrLs rrOzprettytuple..qs-a3q6-rP))joinrs r prettytuplerns# -1-- - 33rc&td|DS)zS Get the maximum denominator in a sequence of ``Fraction`` and ``int`` objects c3FK|]}t|jywr)rrGrLs rrOz get_max_denom..ws41x{&&4s!)rp)tups r get_max_denomrts 44 44rctt|jtd}d}|D]C}t||td}|t |dzz }|D]}|dt |zdzz }E|S)z Print keys of a dictionary with children (expected to be a Sequence) indented underneath. Used for printing out trees of second order cones to represent weighted geometric means. T)keyreverseF z )sortedrkeysrr)r+rresultrr2childs r prettydictrzs $qvvx.mT BD F7!C&mUC+c"T)) 7E d[//$6 6F 77 Mrct|sJt|}tt|dz }t d|Ddz }t ||S)a Return a lower bound on the number of cones needed to represent the tuple. Based on two simple lower bounds. Examples -------- >>> lower_bound((0,1,0)) 0 >>> lower_bound((Fraction(1, 2), Fraction(1,2))) 1 >>> lower_bound((Fraction(1, 4), Fraction(1, 4), Fraction(1, 4), Fraction(1, 4))) 3 >>> lower_bound((Fraction(1,8), Fraction(7,8))) 3 c3.K|] }|dk7rdndywrr Nr`rMes rrOzlower_bound..s 1Q16aq 1sr )rRrr"binr[rp)rtmdlb1lb2s r lower_boundrsP & !! ! v B c"g,q.C  1& 1 1A 5C sC=rcZtd|D}t|t|z |z S)z Return the number of cones in the tree beyond the known lower bounds. if it is zero, then we know the tuple can't be represented in fewer cones. c3,K|] }|dk7s dywrr`rs rrOzover_bound..s/Q1/s )r[r"r)rtr*nonzeross r over_boundrs-/f//H t9{6* *X 55r))rF))__doc__rB collectionsr fractionsrnumpyrXcvxpy.atoms.affine.reshapercvxpy.atoms.affine.vstackrcvxpy.constraints.second_orderrcvxpy.expressions.variabler rr3r7r9r<r>boolrErIrRrrqruror rrnrrr!rrrrrr`rrrs #.,./8v 3  #  # SdS4T677"'D'@U#U$Up02BF*,@FE@04 5 "26r