Learn R Programming

CVXR

CVXR provides an object-oriented modeling language for convex optimization, similar to CVXPY, CVX, YALMIP, and Convex.jl. It allows you to formulate convex optimization problems in natural mathematical syntax rather than the restrictive standard form required by most solvers. You specify an objective and a set of constraints by combining constants, variables, and parameters using a library of functions with known mathematical properties. CVXR then applies signed disciplined convex programming (DCP) to verify the problem’s convexity. Once verified, the problem is converted into standard conic form and passed to an appropriate backend solver.

This version is a ground-up rewrite built on the S7 object system, designed to mirror CVXPY 1.9.1 closely. It is ~4–5x faster than the previous S4-based release, ships with 15 solvers (4 built-in), and supports DCP, DGP, DQCP, disciplined nonlinear programming (DNLP), complex variables, mixed-integer programming, warm-starting, and a derivative / sensitivity-analysis API.

For tutorials, worked examples, and the full story, visit the CVXR website.

Installation

Install the released version from CRAN:

install.packages("CVXR")

Or install the development version from GitHub:

# install.packages("pak")
pak::pak("cvxgrp/CVXR")

Quick example

library(CVXR)

# Data
set.seed(42)
n <- 50; p <- 10
X <- matrix(rnorm(n * p), n, p)
beta_true <- c(rep(1, 5), rep(0, 5))
y <- X %*% beta_true + rnorm(n, sd = 0.5)

# Problem
beta <- Variable(p)
objective <- Minimize(sum_squares(y - X %*% beta) + 0.1 * p_norm(beta, 1))
prob <- Problem(objective)

# Solve (Clarabel is the default solver)
result <- psolve(prob)
result                          # optimal value
estimated <- value(beta)        # coefficient estimates

Documentation

Tutorials and examples: https://cvxr.rbind.io
Package reference: https://www.cvxgrp.org/CVXR/
Paper: Fu, Narasimhan, and Boyd (2020). “CVXR: An R Package for Disciplined Convex Optimization.” Journal of Statistical Software, 94(14), 1–34. doi:10.18637/jss.v094.i14

If you use CVXR in your work, please cite the paper above (citation("CVXR")).

License

Apache License 2.0

Copy Link

Version

Install

install.packages('CVXR')

Monthly Downloads

12,275

Version

1.9.2

License

Apache License 2.0 | file LICENSE

Homepage

https://cvxr.rbind.io

Maintainer

Anqi Fu

Last Published

August 24th, 2026

Functions in CVXR (1.9.2)

Create a 3D Power Cone Constraint

Create an N-Dimensional Power Cone Constraint

Create a Maximization Objective

Create an Optimization Problem

Outer product of two vectors

Get Problem Constraints (read-only)

Solver Error condition

Problem Size Metrics

Get the Constants in an Expression

Create a Non-Negative Constraint

Create a Zero Constraint

Create a Minimization Objective

Per-atom Subgradient Hook (private)

Get the Total Size of a Constraint

Canonicalize an Expression

Global Monthly and Annual Temperature Anomalies (degrees C), 1850-2015 (Relative to the 1961-1990 Mean) (May 2016)

Create a Second-Order Cone Constraint

1D discrete convolution

Get the Atoms in an Expression

Error Gradient (None for every variable)

Promote a scalar expression to the given shape

available_solvers

List available solvers

Cumulative sum along an axis

apply_param_jac

Adjoint of the parameter -> (c, d, A, b) tensor map

Convert a value to a CVXR Expression

Elementwise Ceiling

condition_number

Condition number of a PSD matrix

Get Atom-Specific Domain Constraints

Standard deviation of an expression

Weighted sorted dot product

Variance of an expression

dpp_scope_active

Check if DPP Scope is Active

Create a Huber loss atom

Get the Domain Constraints of an Expression

get_problem_data

Get Problem Data for a Solver (deprecated)

Horizontal concatenation of expressions

Get Expression ID

Get Atom-Specific Data

Get Expression Curvature

Broadcast two expressions for binary operations

Indicator function for constraints

Elementwise Complex Conjugate

Get the Canonical Form

Get the Sizes of Individual Cones

Per-column Subgradient for AxisAtoms (private)

Gradient of a Constant Expression

The difference x - y with domain x > y > 0

installed_solvers

List installed solvers

Compute kth Order Differences of an Expression

Conditional Value at Risk (CVaR)

Direct Standardization: Sample

Lower/Upper Bounds of a Leaf

(Weighted) geometric mean of a vector

Direct Standardization: Population

Apply the derivative of the solution map to perturbations

Compute the gradient of a solution with respect to Parameters

Unity resolvent (I - X) inverse for positive square matrix X

Conjugate-Transpose of an Expression

Shallow Copy of an Expression Tree Node

