tessl/pypi-cvxpy
A domain-specific language for modeling convex optimization problems in Python.
—
Pending
atoms.mddocs/
Mathematical Functions (Atoms)
Pre-defined mathematical functions in CVXPY that preserve convexity properties and enable complex mathematical expressions. These atoms are the building blocks for optimization objectives and constraints, organized by mathematical category.
Capabilities
Linear Algebra Operations
Basic linear algebra operations for vectors and matrices.
def matmul(lh_exp, rh_exp):
"""
Matrix multiplication.
Parameters:
- lh_exp: left matrix expression
- rh_exp: right matrix expression
Returns:
- Expression: matrix product
"""
...
def multiply(lh_exp, rh_exp):
"""
Element-wise multiplication.
Parameters:
- lh_exp, rh_exp: expressions of compatible shapes
Returns:
- Expression: element-wise product
"""
...
def vdot(x, y):
"""
Vector dot product (flattens inputs first).
Parameters:
- x, y: vector expressions
Returns:
- Expression: scalar dot product
"""
...
def outer(x, y):
"""
Outer product of two vectors.
Parameters:
- x, y: vector expressions
Returns:
- Expression: matrix outer product
"""
...
def trace(expr):
"""
Trace of a square matrix.
Parameters:
- expr: square matrix expression
Returns:
- Expression: scalar trace
"""
...
def diag(expr, k=0):
"""
Extract diagonal or create diagonal matrix.
Parameters:
- expr: vector (to create diagonal matrix) or matrix (to extract diagonal)
- k: diagonal offset (0 for main diagonal)
Returns:
- Expression: diagonal vector or diagonal matrix
"""
...Array Construction and Manipulation
Functions for constructing and reshaping arrays and matrices.
def hstack(arg_list):
"""
Horizontal stack of expressions.
Parameters:
- arg_list: list of expressions with compatible shapes
Returns:
- Expression: horizontally stacked matrix
"""
...
def vstack(arg_list):
"""
Vertical stack of expressions.
Parameters:
- arg_list: list of expressions with compatible shapes
Returns:
- Expression: vertically stacked matrix
"""
...
def bmat(block_lists):
"""
Block matrix construction.
Parameters:
- block_lists: nested list of matrix expressions
Returns:
- Expression: block matrix
"""
...
def reshape(expr, shape):
"""
Reshape expression.
Parameters:
- expr: expression to reshape
- shape: new shape tuple
Returns:
- Expression: reshaped expression
"""
...
def vec(X, order='F'):
"""
Vectorize matrix (flatten to column vector).
Parameters:
- X: matrix expression
- order: 'F' (Fortran/column-major) or 'C' (C/row-major)
Returns:
- Expression: vectorized matrix
"""
...
def transpose(expr):
"""
Transpose of an expression.
Parameters:
- expr: matrix expression
Returns:
- Expression: transposed matrix
"""
...Aggregation Functions
Functions that aggregate elements across arrays.
def sum(expr, axis=None, keepdims=False):
"""
Sum along specified axis.
Parameters:
- expr: expression to sum
- axis: axis to sum along (None for all elements)
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: sum result
"""
...
def mean(expr, axis=None, keepdims=False):
"""
Mean along specified axis.
Parameters:
- expr: expression to average
- axis: axis to average along
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: mean result
"""
...
def max(expr, axis=None, keepdims=False):
"""
Maximum along specified axis.
Parameters:
- expr: expression
- axis: axis to take maximum along
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: maximum result
"""
...
def min(expr, axis=None, keepdims=False):
"""
Minimum along specified axis.
Parameters:
- expr: expression
- axis: axis to take minimum along
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: minimum result
"""
...
def sum_largest(expr, k):
"""
Sum of k largest elements.
Parameters:
- expr: expression
- k: number of largest elements to sum
Returns:
- Expression: sum of k largest elements
"""
...
def sum_smallest(expr, k):
"""
Sum of k smallest elements.
Parameters:
- expr: expression
- k: number of smallest elements to sum
Returns:
- Expression: sum of k smallest elements
"""
...Elementwise Functions
Functions applied element-wise to expressions.
def abs(expr):
"""
Absolute value (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: absolute value
"""
...
def square(expr):
"""
Square (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: squared expression
"""
...
def sqrt(expr):
"""
Square root (element-wise).
Parameters:
- expr: expression (must be non-negative)
Returns:
- Expression: square root
"""
...
def power(expr, p):
"""
Power function (element-wise).
Parameters:
- expr: expression
- p: power (scalar)
Returns:
- Expression: expr raised to power p
"""
...
def exp(expr):
"""
Exponential function (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: e^expr
"""
...
def log(expr):
"""
Natural logarithm (element-wise).
Parameters:
- expr: expression (must be positive)
Returns:
- Expression: natural log
"""
...
def log1p(expr):
"""
log(1 + expr) (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: log(1 + expr)
"""
...
def entr(expr):
"""
Entropy function: -expr * log(expr) (element-wise).
Parameters:
- expr: expression (must be non-negative)
Returns:
- Expression: entropy
"""
...
def maximum(lh_exp, rh_exp):
"""
Element-wise maximum of two expressions.
Parameters:
- lh_exp, rh_exp: expressions
Returns:
- Expression: element-wise maximum
"""
...
def minimum(lh_exp, rh_exp):
"""
Element-wise minimum of two expressions.
Parameters:
- lh_exp, rh_exp: expressions
Returns:
- Expression: element-wise minimum
"""
...Norms and Distances
Various norm functions for vectors and matrices.
def norm(expr, p=2, axis=None, keepdims=False):
"""
General norm function.
Parameters:
- expr: expression
- p: norm type (1, 2, 'inf', 'fro', 'nuc')
- axis: axis to compute norm along
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: norm value
"""
...
def norm1(expr):
"""
L1 norm (sum of absolute values).
Parameters:
- expr: expression
Returns:
- Expression: L1 norm
"""
...
def norm2(expr, axis=None):
"""
L2 norm (Euclidean norm).
Parameters:
- expr: expression
- axis: axis to compute norm along
Returns:
- Expression: L2 norm
"""
...
def norm_inf(expr):
"""
Infinity norm (maximum absolute value).
Parameters:
- expr: expression
Returns:
- Expression: infinity norm
"""
...
def pnorm(expr, p=2, axis=None, keepdims=False, max_denom=1024):
"""
P-norm with rational approximation.
Parameters:
- expr: expression
- p: norm order (>= 1)
- axis: axis to compute norm along
- keepdims: whether to keep singleton dimensions
- max_denom: maximum denominator for rational approximation
Returns:
- Expression: p-norm
"""
...
def mixed_norm(expr, p=2, q=1):
"""
Mixed norm: ||expr||_{p,q}
Parameters:
- expr: matrix expression
- p: norm for columns
- q: norm for aggregating column norms
Returns:
- Expression: mixed norm
"""
...Matrix Functions
Functions specific to matrix expressions.
def lambda_max(expr):
"""
Maximum eigenvalue of symmetric matrix.
Parameters:
- expr: symmetric matrix expression
Returns:
- Expression: maximum eigenvalue
"""
...
def lambda_min(expr):
"""
Minimum eigenvalue of symmetric matrix.
Parameters:
- expr: symmetric matrix expression
Returns:
- Expression: minimum eigenvalue
"""
...
def sigma_max(expr):
"""
Maximum singular value.
Parameters:
- expr: matrix expression
Returns:
- Expression: maximum singular value
"""
...
def log_det(expr):
"""
Log determinant of positive definite matrix.
Parameters:
- expr: positive definite matrix expression
Returns:
- Expression: log determinant
"""
...
def matrix_frac(X, P):
"""
Matrix fractional function: tr(X^T P^-1 X).
Parameters:
- X: matrix expression
- P: positive definite matrix
Returns:
- Expression: matrix fractional value
"""
...
def quad_form(x, P, assume_PSD=False):
"""
Quadratic form: x^T P x.
Parameters:
- x: vector expression
- P: matrix (should be PSD for convexity)
- assume_PSD: whether to assume P is PSD
Returns:
- Expression: quadratic form
"""
...
def quad_over_lin(X, y):
"""
Quadratic over linear: sum(X^2) / y.
Parameters:
- X: expression
- y: positive scalar expression
Returns:
- Expression: quadratic over linear
"""
...Special Functions
Advanced mathematical functions for specific applications.
def geo_mean(expr):
"""
Geometric mean.
Parameters:
- expr: expression with positive elements
Returns:
- Expression: geometric mean
"""
...
def harmonic_mean(expr):
"""
Harmonic mean.
Parameters:
- expr: expression with positive elements
Returns:
- Expression: harmonic mean
"""
...
def log_sum_exp(expr, axis=None, keepdims=False):
"""
Log-sum-exponential: log(sum(exp(expr))).
Parameters:
- expr: expression
- axis: axis to sum along
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: log-sum-exp
"""
...
def kl_div(x, y):
"""
Kullback-Leibler divergence.
Parameters:
- x, y: expressions (probability distributions)
Returns:
- Expression: KL divergence
"""
...
def rel_entr(x, y):
"""
Relative entropy: x * log(x/y).
Parameters:
- x, y: expressions
Returns:
- Expression: relative entropy
"""
...
def huber(expr, M=1):
"""
Huber function (robust loss).
Parameters:
- expr: expression
- M: threshold parameter
Returns:
- Expression: Huber loss
"""
...
def sum_squares(expr):
"""
Sum of squares.
Parameters:
- expr: expression
Returns:
- Expression: sum of squared elements
"""
...Complex Number Operations
Functions for working with complex-valued expressions.
def conj(expr):
"""
Complex conjugate (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: complex conjugate
"""
...
def imag(expr):
"""
Imaginary part (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: imaginary part
"""
...
def real(expr):
"""
Real part (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: real part
"""
...Statistical Functions
Statistical and probability functions.
def std(expr, axis=None, keepdims=False):
"""
Standard deviation along specified axis.
Parameters:
- expr: expression
- axis: axis to compute std along
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: standard deviation
"""
...
def var(expr, axis=None, keepdims=False):
"""
Variance along specified axis.
Parameters:
- expr: expression
- axis: axis to compute variance along
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: variance
"""
...
def cvar(expr, alpha):
"""
Conditional value at risk (CVaR).
Parameters:
- expr: expression representing losses
- alpha: confidence level (0 < alpha < 1)
Returns:
- Expression: CVaR value
"""
...
def ptp(expr, axis=None, keepdims=False):
"""
Peak-to-peak (range) along specified axis.
Parameters:
- expr: expression
- axis: axis to compute range along
- keepdims: whether to keep singleton dimensions
Returns:
- Expression: peak-to-peak range
"""
...Cumulative Functions
Cumulative operations on arrays.
def cumsum(expr, axis=None):
"""
Cumulative sum along specified axis.
Parameters:
- expr: expression
- axis: axis to compute cumulative sum along
Returns:
- Expression: cumulative sum
"""
...
def cummax(expr, axis=None):
"""
Cumulative maximum along specified axis.
Parameters:
- expr: expression
- axis: axis to compute cumulative max along
Returns:
- Expression: cumulative maximum
"""
...
def cumprod(expr, axis=None):
"""
Cumulative product along specified axis.
Parameters:
- expr: expression
- axis: axis to compute cumulative product along
Returns:
- Expression: cumulative product
"""
...Advanced Elementwise Functions
Additional elementwise mathematical functions.
def ceil(expr):
"""
Ceiling function (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: ceiling values
"""
...
def floor(expr):
"""
Floor function (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: floor values
"""
...
def inv_pos(expr):
"""
Reciprocal of positive part: 1/pos(expr).
Parameters:
- expr: expression
Returns:
- Expression: reciprocal of positive part
"""
...
def logistic(expr):
"""
Logistic function: 1/(1 + exp(-expr)).
Parameters:
- expr: expression
Returns:
- Expression: logistic function values
"""
...
def loggamma(expr):
"""
Log gamma function (element-wise).
Parameters:
- expr: expression (must be positive)
Returns:
- Expression: log gamma values
"""
...
def log_normcdf(expr):
"""
Log of normal cumulative distribution function.
Parameters:
- expr: expression
Returns:
- Expression: log normal CDF values
"""
...
def neg(expr):
"""
Negative part: max(-expr, 0).
Parameters:
- expr: expression
Returns:
- Expression: negative part
"""
...
def pos(expr):
"""
Positive part: max(expr, 0).
Parameters:
- expr: expression
Returns:
- Expression: positive part
"""
...
def scalene(expr, alpha, beta):
"""
Scalene function.
Parameters:
- expr: expression
- alpha, beta: scalar parameters
Returns:
- Expression: scalene function values
"""
...
def sign(expr):
"""
Sign function (element-wise).
Parameters:
- expr: expression
Returns:
- Expression: sign values (-1, 0, or 1)
"""
...
def xexp(expr):
"""
Extended exponential: expr * exp(expr).
Parameters:
- expr: expression
Returns:
- Expression: extended exponential
"""
...
def one_minus_pos(expr):
"""
One minus positive part: 1 - pos(expr).
Parameters:
- expr: expression
Returns:
- Expression: one minus positive part
"""
...
def diff_pos(x, y):
"""
Positive difference: pos(x - y).
Parameters:
- x, y: expressions
Returns:
- Expression: positive difference
"""
...Advanced Matrix Functions
Additional matrix operations and eigenvalue functions.
def condition_number(expr):
"""
Condition number of a matrix.
Parameters:
- expr: matrix expression
Returns:
- Expression: condition number
"""
...
def resolvent(expr, s):
"""
Matrix resolvent: (sI - expr)^(-1).
Parameters:
- expr: matrix expression
- s: scalar parameter
Returns:
- Expression: resolvent matrix
"""
...
def eye_minus_inv(expr):
"""
(I - expr)^(-1) for matrices with eigenvalues < 1.
Parameters:
- expr: matrix expression
Returns:
- Expression: inverse of (I - expr)
"""
...
def lambda_sum_largest(expr, k):
"""
Sum of k largest eigenvalues.
Parameters:
- expr: symmetric matrix expression
- k: number of largest eigenvalues to sum
Returns:
- Expression: sum of k largest eigenvalues
"""
...
def lambda_sum_smallest(expr, k):
"""
Sum of k smallest eigenvalues.
Parameters:
- expr: symmetric matrix expression
- k: number of smallest eigenvalues to sum
Returns:
- Expression: sum of k smallest eigenvalues
"""
...
def gen_lambda_max(A, B):
"""
Generalized maximum eigenvalue of (A, B).
Parameters:
- A, B: matrix expressions
Returns:
- Expression: generalized maximum eigenvalue
"""
...
def pf_eigenvalue(expr):
"""
Perron-Frobenius eigenvalue of non-negative matrix.
Parameters:
- expr: non-negative matrix expression
Returns:
- Expression: Perron-Frobenius eigenvalue
"""
...
def tr_inv(expr):
"""
Trace of matrix inverse: tr(expr^(-1)).
Parameters:
- expr: positive definite matrix expression
Returns:
- Expression: trace of inverse
"""
...Quantum Information Functions
Functions for quantum information theory.
def von_neumann_entr(expr):
"""
von Neumann entropy: -tr(expr * log(expr)).
Parameters:
- expr: positive semidefinite matrix (density matrix)
Returns:
- Expression: von Neumann entropy
"""
...
def quantum_rel_entr(A, B):
"""
Quantum relative entropy: tr(A * (log(A) - log(B))).
Parameters:
- A, B: positive semidefinite matrices
Returns:
- Expression: quantum relative entropy
"""
...
def quantum_cond_entr(A, B):
"""
Quantum conditional entropy.
Parameters:
- A, B: positive semidefinite matrices
Returns:
- Expression: quantum conditional entropy
"""
...Array Manipulation and Broadcasting
Functions for reshaping and manipulating arrays.
def broadcast_to(expr, shape):
"""
Broadcast expression to specified shape.
Parameters:
- expr: expression
- shape: target shape tuple
Returns:
- Expression: broadcasted expression
"""
...
def deep_flatten(expr):
"""
Flatten expression to 1D vector.
Parameters:
- expr: expression
Returns:
- Expression: flattened vector
"""
...
def permute_dims(expr, axes):
"""
Permute dimensions of expression.
Parameters:
- expr: expression
- axes: permutation of dimension indices
Returns:
- Expression: permuted expression
"""
...
def swapaxes(expr, axis1, axis2):
"""
Swap two axes of expression.
Parameters:
- expr: expression
- axis1, axis2: axes to swap
Returns:
- Expression: expression with swapped axes
"""
...
def moveaxis(expr, source, destination):
"""
Move axis from source to destination position.
Parameters:
- expr: expression
- source: source axis position
- destination: destination axis position
Returns:
- Expression: expression with moved axis
"""
...
def concatenate(expressions, axis=0):
"""
Concatenate expressions along specified axis.
Parameters:
- expressions: list of expressions to concatenate
- axis: axis along which to concatenate
Returns:
- Expression: concatenated expression
"""
...
def diff(expr, k=1, axis=-1):
"""
Discrete difference along specified axis.
Parameters:
- expr: expression
- k: order of difference (number of times differences are taken)
- axis: axis along which differences are taken
Returns:
- Expression: discrete differences
"""
...Matrix Wrapping Functions
Functions that wrap matrices with special properties.
def hermitian_wrap(expr):
"""
Wrap expression to ensure Hermitian property.
Parameters:
- expr: matrix expression
Returns:
- Expression: Hermitian matrix
"""
...
def psd_wrap(expr):
"""
Wrap expression to ensure positive semidefinite property.
Parameters:
- expr: matrix expression
Returns:
- Expression: PSD matrix
"""
...
def skew_symmetric_wrap(expr):
"""
Wrap expression to ensure skew-symmetric property.
Parameters:
- expr: matrix expression
Returns:
- Expression: skew-symmetric matrix
"""
...
def symmetric_wrap(expr):
"""
Wrap expression to ensure symmetric property.
Parameters:
- expr: matrix expression
Returns:
- Expression: symmetric matrix
"""
...Triangular Matrix Operations
Operations related to triangular matrices.
def upper_tri(expr, k=0):
"""
Extract upper triangular part of matrix.
Parameters:
- expr: matrix expression
- k: diagonal offset (0 for main diagonal)
Returns:
- Expression: upper triangular matrix
"""
...
def vec_to_upper_tri(expr, strict=False):
"""
Convert vector to upper triangular matrix.
Parameters:
- expr: vector expression
- strict: whether to exclude diagonal elements
Returns:
- Expression: upper triangular matrix
"""
...Special Advanced Functions
Specialized mathematical functions for specific applications.
def conv(x, y):
"""
Convolution of two vectors.
Parameters:
- x, y: vector expressions
Returns:
- Expression: convolution result
"""
...
def convolve(x, y):
"""
Convolution of two expressions.
Parameters:
- x, y: expressions
Returns:
- Expression: convolution result
"""
...
def kron(X, Y):
"""
Kronecker product of two matrices.
Parameters:
- X, Y: matrix expressions
Returns:
- Expression: Kronecker product
"""
...
def partial_trace(expr, dims, axis):
"""
Partial trace operation (quantum mechanics).
Parameters:
- expr: matrix expression
- dims: dimensions of subsystems
- axis: axis to trace over
Returns:
- Expression: partial trace result
"""
...
def partial_transpose(expr, dims, axis):
"""
Partial transpose operation (quantum mechanics).
Parameters:
- expr: matrix expression
- dims: dimensions of subsystems
- axis: axis to transpose
Returns:
- Expression: partial transpose result
"""
...
def dotsort(expr, W):
"""
Dot sort function.
Parameters:
- expr: expression
- W: weight matrix
Returns:
- Expression: dot sort result
"""
...
def dist_ratio(expr, X, Y):
"""
Distance ratio function.
Parameters:
- expr, X, Y: expressions
Returns:
- Expression: distance ratio
"""
...
def length(expr):
"""
Length (magnitude) of vector expression.
Parameters:
- expr: vector expression
Returns:
- Expression: vector length
"""
...
def inv_prod(expr):
"""
Inverse product function.
Parameters:
- expr: expression
Returns:
- Expression: inverse product
"""
...
def perspective(f, x):
"""
Perspective function: x * f(expr/x).
Parameters:
- f: convex function
- x: positive scaling expression
Returns:
- Expression: perspective function result
"""
...
def promote(expr, shape):
"""
Promote expression to specified shape.
Parameters:
- expr: expression
- shape: target shape
Returns:
- Expression: promoted expression
"""
...
def scalar_product(x, y):
"""
Scalar product of two expressions.
Parameters:
- x, y: expressions
Returns:
- Expression: scalar product
"""
...
def tv(expr, *args):
"""
Total variation function.
Parameters:
- expr: expression
- args: additional arguments for TV computation
Returns:
- Expression: total variation
"""
...Usage Examples
import cvxpy as cp
import numpy as np
# Linear algebra example
A = cp.Parameter((4, 5))
x = cp.Variable(5)
b = cp.Parameter(4)
# Matrix-vector operations
Ax = A @ x # or cp.matmul(A, x)
residual = Ax - b
objective = cp.Minimize(cp.sum_squares(residual))
# Norm constraints
constraints = [
cp.norm(x, 1) <= 1, # L1 constraint (sparse)
cp.norm(x, 2) <= 2, # L2 constraint (bounded)
cp.norm(x, 'inf') <= 0.5 # Infinity norm constraint
]
# Portfolio optimization with different objectives
n = 10
w = cp.Variable(n) # portfolio weights
mu = cp.Parameter(n) # expected returns
Sigma = cp.Parameter((n, n), PSD=True) # covariance matrix
# Different risk measures
variance_risk = cp.quad_form(w, Sigma)
mad_risk = cp.norm(w, 1) # mean absolute deviation proxy
max_weight_risk = cp.norm(w, 'inf') # concentration risk
# Utility functions
log_utility = cp.sum(cp.log(w)) # log utility (must have w > 0)
entropy_regularization = cp.sum(cp.entr(w)) # entropy regularization
# Matrix completion problem
m, n = 20, 15
X = cp.Variable((m, n))
mask = np.random.binomial(1, 0.3, (m, n)) # observed entries
Y_obs = cp.Parameter((m, n)) # observed values
# Nuclear norm minimization (low-rank recovery)
objective = cp.Minimize(cp.norm(X, 'nuc'))
observed_constraints = [X[i, j] == Y_obs[i, j] for i, j in zip(*np.where(mask))]
matrix_completion = cp.Problem(objective, observed_constraints)
# Robust optimization with Huber loss
data_fit = cp.sum(cp.huber(A @ x - b, M=1.0))
robust_objective = cp.Minimize(data_fit + 0.1 * cp.norm(x, 1))
# Geometric programming (requires DGP mode)
x = cp.Variable(pos=True)
y = cp.Variable(pos=True)
gp_objective = cp.Minimize(x * y)
gp_constraints = [x + y == 1, cp.geo_mean([x, y]) >= 0.1]
gp_problem = cp.Problem(gp_objective, gp_constraints)
gp_problem.solve(gp=True)Install with Tessl CLI
npx tessl i tessl/pypi-cvxpy