fuctionally equivalent to _mm_shuffle_pd in SSE (i.e. shuffle(m, n, mask) equals _mm_shuffle_pd(m,n,mask)) Currently used in LU/arch/InverseSize4.h to

Returns sign (is positive, is negative) of the expression.

Solve the problem and return a Solution object.

Returns the result of the call to the solver. Parameters ---------- data : dict Data generated via an apply call.

Splits the solution into individual variables.

\returns the squared norm of the quaternion's coefficients * \sa QuaternionBase::norm(), MatrixBase::squaredNorm() */

Returns the type of the underlying tensor

Convert a value to a dense float64 numpy array.

Convert key to tuple if necessary.

Given a NumPy typecode, return a string describing the type. */

Free symbolic

Turns the matrix into the uncompressed mode */

Returns a coefficient matrix A that creates a symmetric matrix when multiplied with a variable vector v. That is, (A @ v).reshape((n, n))

Check if the name is a valid column name.

Pack binary data into a string */

Cast a pointer up an inheritance hierarchy */

Set the clientdata field for a type */

Return the pretty name associated with this type, that is an unmangled type name in a form presentable to the user. */

Unpack binary data from a string */

These constants are endian-agnostic

Parameters ---------- data : str String with lines separated by '\n'.

Expression : Called for matrix @ Expression.

Aggregates and caches metrics for expression trees in self.args. So far metrics include the maximum dimensionality ('max_ndim') and w

Check if all values are 0 or inf, sparse-aware (O(nnz) for sparse).

Check if any values are NaN, sparse-aware (O(nnz) for sparse).

A utility function to append constraints from lower and upper bounds. Parameters ---------- term: The term to encode in the c

Build the interleaved matrix for batch-varying constant case. For C (..., m, k) @ X (..., k, n), builds I_n ⊗ M_interleaved where: M_int

Build the interleaved matrix for batch-varying rmul case. For X (..., m, k) @ C (..., k, n), builds M_interleaved ⊗ I_m where: M_interle

Build interleaved matrix for batch-varying mul (C @ X). This handles the case where each batch element uses a DIFFERENT constant matrix:

Build the interleaved matrix for a batch-varying parametric constant (C @ X). Parametric analogue of _build_interleaved_mul: C(B,m,k) @ X(B,

Build the interleaved matrix for a batch-varying parametric constant (X @ C). Parametric analogue of _build_interleaved_rmul: X(B,m,k) @ C(B

Build interleaved matrix for batch-varying rmul case. This handles the case where each batch element uses a DIFFERENT constant matrix: X

Recursively canonicalize a constraint. The DQCP grammar has expresions of the form INCR* QCVX DCP and DECR

Check if args satisfy DPP requirements for quad_form. For DPP with parametric P (in quad_form_dpp_scope): - x must be param-free (avo

Gives the (sub/super)gradient of the atom w.r.t. a column argument. Matrix expressions are vectorized, so the gradient is a matrix.

Compose a sequence of ``{old_id: [new_id, ...]}`` mappings. Each step map comes from a reduction's ``var_id_map`` or ``param_id_map``. The r

Compute numerical Jacobian via central finite differences. Parameters ---------- eval_func : callable Function that takes a

Determine whether the constant is symmetric/Hermitian.

Fallback factor via dense pivoted LDL (Bunch-Kaufman, ``scipy.linalg.ldl``). Used when QDLDL cannot factor the matrix — either because it throws

Collect atom types needing conic canonicalization from an expression. Unlike ``_objective_cone_atoms``, this does not apply QP-path filtering.

Return all atoms of ``atom_cls`` reachable from ``expr.args``.

Flatten a dual value to 1D array for comparison. Normalizes both [t, X] format and flat array format to a consistent ordering: [t0, x0..., t1

Formats the block for block_add. Args: matrix: The matrix the block will be added to. block: The matrix/scalar to be

Get a string representing the attributes.

Check if cone dimensions contain cones unsupported by QP solvers.

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

Unified Kronecker product implementation. If const_on_left=True: computes kron(constant, variable) If const_on_left=False: c

Transform a DGP bound to log-space. For a DGP variable x = exp(t), the bound value ``b`` in the positive domain maps to ``log(b)`` in

Compute the cost (removed size + flops) and resultant indices for performing the contraction specified by ``positions``. Parameters -----

Handle p == 2 case via SOC directly (shared by exact and approx).

Utility function to check if power is 0, 1 or 2.

Reconstruct the original SOC dual from decomposed cone duals.

Reshape constant data from column format to matrix format. Dispatches to specialized functions based on whether data is parametric.

Sum a sparse array, handling keepdims which scipy doesn't support.

Create a sparse upper triangular matrix of ones. This avoids allocating a dense dim x dim matrix. Used for cumsum gradient in CVXPY's convent

2D matrix transpose (swap rows and cols). Internal helper for matrix operations like rmul. Not for ND linop transpose.

Check for unsupported DGP attributes and return supported ones. Raises ValueError if the leaf uses an attribute that DGP cannot enforce