Get the Dual Cone Constraint

is_atom_log_log_concave

Check if Atom is Log-Log Concave

is_atom_log_log_convex

Check if Atom is Log-Log Convex

Check if Expression is Parameter-Free

Pretty-print an expression with labels substituted

Logical Implication

Access the gradient of a Variable or Parameter

Maximum generalized eigenvalue

Elementwise Floor

Negative Semidefinite Constraint Operator

Get the Dual Residual

Extract Imaginary Part of Expression

graph_implementation

Get the Graph Implementation of an Atom

Logical Biconditional

Determine the sign of a numeric value

Check if a value is a sparse matrix

Positive Semidefinite Constraint Operator

Check if a Constraint is DGP-Compliant

intf_is_hermitian

Check if a matrix is symmetric (and Hermitian for real case)

Convert a value to a numeric matrix or sparse matrix

Check if Atom is Decreasing in an Argument

Inverse position: \(x^{-1}\) (for x > 0)

is_log_log_affine

Check if Expression is Log-Log Affine

is_atom_quasiconcave

Check if Atom is Quasiconcave

Check if Expression is Symmetric

Is the Expression a Vector?

Check if Expression is Quasiconvex

Check if Expression is Quasilinear

Check if Expression is Strictly Positive

linop_set_data_ndim

Set the data dimensionality on a LinOp

Check if Expression is Non-Negative

Check if Expression is Non-Positive

is_atom_quasiconvex

Check if Atom is Quasiconvex

is_log_log_concave

Check if Expression is Log-Log Concave

Check if Expression is Zero

Is the Expression a Scalar?

Check if an Expression is Constant

Check if an Expression is Concave

is_linearizable_concave

Check if an Expression is Linearizable-Concave

1D discrete convolution (numpy-style)

Get the shape of a value as an integer vector c(nrow, ncol)

Geometric matrix multiplication A diamond X

Construct a Block Matrix

Check if Expression is Real

is_linearizable_convex

Check if an Expression is Linearizable-Convex

Get the Gradient of an Expression

Check if Atom is Convex

is_atom_concave

Check if Atom is Concave

Check if an Expression is Quadratic

is_mixed_integer

Check if a Problem is Mixed-Integer

Check if Expression is Positive Semidefinite

Is the Expression a Matrix?

Cumulative maximum along an axis

Matrix fractional function

Log-determinant

Standard R Functions for CVXR Expressions

Check if Expression is Imaginary

Check if Atom is Increasing in an Argument

Elementwise log of the standard normal CDF

Mean of an expression

linop_set_dense_data

Set dense data on a LinOp

Check if an Expression is Convex

Check if Expression is Piecewise Linear

Get the label of an expression

is_quasiconcave

Check if Expression is Quasiconcave

Compute the Numeric Value of an Atom

Get Problem Objective (read-only)

Compute a norm of an expression

Recursively flatten a nested list of expressions into one column vector

linop_size_push_back

Push a dimension to the LinOp size vector

Set the type of a LinOp

linop_args_push_back

Append a child LinOp to the args list

Create a new C++ LinOp external pointer

Check if an Expression is DCP-Compliant

Check if Expression is Negative Semidefinite

Check if Expression is DQCP-Compliant

Access the perturbation delta of a Variable or Parameter

Get the Dual Value of a Constraint

Check if Expression is Hermitian

Minimum entry of an expression

Maximum eigenvalue

Get the Name of an Expression

Create an entropy atom -x * log(x)

Mixed norm (\(L_{p,q}\) norm): column-wise p-norm, then q-norm

Get all Parameters of a Problem as a Named List

Get the Parameters in an Expression

is_param_affine

Check if Expression is Parameter-Affine

Check if a Problem is a Quadratic Program

problem_solution

Get the Raw Solution Object (deprecated)

Get the Solution Status of a Problem (deprecated)

Get the DCP Sign of an Expression

Harmonic mean: n / sum(1/x_i)

lambda_sum_smallest

Sum of smallest k eigenvalues

Negative part: -min(x, 0)

Get Expression Name

lambda_sum_largest

Sum of largest k eigenvalues

KL Divergence: x*log(x/y) - x + y

Minimum eigenvalue

Logistic function: log(1 + exp(x)) -- elementwise

Check if Expression is Quadratic or Piecewise Affine

Kronecker product of two expressions

Set the label of an expression

L1 norm of an expression

Elementwise log of the gamma function

Log-sum-exp: log(sum(exp(x)))

The difference 1 - x with domain (0, 1)

Sign of a product of two expressions

Elementwise multiplication (deprecated)

Euclidean norm (deprecated alias)

Perron-Frobenius eigenvalue of a positive matrix

Maximum entry of an expression

make_sparse_diagonal_matrix

Make a CSC sparse diagonal matrix

