Returns all the variables present in the arguments.

The python cached type query */

global space

String to recreate the variable.

Returns True if all sub-expressions support C++, False otherwise.

Apply ND Kronecker structure I_n ⊗ C ⊗ I_batch for mul (C @ X). For ND matmul C @ X where C is 2D (m, k) and X has shape (..., k, n): ve

Apply ND Kronecker structure for rmul: C.T tensor I_{batch*m}. For ND rmul X @ C where C is 2D (k, n) and X has shape (..., m, k): vec(X

Apply the full reduction chain to get a ParamConeProg.

Canonicalize arguments of an expression. Like Canonicalization.canonicalize_tree, but preserves signs.

Compute the attributes of the constant related to complex/real, sign.

The size of each second-order cone (1 + dimension of X).

The dimension of each PSD cone (the matrix side length n).

Returns constraints describing the domain of the atom.

Implements the dual cone of the exponential cone See Pg 85 of the MOSEK modelling cookbook for more information

Return a copy of an empty int64 array.

Generator yielding expanded slices for parametric ND mul (C @ X). For a stacked parameter matrix of shape (param_size * m, k), extracts each

Generator yielding expanded slices for parametric ND rmul. For a stacked parameter matrix of shape (param_size * k, n), extracts each (k

Computes the number of FLOPS in the contraction. Parameters ---------- idx_contraction : iterable The indices involved in th

Apply Kronecker product kron(A, I_reps) to a CooTensor. For a tensor with shape (m, k), this produces a tensor with shape (m*reps, k*reps)

Build the Kronecker structure for ND mul (C @ X): I_n ⊗ C ⊗ I_B. This is the key operation for computing C @ X where C is a 2D constant (m,

Build the Kronecker structure for ND rmul: C.T tensor I_{B*m}. This is the key operation for computing X @ C where C is a 2D constant (k, n)

Returns the maximum number of dimensions of any argument in the problem.

Helper for b**x where b is a positive constant and x is a CVXPY expression. Validates that base is constant and positive, then returns exp(x * lo

Convert constraints and cost to solver-specific format

Returns True if all the arguments in the problem support cpp backend.

Check that the value satisfies the leaf's symbolic attributes. Parameters ---------- val : numeric type The value

Bounds for elementwise absolute value: |x|. Parameters ---------- lb, ub : np.ndarray Bounds for the expression. Returns

Apply SOCDim3 decomposition to all SOC constraints.

Apply 'func' across all variables and parameter slices. For the stacked-slices backend, we must pass an additional parameter 'p'

Apply 'func' across all variables and parameter slices. func signature: func(compact: CooTensor, p: int) -> CooTensor

Returns a coefficient matrix that maps a vector of batch_size * tri entries (F-order layout of (batch_size, tri)) to batch_size * n*n entries

* Return the array of column-to-supernode mapping */

Compresses A and b by eliminating redundant rows. Identifies rows that are multiples of another row. Reduces A and b to C = PA, d = Pb, where

Equivalent to `cp.conj(self)`.

\brief Complex conjugate of the Householder sequence. */

Accessor method for constants. Returns ------- list of :class:`~cvxpy.expressions.constants.constant.Constant` A

Reshape the tensor (Fortran order, column-major). For each entry at (row, col), compute linear index = col * m + row, then new_row = lin

Create new TensorView with same shape information as self, but new data.

Compute a matrix decomposition. Compute scale, M1, M2 such that P = scale * (dot(M1, M1.T) - dot(M2, M2.T)). Uses LDL decomposition for

\returns a vector expression of the main diagonal */

Evaluate the constraint Jacobian and return its nonzero values. The values correspond to the sparsity pattern from get_jacobian_sparsity_coo(

A random risk-parity portfolio optimization problem.

Coalesces bool, int indices for variables. The indexing scheme assumes that the variables will be coalesced into a single one-dimensional

Extract PR numbers from git log output. Matches the (#NNNN) pattern at the end of a line, which is the convention for merge and squash commit

Flatten into 2D scipy sparse matrix in order-order and transpose. Parameters ---------- num_param_slices: Number of

Returns the matrix in the appropriate form for SWIG wrapper

Return a valid fractional weight tuple (and its dyadic completion) to represent the weights given by ``a``. When the input tuple con

Generate input based on type string.

* Returns a map from CONSTANT_ID to the data matrix of the corresponding * CONSTANT type LinOp. The coefficient matrix is the data matrix reshaped *

Returns tensor of constant node as a column vector.

Get a list of the variables in the operator and their shapes. Parameters ---------- operator : LinOp The operator to extract the

Map the name of a function as given by the linOp to the implementation. Parameters ---------- func_name: The name of

Wraps get_matrix_from_tensor in canonInterface. Parameters ---------- param_vec: flattened parameter vector w