Return the sparsity pattern (row, col) of the constraint Jacobian. Does not evaluate the Jacobian; only returns structural nonzero indices.

* LinOP -> Matrix FUNCTIONS *****************************/ * Return the coefficients for KRON_R. * * Parameters: linOp LIN with type KRON_R * Retu

* Returns an iterator to the node that stores the information * of the given virtual pointer from the given pointer map structure. * If pointer

* Computes a vector of coefficient matrices for the linOp LIN based on the * type of linOp. * * Note: This function assumes LIN has been initialize

Returns tensor of a parameter node, i.e., eye(n) across axes 0 and 2, where n is the size of the parameter.

Return the sparsity pattern (row, col) of the lower-triangular Lagrangian Hessian. Does not evaluate the Hessian; only returns structural non

Return the number of nonzeros in row.

Returns the cvxcore type corresponding to the type of linPy.

Organize the constraints into a dictionary keyed by constraint names. Parameters --------- constraints : list of constraints Returns

Handle user-specified solver options. Options that have to be applied before the optimization are applied to the task here.

\internal Like malloc, but the returned pointer is guaranteed to be 16-byte aligned. * Fast, but wastes 16 additional bytes of memory. Does not thro

Canonicalize functions that take a Hermitian matrix.

Set CPLEX verbosity level (either on or off).

Create a tensor with a problem data entry for each parameter, as a vector with entries equal to the parameter size.

Fill sparsity for the Lagrangian Hessian (lower triangle, COO). Must be called once before get_problem_hessian_sparsity_coo() or eval

Initialize TensorV/I/J for the given parameter.

Fill sparsity for the constraint Jacobian in COO format. Must be called once before get_jacobian_sparsity_coo() or eval_jacobian_vals().

Returns the solution to the original problem given the inverse_data.

Is the atom concave? In quad_form_dpp_scope (QP solver path), allows parametric P: - x must be param-free (avoid quadratic-in-params)

Is the atom convex? In quad_form_dpp_scope (QP solver path), allows parametric P: - x must be param-free (avoid quadratic-in-params)

Is the atom log-log concave?

Is the atom log-log concave?

Is the atom log-log convex?

Is the atom log-log convex?

Is the atom quasiconcave?

Is the atom quasiconvex?

Is the expression concave?

Is the expression convex?

A power cone constraint is DCP if each argument is affine.

A non-positive constraint is DCP if its argument is convex.

The objective must be concave.

Is the composition non-increasing in argument idx?

The objective must be log-log convex.

The objective must be log-log concave.

The objective must be linearizable convex.

Is the expression imaginary?

Is the composition non-decreasing in argument idx?

Is the expression concave after linearizing all smooth subexpressions?

Is the expression convex after linearizing all smooth subexpressions?

Is the expression positive?

Is the expression negative?

Is the expression a negative semidefinite matrix?

Is the expression a positive semidefinite matrix?

Is the expression skew-symmetric?

Check if a sparse matrix is symmetric Parameters ---------- m : array or sparse matrix A square matrix. Returns -------

Is the expression symmetric?

Check if XPRESS is installed and a usable license can be acquired. The Community license bundled with the ``xpress`` package is sufficient

Convert -inf to -kn.KN_INFINITY and inf to kn.KN_INFINITY.

Convert -inf to -kn.KN_INFINITY and inf to kn.KN_INFINITY.

Approximate ``a/sum(a)`` with tuple of fractions with denominator *exactly* ``denom``. >>> a = [.123, .345, .532] >>> make_frac(a,10) (F

Wrapper for canonicalizers whose domain is a bounded interval.

Enforce an upper bound of 0.8 on trace(N); Expect N's unspecified eigenvalue to be 0.2

Enforce a lower bound of 0.9 on trace(N); Expect N's unspecified eigenvalue to be 0.4

Convert a numpy matrix to a list.

TODO: Several loops in this file are trivially parallelizable; consider parallelizing some (parallelism will be nested inside build_matrix) multiply

Matrix multiplication.

Bounds for matrix multiplication: x @ y. When one operand is a point (lb == ub, i.e. a constant), uses the exact split formula: A_pos @ lb2 +

\returns an expression of the matrix L, internally stored as supernodes * The only operation available with this expression is the triangular so

\returns the sparse triangular factor R. It is a sparse matrix */

\returns the matrix \b Z. */

\returns the absolute value of the biggest pivot, i.e. the biggest * diagonal coefficient of U. */

Promotes shapes as necessary and returns promoted shape of product. If lh_shape is of length one, prepend a one to it. If rh_shape is of

str : The string representation of the expression.

The value of the constant as a string.