Positive part: max(x, 0)

Elementwise minimum of expressions

Length of a Vector (Last Nonzero Index)

Trace of a square matrix expression

Project a Value onto the Domain of a Leaf

Relative Entropy: x*log(x/y)

Reshape an expression to a new shape

problem_unpack_results

Unpack Solver Results into a Problem

General p-norm of an expression

Get the Residual of a Constraint

Get Size Metrics for a Problem

reduction_invert

Invert a Solution through a Reduction

Resolvent inverse(sI - X)

Elementwise maximum of expressions

Solve a Convex Optimization Problem

Maximum singular value

reduction_apply

Apply a Reduction to a Problem

shape_from_args

Infer Shape from Arguments

Get Solver Statistics

Standard Normal Cumulative Distribution Function

Product of entries along an axis

quad_form_dpp_scope_active

Check if a quad_form DPP Scope is Active

Sampling Bounds for NLP Random Restarts

Sum of squares divided by a scalar

Sum of squares (= quad_over_lin(x, 1))

Vector dot product (inner product)

Get the Variables in an Expression

Sum of k largest entries

Sum the entries of an expression

Create Solver Options

Vertical concatenation of expressions

Adjoint of split_solution

has_quadratic_term

Check if Expression Has a Quadratic Term

save_dual_value

Save Dual Variable Values from Solver Output

smith_annotation

Smith Form Annotation for an Expression Node

Check if a symmetric matrix is PSD within tolerance

x * exp(x) -- elementwise

with_quad_form_dpp_scope

Execute Expression Within a quad_form DPP Scope

Split a primal solution into per-variable arrays

Get the Number of Cones in a Constraint

Get Solver Name

Execute Expression Within DPP Scope

supports_quad_obj

Does Solver Support Quadratic Objectives?

Reciprocal of product of entries

Create a Power atom

Partial trace of a tensor product expression

partial_optimize

Partial optimization transform

Square of an expression: x^2

intf_is_skew_symmetric

Check if a matrix is skew-symmetric (A + A^T == 0)

solver_default_param

Standard Solver Parameter Mappings

solver-constants

Solver Name Constants

Sign of a sum of expressions

Sum of k smallest entries

Get Problem Data for a Solver

Extract Real Part of Expression

Check if an Expression is Affine

Get Expression Size

Attach a label to an expression

Scalene penalty: alpha * pos(x) + beta * neg(x)

reduction-chain-rule

Reduction chain-rule hooks (dict-in / dict-out)

Infer Sign from Arguments

Trace of matrix inverse

Unpack Results (backward-compatible alias)

Get the Violation of a Constraint

Visualize the Canonicalization Pipeline of a CVXR Problem

Deep Copy of an Expression Tree

Total variation (deprecated alias)

Convert CVXR Object to LaTeX

Check if an Expression or Problem is DNLP-Compliant

Check if an Atom is Smooth

Check DPP Compliance

is_log_log_convex

Check if Expression is Log-Log Convex

Check if Expression is Complex

Get the Numeric Value of an Expression

vec_to_upper_tri

Reshape a vector into an upper triangular matrix

Vectorize an expression (column vector)

total_variation

Total variation of a vector or matrix

linop_set_sparse_data

Set sparse data on a LinOp

Check if a Problem is a Linear Program

Check if an Expression is Smooth

Get all Variables of a Problem as a Named List

is_skew_symmetric

Check if Expression is Skew-Symmetric

linop_set_linop_data

Set a LinOp data sub-tree on a LinOp

Log(1 + x) -- elementwise

linop_slice_push_back

Push a slice (index vector) to a LinOp

Nuclear norm (sum of singular values)

L-infinity norm of an expression

Quadratic form x^T P x

partial_transpose

Partial transpose of a tensor product expression

Perspective Transform

Peak-to-peak (range): max(x) - min(x)

reduction-id-map

Reduction leaf-id maps

reduction_accepts

Check if a Reduction Accepts a Problem

Scalar product (alias for vdot)

Scalarize multiple objectives into a single objective

Get the Raw Solution Object

Solve via Raw Data

update_parameters

Update Parameters for DPP Fast Path

Extract strict upper triangle of a square matrix

status-constants

Solution Status Constants

Get the Solution Status of a Problem

validate_arguments

Validate Arguments to an Atom

Set the Value of a Leaf Expression

CVXR: Disciplined Convex Optimization

Create an Exponential Cone Constraint

Callback Parameter

Create a Constant Expression

Create an Equality Constraint

Extract Diagonal from a Matrix

FiniteSet Constraint

Vector to Diagonal Matrix

Create an Inequality Constraint

Create a Non-Positive Constraint

Create a Parameter

Create a Positive Semidefinite Constraint

Partial optimization of a Problem

DCP Error condition

Create an Optimization Variable