* Return the coefficients for MUL (left multiplication): a NUM_BLOCKS * ROWS * by NUM_BLOCKS * COLS block diagonal matrix where each diagonal block i

* Return the coefficients for NEG: -I, where I is an identity of size m * n. * * Parameters: linOp with type NEG * * Returns: vector containing th

* Returns a Tensor with selector matrices * for the parameter entries. * * Parameters: PARAM Type LinOp LIN * * Returns: Tensor * */

Look up the GitHub username for a PR.

Infer the previous release branch from a tag like v1.8.0.

Infer the previous minor release tag from a tag like v1.8.0.

* Return the coefficients for PROMOTE: a column vector of size N with all * entries 1. Note this is treated as sparse for consistency of later * mul

* Return the coefficients for RESHAPE: a 1x1 matrix [1]. In Eigen, this * requires special case handling to multiply against an arbitrary m x n * ma

* Return the coefficients for RMUL (right multiplication): a ROWS * N * by COLS * N matrix given by the kronecker product between the * transpose of

Get the constraint ID of the root cone.

Returns a sparse matrix LinOp that spaces out an expression. Parameters ---------- shape : tuple (rows in matrix, columns in matr

Returns a function that takes in a tensor, modifies the shape of the tensor by extending it to total_rows, and then shifts the entrie

* Return horizontally stacked identity matrices. * * Parameters: LinOp with type SUM * * Returns: A vector of length N where each element is a 1x1

* Return the coefficient matrix for SUM_ENTRIES. A single row vector of 1's * of size 1 by (data.rows x data.cols). * * Parameters: LinOp with type

* Return the coefficients for TRACE: A single row vector v^T \in R^(n^2) * with 1 if v_{i} corresponds to a diagonal entry (i.e. i * n + i) and 0 *

* Return the coefficients for TRANSPOSE: a ROWS*COLS by ROWS*COLS matrix * such that element ij in the vectorized matrix is mapped to ji after * mul

* Return the coefficients for UPPER_TRI: an ENTRIES by ROWS * COLS matrix * where the i, j entry in the original matrix has a 1 in row COUNT and * c

Get variable bounds for all variables. Uses the variable's get_bounds() method which handles bounds attributes, nonneg/nonpos

* Return a map from the variable ID to the coefficient matrix for the * corresponding VARIABLE linOp, which is an identity matrix of total * linop s

Given an index n, and a set of data, return the type of a variable with the same index.

* Return the coefficients for VSTACK. * * Parameters: linOp LIN with type VSTACK * Returns: vector of coefficient matrices for each argument. */

Reduces the atom to an affine expression and list of constraints. Parameters ---------- arg_objs : list LinExpr f

Sum the linear expression's entries. Parameters ---------- arg_objs : list LinExpr for each argument.

Finds the path by contracting the best pair until the input list is exhausted. The best pair is found by minimizing the tuple ``(-prod(in

Handle user-specified solver options. Parameters ---------- verbose : bool Enable verbose output solver_o

\internal Frees memory allocated with handmade_aligned_malloc */

\internal * \brief Reallocates aligned memory. * Since we know that our handmade version is based on std::malloc * we can use std::realloc to im

Logical biconditional: x <=> y. Returns 1 if and only if x and y have the same value. Equivalent to ``Not(Xor(x, y))``. Parameters -

Logical implication: x => y. Returns 1 unless x = 1 and y = 0. Equivalent to ``Or(Not(x), y)``. Parameters ---------- x : Expressio

Imports the solver.

Imports the solver (updates the set of supported constraints, if applicable).

Index into bounds. Parameters ---------- lb, ub : np.ndarray Bounds to index. key : index Index/slice to apply.

\brief Reports whether previous computation was successful. * * \returns \c Success if computation was successful, * \c Num

\brief Reports whether previous computation was successful. * * \returns \c Success if computation was successful, \c NoConvergence otherw

\returns NumericalIssue if the input contains INF or NaN values or overflow occurred. Returns Success otherwise. */

\returns the inner size. * * \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension * wit

List the installed solvers.

Return a compact key for a local structural signature.

\returns the inverse of the matrix of which *this is the LU decomposition. * * \warning The matrix being decomposed here is assumed to be

Returns a solution to the original problem given the inverse_data. Parameters ---------- solution : Solution A so

Reconstruct solution with original SOC dual variables.

\returns \c true if \c *this is approximately equal to \a other, within the precision * determined by \a prec. * * \sa MatrixBase::isAppro

Is the atom convex?

Multiplication is convex (affine) in its arguments only if one of the arguments is constant.

Division is convex (affine) in its arguments only if the denominator is constant.

Is the atom convex?

Is the atom convex?

Is the atom log-log convex?

Is the atom log-log convex?

Is the Leaf complex valued?

Is the Leaf complex valued?

Is the Leaf complex valued?

An SOC constraint is DCP if each of its arguments is affine.

A FiniteSet constraint is DCP if the constrained expression is affine.

Checks whether the constraint is DCP. Returns ------- bool True if the constraint is DCP, False otherwise.

A zero constraint is DCP if its argument is affine.

An equality constraint is DCP if its argument is affine.

Check DCP compliance, including parameter-affine bounds.

Is the composition non-increasing in argument idx?

Checks whether the constraint is DGP. Returns ------- bool True if the constraint is DGP, False otherwise.