bi\ &dZddlmZddlZddlZddlmZddlmZddl m Z m Z m Z m Z ddlZddlmZddlmcmZddlmZmZddlmZdd lmZdd lmZmZm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&dd l'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl>m@ZAddlBmCZCddlDmEZEmFZFddlGmHZHddlImJZJddlKmLZLmMZMddlNmOZOdd lmPZPdd!lQmRZRdd"lSmTZTed#gd$ZUd%ZVd&eVzd'zd(jeVzd'zd)e(jzjeVzd'zd&eVzzZYd*eVzd'zd+jeVzd'zd*eVzzZZd*eVzd'zd,jeVzd'zd*eVzzZ[d*eVzd'zd-jeVzd'zd*eVzzZ\d*eVzd'zd.jeVzd'zd*eVzzZ]Gd/d0Z^d1Z_Gd2d3ejZaeGd4d5ZbGd6d7Zcy)8aA Copyright 2013 Steven Diamond, 2017 Akshay Agrawal 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. ) annotationsN) namedtuple) dataclass)DictListOptionalUnion)Constanterror)settings)Atom)Equality InequalityNonNegNonPosZero) Constraint)DPPError)cvxtypes)Variable) scalar_value)MaximizeMinimize) InverseData)Chain)Dgp2Dcp)dqcp2dcp) EvalParams) FlipObjective)INF_OR_UNB_MESSAGE) bisection)defines) ConicSolver)SOLVER_MAP_CONIC SOLVER_MAP_QP)QpSolver)Solver) SolvingChainconstruct_solving_chain)SOLVERS) debug_tools) CITATION_DICT) unique_list SolveResult) opt_valuestatus primal_values dual_valuesO= CVXPYv- CompilationzNumerical solver CitationsSummaryc(eZdZddZddZdZdZy)Cachec<d|_d|_d|_d|_yNkey solving_chain param_prog inverse_dataselfs Q/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/cvxpy/problems/problem.py__init__zCache.__init__ks 5937c<d|_d|_d|_d|_yr?r@rEs rG invalidatezCache.invalidateqs ! rIc||||fSr?)rFsolvergp ignore_dpp use_quad_objs rGmake_keyzCache.make_keywsJ 55rIc@|jduxr|jdS)NrArEs rGrOzCache.gpzsxxt#3 3rINreturnNone)__name__ __module__ __qualname__rHrKrRrOrMrIrGr=r=js8 ! 64rIr=ct|tr|St|tr0|rtdtdkStdtdkSt dt |z)NrrTz,Problem has an invalid constraint of type %s) isinstancerboolr ValueErrortype) constraints rG_validate_constraintrb~sg*j) J %.8 x{* , x{* ,Gj)*+ +rIceZdZdZiZ d4 d5dZejd6dZe dZ e d7dZ e dZ e d8dZ e d9d Ze d Ze d:d Zejd;ddZejd;ddZejd?d@dZejd>dZejd>dZejdAdZejdZejdBdZdCdZe dDdZe dEdZe dFdZdGdZ dZ!e"dHdZ# dI dJdZ$ dK dLdZ%dMd Z& dN dOd!Z'e(dPd"Z)dPd#Z* dQ dRd$Z+dPd%Z,dPd&Z-dPd'Z.dPd(Z/dSd)Z0d7d*Z1d7d+Z2dTd,Z3dTd-Z4dTd.Z5dTd/Z6dTd0Z7dTd1Z8e8Z9dTd2Z:d>d3Z;e:ZIJ1!4J&t'8'89 _MAz%%j1[5J5JJ QC0^^_ _  &* g 6:6:26,0__d&7&78  )KsE#c|j}|j}|jg|jzD]0}t ||j }|xr|j }2||d}|S)z Aggregates and caches metrics for expression trees in self.args. So far metrics include the maximum dimensionality ('max_ndim') and whether all sub-expressions support C++ ('all_support_cpp'). )max_ndimall_support_cpp)rx _supports_cpprgrlmax _max_ndim_all_support_cpp)rFr~ cpp_supportargmetricss rG_aggregate_metricszProblem._aggregate_metricssy99((* OO$t'8'88 AC8S]]_5H%@#*>*>*@K A !* rIcF|jyt|jS)zpfloat : The value from the last time the problem was solved (or None if not solved). N)rnrrEs rGvaluez Problem.values ;;  , ,rIc|jS)zstr : The status from the last time the problem was solved; one of optimal, infeasible, or unbounded (with or without suffix inaccurate). )rorEs rGr0zProblem.statuss ||rIc|jS)zKSolution : The solution from the last time the problem was solved. )rprEs rGsolutionzProblem.solutions~~rIc|jS)zMinimize or Maximize : The problem's objective. Note that the objective cannot be reassigned after creation, and modifying the objective after creation will result in undefined behavior. )rgrEs rGryzProblem.objectivesrIc |jddS)zA shallow copy of the problem's constraints. Note that constraints cannot be reassigned, appended to, or otherwise modified after creation, except through parameters. N)rlrEs rGrzzProblem.constraintss  ##rIcf|jDcic]}|j|c}Scc}w)z7 Expose all parameters as a dictionary ) parametersname)rFrs rG param_dictzProblem.param_dicts- AE@QR* !:-RRR.cf|jDcic]}|j|c}Scc}w)z6 Expose all variables as a dictionary ) variablesr)rFvariables rGvar_dictzProblem.var_dicts* ;?..:JKh )KKKrc\tfd|j|jgzDS)aDoes the problem satisfy DCP rules? Arguments --------- dpp : bool, optional If True, enforce the disciplined parametrized programming (DPP) ruleset; only relevant when the problem involves Parameters. DPP is a mild restriction of DCP. When a problem involving Parameters is DPP, subsequent solves can be much faster than the first one. For more information, consult the documentation at https://www.cvxpy.org/tutorial/advanced/index.html#disciplined-parametrized-programming Returns ------- bool True if the Expression is DCP, False otherwise. c3@K|]}|jywr?)is_dcp.0exprdpps rG z!Problem.is_dcp..!!L#$++c LallrzryrFrs `rGrzProblem.is_dcp 5(L'+'7'74>>:J'JLL LrIcjtd|j|jjgzDS)zZ Returns the maximum number of dimensions of any argument in the problem. c3<K|]}|jywr?)rrrs rGrz$Problem._max_ndim..)sY4>>#Y)rrzryrrEs rGrzProblem._max_ndim$s- Y0@0@DNNDWDWCX0XYYYrIcjtd|j|jjgzDS)zW Returns True if all the arguments in the problem support cpp backend. c3<K|]}|jywr?)rrs rGrz(Problem._supports_cpp..0s`t4((*`r)rrzryrrEs rGrzProblem._supports_cpp+s- `t7G7G4>>K^K^J_7_```rIc\tfd|j|jgzDS)aDoes the problem satisfy DGP rules? Arguments --------- dpp : bool, optional If True, enforce the disciplined parametrized programming (DPP) ruleset; only relevant when the problem involves Parameters. DPP is a mild restriction of DGP. When a problem involving Parameters is DPP, subsequent solves can be much faster than the first one. For more information, consult the documentation at https://www.cvxpy.org/tutorial/advanced/index.html#disciplined-parametrized-programming Returns ------- bool True if the Expression is DGP, False otherwise. c3@K|]}|jywr?)is_dgprs rGrz!Problem.is_dgp..Frrrrs `rGrzProblem.is_dgp2rrIcVtd|j|jgzDS)z1Does the problem satisfy the DQCP rules? c3<K|]}|jywr?)is_dqcprs rGrz"Problem.is_dqcp..MsJ!$,,.JrrrEs rGrzProblem.is_dqcpIs4J%)%5%58H%HJJ JrIc|jdk(r|jdS|jdk(r|jdStd|)a>Does the problem satisfy DPP rules? DPP is a mild restriction of DGP. When a problem involving Parameters is DPP, subsequent solves can be much faster than the first one. For more information, consult the documentation at https://www.cvxpy.org/tutorial/advanced/index.html#disciplined-parametrized-programming Arguments --------- context : str Whether to check DPP-compliance for DCP or DGP; ``context`` should be either ``'dcp'`` or ``'dgp'``. Calling ``problem.is_dpp('dcp')`` is equivalent to ``problem.is_dcp(dpp=True)``, and `problem.is_dpp('dgp')`` is equivalent to `problem.is_dgp(dpp=True)`. Returns ------- bool Whether the problem satisfies the DPP rules. dcpT)rdgpzUnsupported context )lowerrrr_)rFcontexts rGis_dppzProblem.is_dppPsP0 ==?e #;;4;( ( ]]_ %;;4;( (3W= =rIcp|jD]8}t|ttfr|jdj r8y|j D]$}|js|js$y|jxr'|jjdjS)z(Is problem a quadratic program? rF) rzr]rrrwis_pwlris_psdis_nsdrryis_qpwa)rFr{vars rGis_qpz Problem.is_qpos!! Aq8T"23qvvay7G7G7I >># Czz|szz|  B$.."5"5a"8"@"@"BCrIcBtd|jDS)Nc3\K|]$}|jdxs|jd&yw)booleanintegerN) attributesrr7s rGrz+Problem.is_mixed_integer..}s2.<< *Eall9.EE.s*,)anyrrEs rGis_mixed_integerzProblem.is_mixed_integer{s#. NN,.. .rIc|jj}|jD]}||jz }t|S)zAccessor method for variables. Returns ------- list of :class:`~cvxpy.expressions.variable.Variable` A list of the variables in the problem. )ryrrzr-)rFvars_constrs rGrzProblem.variablessI((*&& (F V%%' 'E (5!!rIc|jj}|jD]}||jz }t|S)zAccessor method for parameters. Returns ------- list of :class:`~cvxpy.expressions.constants.parameter.Parameter` A list of the parameters in the problem. )ryrrzr-)rFparamsrs rGrzProblem.parameterssI**,&& *F f'') )F *6""rIci}|jj}|jD]}||jz }|Dcic]}t||}}t |j Scc}w)zAccessor method for constants. Returns ------- list of :class:`~cvxpy.expressions.constants.constant.Constant` A list of the constants in the problem. )ry constantsrzidlistvalues)rF const_dict constants_rconstants rGrzProblem.constantss| ^^--/ && -F &**, ,J ->HHblH,H HJ%%'((IsA3c|jj}|jD]}||jz }t|S)zAccessor method for atoms. Returns ------- list of :class:`~cvxpy.atoms.Atom` A list of the atom types in the problem; note that this list contains classes, not instances. )ryatomsrzr-)rFrrs rGrz Problem.atomssF$$&&& $F V\\^ #E $5!!rIcR|jt||_|jS)z]:class:`~cvxpy.problems.problem.SizeMetrics` : Information about the problem's size. )rs SizeMetricsrEs rG size_metricszProblem.size_metricss)    %!,T!2D !!!rIc|jS)z[:class:`~cvxpy.problems.problem.SolverStats` : Information returned by the solver. )rtrEs rG solver_statszProblem.solver_statss!!!rIc|jS)zwfloat : The number of seconds it took to compile the problem the last time it was compiled. )rurEs rGcompilation_timezProblem.compilation_times %%%rIcvd}t|ts t||s td|D]} t|tr|}||g|d|i|}njt|trOt |dk(rA|\}} t|trt| t s t|||g|d|i| |}n t|tjjd||cStjd|#tj$r,} tjjd| Yd} ~ d} ~ wwxYw) a`Solve a problem using multiple solvers. Arguments --------- solvers : list of (str, dict) tuples or strings. The solvers to use. For example, ['SCS', ('OSQP', {'max_iter':10000})] kwargs : keywords, optional Additional solver specific arguments. Returns ------- solution : Solution The solution of the first solver that succeeds. Raises ------ SolverError If all solvers fail to find a solution. ValueError If the input solvers format is incorrect. zCSolver path entry must be list of str or tuple[str, dict[str, Any]]z-Solver path must contain at least one solver.rNzSolver %s succeedszSolver %s failed: %sNzAll solvers failed: ) r]rr_strtuplelendictsLOGGERinfor SolverError) rF solve_funcsolversrwkwargsENTRY_ERROR_MSGrN solver_namer solver_kwargses rG_solve_solver_pathzProblem._solve_solver_pathsO0_'4(_- -LM M FF Ffc*"(K)$TTkTVTH.3v;!3C5;2 ])+s;:m]aCb",_"==#- $X#'$X0;$X?L$XPV$X%_55 2K@ F""6wi @AA$$ F 4k1EE FsB,C99D8 !D33D8c|jdd}|tj|}ntj}|jdd}|3|j dd}| t d|j ||||S||g|i|S)aCompiles and solves the problem using the specified method. Populates the :code:`status` and :code:`value` attributes on the problem object as a side-effect. Arguments --------- solver : str, optional The solver to use. For example, 'CLARABEL', 'SCS', or 'OSQP'. solver_path : list of (str, dict) tuples or strings, optional The solvers to use with optional arguments. The function tries the solvers in the given order and returns the first solver's solution that succeeds. For example, ['SCS', ('OSQP', {'max_iter':10000})] verbose : bool, optional Overrides the default of hiding solver output, and prints logging information describing CVXPY's compilation process. gp : bool, optional If True, parses the problem as a disciplined geometric program instead of a disciplined convex program. qcp : bool, optional If True, parses the problem as a disciplined quasiconvex program instead of a disciplined convex program. requires_grad : bool, optional Makes it possible to compute gradients of a solution with respect to Parameters by calling ``problem.backward()`` after solving, or to compute perturbations to the variables given perturbations to Parameters by calling ``problem.derivative()``. Gradients are only supported for DCP and DGP problems, not quasiconvex problems. When computing gradients (i.e., when this argument is True), the problem must satisfy the DPP rules. enforce_dpp : bool, optional When True, a DPPError will be thrown when trying to solve a non-DPP problem (instead of just a warning). Only relevant for problems involving Parameters. Defaults to False. ignore_dpp : bool, optional When True, DPP problems will be treated as non-DPP, which may speed up compilation. Defaults to False. method : function, optional A custom solve method to use. kwargs : keywords, optional Additional solver specific arguments. See Notes below. Notes ------ CVXPY interfaces with a wide range of solvers; the algorithms used by these solvers have arguments relating to stopping criteria, and strategies to improve solution quality. There is no one choice of arguments which is perfect for every problem. If you are not getting satisfactory results from a solver, you can try changing its arguments. The exact way this is done depends on the specific solver. Here are some examples: :: prob.solve(solver='ECOS', abstol=1e-6) prob.solve(solver='OSQP', max_iter=10000). mydict = {"MSK_DPAR_INTPNT_CO_TOL_NEAR_REL": 10} prob.solve(solver='MOSEK', mosek_params=mydict). You should refer to CVXPY's web documentation for details on how to pass solver solver arguments, available at https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options Returns ------- float The optimal value for the problem, or a string indicating why the problem could not be solved. Raises ------ cvxpy.error.DCPError Raised if the problem is not DCP and `gp` is False. cvxpy.error.DGPError Raised if the problem is not DGP and `gp` is True. cvxpy.error.DPPError Raised if DPP settings are invalid. cvxpy.error.SolverError Raised if no suitable solver exists among the installed solvers, or if an unanticipated error is encountered. methodN solver_pathrNzBCannot specify both 'solver' and 'solver_path'. Please choose one.)poprdREGISTERED_SOLVE_METHODS_solvegetr_r)rFrwr func_namerrrNs rGsolvez Problem.solveshJJx.   99)DJ Jjj5  "ZZ$/F! XZZ**:k4P P$0000rIc"||j|<y)a<Adds a solve method to the Problem class. Arguments --------- name : str The keyword for the method. func : function The function that executes the solve method. This function must take as its first argument the problem instance to solve. N)r)clsrfuncs rGregister_solvezProblem.register_solvecs.2$$T*rIc|r |r tdtj}t|tr|j }|d} n|j dd} |j j|||| } | |j jk7r[|j j|j||||||} | |j _| |j _ i|_ n|j j} |rtt|j j:|rt j"j%d|r|j jj t&} | j(j*} |j-D].}|| vst/j0|j2| |_0| j4j7|j j\}}|j j8|gz}tj|z |_|rt j"j%d|j:n|r| j<dj?}djAd | j<D}t j"j%d |t j"j%d || j7||\}}t|tBxr1t jD|vxrtGd | j<D }tj|z |_|r*t j"j%d|j:|rg|r/|j-rt j"j%d |t jD|j _|dd|j _|| |fS)aReturns the problem data used in the call to the solver. When a problem is solved, CVXPY creates a chain of reductions enclosed in a :class:`~cvxpy.reductions.solvers.solving_chain.SolvingChain`, and compiles it to some low-level representation that is compatible with the targeted solver. This method returns that low-level representation. For some solving chains, this low-level representation is a dictionary that contains exactly those arguments that were supplied to the solver; however, for other solving chains, the data is an intermediate representation that is compiled even further by the solver interfaces. A solution to the equivalent low-level problem can be obtained via the data by invoking the `solve_via_data` method of the returned solving chain, a thin wrapper around the code external to CVXPY that further processes and solves the problem. Invoke the unpack_results method to recover a solution to the original problem. For example: :: objective = ... constraints = ... problem = cp.Problem(objective, constraints) data, chain, inverse_data = problem.get_problem_data(cp.SCS) # calls SCS using `data` soln = chain.solve_via_data(problem, data) # unpacks the solution returned by SCS into `problem` problem.unpack_results(soln, chain, inverse_data) Alternatively, the `data` dictionary returned by this method contains enough information to bypass CVXPY and call the solver directly. For example: :: problem = cp.Problem(objective, constraints) data, _, _ = problem.get_problem_data(cp.SCS) import scs probdata = { 'A': data['A'], 'b': data['b'], 'c': data['c'], } cone_dims = data['dims'] cones = { "f": cone_dims.zero, "l": cone_dims.nonneg, "q": cone_dims.soc, "ep": cone_dims.exp, "s": cone_dims.psd, } soln = scs.solve(data, cones) The structure of the data dict that CVXPY returns depends on the solver. For details, consult the solver interfaces in `cvxpy/reductions/solvers`. Arguments --------- solver : str The solver the problem data is for. gp : bool, optional If True, then parses the problem as a disciplined geometric program instead of a disciplined convex program. enforce_dpp : bool, optional When True, a DPPError will be thrown when trying to parse a non-DPP problem (instead of just a warning). Defaults to False. ignore_dpp : bool, optional When True, DPP problems will be treated as non-DPP, which may speed up compilation. Defaults to False. canon_backend : str, optional 'CPP' (default) | 'SCIPY' Specifies which backend to use for canonicalization, which can affect compilation time. Defaults to None, i.e., selecting the default backend. verbose : bool, optional If True, print verbose output related to problem compilation. solver_opts : dict, optional A dict of options that will be passed to the specific solver. In general, these options will override any default settings imposed by cvxpy. Returns ------- dict or object lowest level representation of problem SolvingChain The solving chain that created the data. list The inverse data generated by the chain. Raises ------ cvxpy.error.DPPError Raised if DPP settings are invalid. z4Cannot set enforce_dpp = True and ignore_dpp = True.NrQ)rNrO enforce_dpprP canon_backend solver_optszIUsing cached ASA map, for faster compilation (bypassing reduction chain).z1Finished problem compilation (took %.3e seconds).z -> c3FK|]}t|jywr?)r`rY)rrs rGrz+Problem.get_problem_data.. s!2L-.Q((2Ls!z%Compiling problem (target solver=%s).zReduction chain: %sc3<K|]}t|tywr?)r]r)r reductions rGrz+Problem.get_problem_data..)s!G )'y*=Grz[(Subsequent compilations of this problem, using the same arguments, should take less time.))$rtimer]rupperrrqrRrArK_construct_chainrBrrprint_COMPILATION_STRrCrrrr canon_methods _parametersrnplogrrNapplyrDru reductionsrjoinr PARAM_PROBr)rFrNrOrrPverboserrstartrQrArBdgp2dcpold_params_to_new_paramsparamdatasolver_inverse_datarDrreduction_chain_str safe_to_caches rGget_problem_datazProblem.get_problem_dataqsgd :QR R  fc "\\^F  L&??>4@Lkk""62z<H $++// ! KK " " $ 11"'%+' 2)M "DKKO(5DKK %!#D  KK55M  " # ;; ! ! - 78++3377@ ,3+@+@+L+L(!__.)E 88@B!KKA)07=) )6(<(<(B(B &&)( %D%;;337J6KKL%)YY[5%8D " /040F0FH+66r:??A &,kk2L2?2J2J2L'L# @+O 35HI!.!4!4T7!C D,4&GLLD(GG-:-E-EGGG  &*YY[5%8D " /040F0FHt0HHMMEF*.all); &,8+< (]L00rIcggd}t|tr|j|St|tr|j }|k|t j vrtjd|z|t jvr|dxx|gz cc<|t jvr|dxx|gz cc<nt j Dcgc]}|t jvr|c}|d<g|d<t j D]=}|t jvs|tjk7s*|dj|?|r6|-|t jvrtjd|zdz|g|d<|jrt jtjgk(r*|tjk7rd}tj||dDcgc]!}t j |j"r|#c}|d<|dDcgc]!}t j$|j"r|#c}|d<|ds&|ds!tjd|d|dzz|Scc}wcc}wcc}w) aX Find candidate solvers for the current problem. If solver is not None, it checks if the specified solver is compatible with the problem passed. Arguments --------- solver : Union[string, Solver, None] The name of the solver with which to solve the problem or an instance of a custom solver. If no solver is supplied (i.e., if solver is None), then the targeted solver may be any of those that are installed. If the problem is variable-free, then this parameter is ignored. gp : bool If True, the problem is parsed as a Disciplined Geometric Program instead of as a Disciplined Convex Program. Returns ------- dict A dictionary of compatible solvers divided in `qp_solvers` and `conic_solvers`. Raises ------ cvxpy.error.SolverError Raised if the problem is not DCP and `gp` is False. cvxpy.error.DGPError Raised if the problem is not DGP and `gp` is True.  qp_solvers conic_solverszThe solver %s is not installed.rrzMWhen `gp=True`, `solver` must be a conic solver (received '%s'); try calling z$ `solve()` with `solver=cvxpy.ECOS`.a You need a mixed-integer solver for this model. Refer to the documentation https://www.cvxpy.org/tutorial/advanced/index.html#mixed-integer-programs for discussion on this topic. Quick fix 1: if you install the python package CVXOPT (pip install cvxopt), then CVXPY can use the open-source mixed-integer linear programming solver `GLPK`. If your problem is nonlinear then you can install SCIP (pip install pyscipopt). Quick fix 2: you can explicitly specify solver='ECOS_BB'. This may result in incorrect solutions and is not recommended. zRProblem is mixed-integer, but candidate QP/Conic solvers (%s) are not MIP-capable.)r]r'_add_custom_solver_candidatesrrslv_defINSTALLED_SOLVERSr r CONIC_SOLVERS QP_SOLVERSrECOS_BBappendrINSTALLED_MI_SOLVERSr% MIP_CAPABLEr$)rFrNrO candidatesrslvmsgs rG_find_candidate_solverszProblem._find_candidate_solvers<sB%'')+ ff %55f= = fc "\\^F  W666''(IF(RSS...?+x7++++<(VH4(3:3L3L(Da+,0B0B+B)*(DJ| $*,J '00 <'///C1994D/66s; < !fG4I4I&I''24:;89 +- <(  "++ {:v?R '',,&l3(9((+77(9J| $&o6+<++A.::+,>,@+A <(M;79F !3!3!56/23>2<5B3>8> @ @rIct|ddkDrt|dd|d<t|ddkDrt|dd|d<yy)a Sorts candidate solvers lists according to slv_def.CONIC_SOLVERS/QP_SOLVERS Arguments --------- candidates : dict Dictionary of candidate solvers divided in qp_solvers and conic_solvers Returns ------- None rrTc@tjj|Sr?)r!r#indexrs rGz1Problem._sort_candidate_solvers..s8M8M8S8STU8VrIrUrc@tjj|Sr?)r!r$r6r7s rGr8z1Problem._sort_candidate_solvers.. sW5G5G5M5Ma5PrIN)rsorted)rs rGr2zProblem._sort_candidate_solverssc w' (1 ,'-(.V(GO $ w|$ % )$* %+P%GL ! *rIc<d|_d|_d|_d|_yr?) _cache_key_solving_chain _param_prog _inverse_datarEs rG_invalidate_cachezProblem._invalidate_caches!"!rIc  |rtt|jD]4} | jt j d| j z|rtd|jD} td|jD}td|jD}tjjd| ||g}|jr|jd|jr|jd|j!r|jdtjjd d j#||d k(rtjjd tjjd tjjd| tj$n| |r|rdnd}|r t'd|j)|st j*d|0|tj,tj.fvrt'd|ztj.t0j2vr t5dtj.}n|r |r t'd|ru|jsd|j!st j6d|rTtjjd|r3tt8tt:dtt:dt=j>g}tAj@}tC|jDtFk(rDtIg|z}| jKd| jKd}}||dz| d<||dz| d<tM||}tOjP|jSf||d| }|jU|jW||jS|jY|||| || | \}}}|rJttZtjjd|j\dj tAj@}| j_d|}|r|sttZ|r|r~tt8tt:d|jrtt:d|rtt:dt|j\dja||jc||||| }tAj@}||z |_2|jg||||rtthtjjd |jj|j |jntljn}tjjd!|tjjd"|jptjjd#|jd|jS)$arSolves a DCP compliant optimization problem. Saves the values of primal and dual variables in the variable and constraint objects, respectively. Arguments --------- solver : str, optional The solver to use. Defaults to ECOS. warm_start : bool, optional Should the previous solver result be used to warm start? verbose : bool, optional Overrides the default of hiding solver output. bibtex : bool, optional Prints bibtex citations for CVXPY, the grammar, and the solver. gp : bool, optional If True, parses the problem as a disciplined geometric program. qcp : bool, optional If True, parses the problem as a disciplined quasiconvex program. requires_grad : bool, optional Makes it possible to compute gradients with respect to parameters by calling `backward()` after solving, or to compute perturbations to the variables by calling `derivative()`. When True, the solver must be SCS, and dqcp must be False. A DPPError is thrown when problem is not DPP. enforce_dpp : bool, optional When True, a DPPError will be thrown when trying to solve a non-DPP problem (instead of just a warning). Defaults to False. ignore_dpp : bool, optional When True, DPP problems will be treated as non-DPP, which may speed up compilation. Defaults to False. canon_backend : str, optional 'CPP' (default) | 'SCIPY' Specifies which backend to use for canonicalization, which can affect compilation time. Defaults to None, i.e., selecting the default backend. kwargs : dict, optional A dict of options that will be passed to the specific solver. In general, these options will override any default settings imposed by cvxpy. Returns ------- float The optimal value for the problem, or a string indicating why the problem could not be solved. zA Parameter (whose name is '%s') does not have a value associated with it; all Parameter objects must have values before solving a problem.c3K|]G}|jrt|jdntj|jIyw)rN) sparse_idxrr prodshapers rGrz!Problem._solve..ZsBJ3478llc!,,q/2 ggagg./JsA Ac3ZK|]#}tj|j%ywr?r rDrE)rr{s rGrz!Problem._solve..\sKQ 0K)+c3ZK|]#}tj|j%ywr?rG)rps rGrz!Problem._solve..]sKArwwqww/KrHzAYour problem has %d variables, %d constraints, and %d parameters.DCPDGPDQCPz/It is compliant with the following grammars: %s, rzg(If you need to solve this problem multiple times, but with different data, consider using parameters.)zdCVXPY will first compile your problem; then, it will invoke a numerical solver to obtain a solution.z>Your problem is compiled with the %s canonicalization backend.rrz*Cannot compute gradients of DQCP problems.zEProblem is not DPP (when requires_grad is True, problem must be DPP).zKWhen requires_grad is True, the only supported solver is SCS (received %s).zThe Python package diffcp must be installed to differentiate through problems. Please follow the installation instructions at https://github.com/cvxgrp/diffcpz*At most one of `gp` and `qcp` can be True.zThe problem is not DQCP.zOReducing DQCP problem to a one-parameter family of DCP problems, for bisection.r6lowhighr)problemr)rNrz)Invoking solver %s to obtain a solution.solver_verbosezProblem status: %szOptimal value: %.3ezCompilation took %.3e secondszJ{{}!!%({{}!!%(||~!!&) HHMMEIIj) +q  KL HHMMF G HHMMT/ 7 / " v -  -( ){{}mE*+mE*+ -**2.33D9 : // $ NF<iik; Hm\B  'N HHMM. < $ 6$**BFFC HHMM/ 5 HHMM94;Q;Q R HHMM#$($4$4 6zzrIctj|jvr td|jtj vrt jd|jtj}|d}tj|dj}i}|jj}|jD]}|j-tj|j||j <n= 0]) p.value = 3.0 problem.solve(requires_grad=True, eps=1e-10) # backward() populates the gradient attribute of the parameters problem.backward() # Because x* = 2 * p, dx*/dp = 2 np.testing.assert_allclose(p.gradient, 2.0) In the above example, the gradient could easily be computed by hand. The ``backward()`` is useful because for almost all problems, the gradient cannot be computed analytically. This method can be used to differentiate through any DCP or DGP problem, as long as the problem is DPP compliant (i.e., ``problem.is_dcp(dpp=True)`` or ``problem.is_dgp(dpp=True)`` evaluates to ``True``). This method uses the chain rule to evaluate the gradients of a scalar-valued function of the Variables with respect to the Parameters. For example, let x be a variable and p a Parameter; x and p might be scalars, vectors, or matrices. Let f be a scalar-valued function, with z = f(x). Then this method computes dz/dp = (dz/dx) (dx/p). dz/dx is chosen as the all-ones vector by default, corresponding to choosing f to be the sum function. You can specify a custom value for dz/dx by setting the ``gradient`` attribute on your variables. For example, :: import cvxpy as cp import numpy as np b = cp.Parameter() x = cp.Variable() quadratic = cp.square(x - 2 * b) problem = cp.Problem(cp.Minimize(quadratic), [x >= 0]) b.value = 3. problem.solve(requires_grad=True, eps=1e-10) x.gradient = 4. problem.backward() # dz/dp = dz/dx dx/dp = 4. * 2. == 8. np.testing.assert_allclose(b.gradient, 8.) The ``gradient`` attribute on a variable can also be interpreted as a perturbation to its optimal value. Raises ------ ValueError if solve was not called with ``requires_grad=True`` SolverError if the problem is infeasible or unbounded zIbackward can only be called after calling solve with `requires_grad=True`zBackpropagating through infeasible/unbounded problems is not yet supported. Please file an issue on Github if you need this feature.DTrNdtypeDT_TIMEg?)rrXrrr_r0SOLUTION_PRESENTr rr zerosrErqrOrgradientonesrasarrayfloat64rrC split_adjointrapply_param_jacrrBrrr r )rFbackward_cachervr|del_varsrOrdxrdAdbdcrsdparamsrrrgrad new_params rGbackwardzProblem.backwards`Z 884-- -?@ @ [[ 2 2 2##%GH H ++AHH5 D !,223 [[^^ ( 8H  ((*(?%(* 83D3D9;)E%%7% 8[[ # # 1 1( ; E5) Biik$'%Ky!++((88bS"E* 3!(!2 3kk//33G|j3|d\} } } }t5j4}|| || \}} } t5j4}||z |d <|j7||jDcgc]}|j(c}}|jD]8}||j(|_|s|xj"|j*zc_:ycc}w) aApply the derivative of the solution map to perturbations in the Parameters This method applies the derivative of the solution map to perturbations in the Parameters to obtain perturbations in the optimal values of the Variables. In other words, it tells you how the optimal values of the Variables would be changed by small changes to the Parameters. You can specify perturbations in a Parameter by setting its ``delta`` attribute (if unspecified, the perturbation defaults to 0). This method populates the ``delta`` attribute of the Variables as a side-effect. This method can only be called after calling ``solve()`` with ``requires_grad=True``. It is compatible with both DCP and DGP problems (that are also DPP-compliant). Below is a simple example: :: import cvxpy as cp import numpy as np p = cp.Parameter() x = cp.Variable() quadratic = cp.square(x - 2 * p) problem = cp.Problem(cp.Minimize(quadratic), [x >= 0]) p.value = 3.0 problem.solve(requires_grad=True, eps=1e-10) # derivative() populates the delta attribute of the variables p.delta = 1e-3 problem.derivative() # Because x* = 2 * p, dx*/dp = 2, so (dx*/dp)(p.delta) == 2e-3 np.testing.assert_allclose(x.delta, 2e-3) Raises ------ ValueError if solve was not called with ``requires_grad=True`` SolverError if the problem is infeasible or unbounded zKderivative can only be called after calling solve with `requires_grad=True`zDifferentiating through infeasible/unbounded problems is not yet supported. Please file an issue on Github if you need this feature.DNrzrwT) zero_offsetD_TIME)rrXrrr_r0r{rqrCrOrBrrrrr r|rEdeltar r rrrrparam_id_to_colapply_parametersrsplit_solution)rFrrCr param_deltasrOrrrr new_param_idr_rrrrrsr7dvarss rG derivativezProblem.derivativeYsX 884-- -?@ @ [[ 2 2 2IJ J++AHH5[[++ 3  [[^^  kk//33G@jj.JL**,E)L UXX&! M"#33L@D4F Ar2 bS"b>Aqiik#&;x )) t~~/0!02( 1H"8;;/HN(..0  11sM c|jD]}|jd|jD]$}|jD]}|jd&d|_d|_d|_yr?)r save_valuerzdual_variablesrnrorp)rFr7r{dvs rG_clear_solutionzProblem._clear_solutionsq! A LL  !! $A&& $ d# $ $  rIc|jtjvr|jD]*}|j |j |j ,|jD]C}|j |jvs|j|j|j E|jj|_ n|jtjvrk|jD]}|j d|jD]$}|jD]}|j d&|j|_ nt!d|z|j|_||_y)aUpdates the problem state given a Solution. Updates problem.status, problem.value and value of primal and dual variables. If solution.status is in cvxpy.settins.ERROR, this method is a no-op. Arguments _________ solution : cvxpy.Solution A Solution object. Raises ------ ValueError If the solution object has an invalid status Nz"Cannot unpack invalid solution: %s)r0rr{rr primal_varsrrz dual_varssave_dual_valueryrrn INF_OR_UNBropt_valr_rorp)rFrr7r{rrs rGr_zProblem.unpacks:" ??a00 0^^% 9 X11!$$78 9%% @448---%%h&8&8&>? @....DK __ ,^^% # T" #** ( //(BMM$'( (#**DKAHLM M !rIcD|j||}|jtjvrt j d|jtj k(rt j t|jtjvr3tjd|jjzdz|j|tj|j j"|jj|_y)aUpdates the problem state given the solver results. Updates problem.status, problem.value and value of primal and dual variables. Arguments _________ solution : object The solution returned by applying the chain to the problem and invoking the solver on the resulting data. chain : SolvingChain A solving chain that was used to solve the problem. inverse_data : list The inverse data returned by applying the chain to the problem. Raises ------ cvxpy.error.SolverError If the solver failed zSolution may be inaccurate. Try another solver, adjusting the solver settings, or solve with verbose=True for more information.zSolver '%s' failed. zDTry another solver, or solve with verbose=True for more information.N)invertr0r INACCURATErjrkINFEASIBLE_OR_UNBOUNDEDr ERRORr rrNrr_ SolverStats from_dictrpattrrt)rFrrqrDs rGrdzProblem.unpack_resultss,<<,7 ??all * MM5  ??a77 7 MM, - ??agg %##*U\\->->-@@##$ $ H(224>>3F3F).):):)<>rIcFt|jdk(rt|jSd}t|j|t|jdzg}|jddD] }|t|dzt|zgz }"dj |S)Nrz subject to rT r5)rrzrryr)rF subject_tolinesrs rG__str__zProblem.__str__s t A %t~~& &&J(#d&6&6q&9"::> ?99U# #rIc`dt|jdt|jdS)NzProblem(rN))reprryrzrEs rG__repr__zProblem.__repr__s&$($8$()9)9$:< ><  D D ..  " "  # # ))" """"" && .B``1D 2 2! $(&*I1 I1I1 I1  I1 " I1$I1X(,+0e$(eN H%) %$(,*.1@!1@1@ 1@  1@ & 1@(1@ 1@f*"""&$# %*#("'+/|||| |  |  |#|!| |)||E&N`1D$"L'>R $<:J( J ( A HI KrIrdcfeZdZUdZded<dZded<dZded<dZded <dZd ed <e d d Z y)raReports some of the miscellaneous information that is returned by the solver after solving but that is not captured directly by the Problem instance. Attributes ---------- solver_name : str The name of the solver. solve_time : double The time (in seconds) it took for the solver to solve the problem. setup_time : double The time (in seconds) it took for the solver to setup the problem. num_iters : int The number of iterations the solver had to go through to find a solution. extra_stats : object Extra statistics specific to the solver; these statistics are typically returned directly from the solver, without modification by CVXPY. This object may be a dict, or a custom Python object. rrNzOptional[float] solve_time setup_timez Optional[int] num_itersr extra_statsc |||jtj|jtj|jtj|jtj S)aWConstruct a SolverStats object from a dictionary of attributes. Parameters ---------- attr : dict A dictionary of attributes returned by the solver. solver_name : str The name of the solver. Returns ------- SolverStats A SolverStats object. )rrrr)rr SOLVE_TIME SETUP_TIME NUM_ITERS EXTRA_STATS)rrrs rGrzSolverStats.from_dictnsT  xx -xx -hhq{{+/   rI)rrrrrWr) rYrZr[r__annotations__rrrrrrrMrIrGrrRsI("&J&"&J&#I}#"&K&  rIrceZdZdZddZy)raRReports various metrics regarding the problem. Attributes ---------- num_scalar_variables : integer The number of scalar variables in the problem. num_scalar_data : integer The number of scalar constants and parameters in the problem. The number of constants used across all matrices, vectors, in the problem. Some constants are not apparent when the problem is constructed: for example, The sum_squares expression is a wrapper for a quad_over_lin expression with a constant 1 in the denominator. num_scalar_eq_constr : integer The number of scalar equality constraints in the problem. num_scalar_leq_constr : integer The number of scalar inequality constraints in the problem. max_data_dimension : integer The longest dimension of any data block constraint or parameter. max_big_small_squared : integer The maximum value of (big)(small)^2 over all data blocks of the problem, where (big) is the larger dimension and (small) is the smaller dimension for each data block. cd|_|jD]!}|xj|jz c_#d|_d|_d|_|j |jzD]}d}|xj|jz c_t|jdk(rdnt|j}t|jdk(rdnt|j}|j|kr||_t|t|dzz}|j |ks||_d|_ |jD]B}t|t t"fs|xj|j$jz c_ Dd|_|jD]G}t|t(t*t,fs|xj&|j$jz c_Iy)NrrTr)num_scalar_variablesrsizemax_data_dimensionnum_scalar_datamax_big_small_squaredrrrrErminrnum_scalar_eq_constrrzr]rrrnum_scalar_leq_constrrrr)rFrQrconstbigsmallrras rGrHzSizeMetrics.__init__s$%!$$& 2C  % % 1 % 2#$ %&"&&(););)== CEC  EJJ . 5;;'1,!#ekk2BCU[[)Q.AC 4DE&&,*-'$)#Je a$@ !)),AA-B* C %&!!-- BJ*x&67))Z__-A-AA) B &'"!-- CJ*z66&BC**joo.B.BB* CrIN)rQrdrWrX)rYrZr[rrHrMrIrGrrs 4#CrIr)dr __future__rrrj collectionsr dataclassesrtypingrrrr numpyr cvxpy.utilities utilitiesu!cvxpy.utilities.performance_utilsperformance_utilsrcvxpyr r r rcvxpy.atoms.atomr cvxpy.constraintsrrrrrcvxpy.constraints.constraintr cvxpy.errorrcvxpy.expressionsrcvxpy.expressions.variabler cvxpy.interface.matrix_utilitiesrcvxpy.problems.objectiverrcvxpy.reductionsrcvxpy.reductions.chainr cvxpy.reductions.dgp2dcp.dgp2dcprcvxpy.reductions.dqcp2dcprcvxpy.reductions.eval_paramsrcvxpy.reductions.flip_objectivercvxpy.reductions.solutionr cvxpy.reductions.solversr!r"r!3cvxpy.reductions.solvers.conic_solvers.conic_solverr# cvxpy.reductions.solvers.definesr$r%-cvxpy.reductions.solvers.qp_solvers.qp_solverr&cvxpy.reductions.solvers.solverr'&cvxpy.reductions.solvers.solving_chainr(r)cvxpy.settingsr*r+cvxpy.utilities.citationsr,cvxpy.utilities.deterministicr-r. _COL_WIDTHcenterversionrSr rar[rer=rb CanonicalrdrrrMrIrGrsZ# "!..00!!HH3 &/97((4.398.7KLB2#'35;=   N  Z !   8   %%j1 2    N  N :&'   N  N  +,   N  N $%   N  N z"#   N 44( +EakkEP. 1 1  1 f>C>CrI