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

17,122

Version

1.9.1

License

Apache License 2.0 | file LICENSE

Homepage

https://cvxr.rbind.io

Maintainer

Anqi Fu

Last Published

June 9th, 2026

Functions in CVXR (1.9.1)

FiniteSet Constraint

Create an Optimization Variable

Create a Non-Positive Constraint

Callback Parameter

Create a Constant Expression

Vector to Diagonal Matrix

Create an Equality Constraint

Create a Parameter

Problem Size Metrics

Create a 3D Power Cone Constraint

Create an N-Dimensional Power Cone Constraint

Partial optimization of a Problem

Solver Error condition

CVXR: Disciplined Convex Optimization

Create an Inequality Constraint

Create a Maximization Objective

Create a Minimization Objective

Create a Non-Negative Constraint

Compute the gradient of a solution with respect to Parameters

Create an Optimization Problem

Create a Positive Semidefinite Constraint

Create a Second-Order Cone Constraint

Get the Atoms in an Expression

Convert a value to a CVXR Expression

Cumulative maximum along an axis

Mean of an expression

1D discrete convolution (numpy-style)

Standard deviation of an expression

Get the Sizes of Individual Cones

Broadcast two expressions for binary operations

Elementwise Complex Conjugate

Get Atom-Specific Domain Constraints

Get the Canonical Form

Gradient of a Constant Expression

Construct a Block Matrix

Error Gradient (None for every variable)

Create a Zero Constraint

Compute a norm of an expression

Get Atom-Specific Data

Lower/Upper Bounds of a Leaf

Get the Total Size of a Constraint

Get the Constants in an Expression

Compute kth Order Differences of an Expression

Conditional Value at Risk (CVaR)

Shallow Copy of an Expression Tree Node

apply_param_jac

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

available_solvers

List available solvers

1D discrete convolution

Get Problem Constraints (read-only)

Outer product of two vectors

Geometric matrix multiplication A diamond X

get_problem_data

Get Problem Data for a Solver (deprecated)

Get the Name of an Expression

Access the perturbation delta of a Variable or Parameter

Apply the derivative of the solution map to perturbations

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

Canonicalize an Expression

Extract Imaginary Part of Expression

Positive Semidefinite Constraint Operator

Reciprocal of product of entries

Logical Biconditional

Negative Semidefinite Constraint Operator

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

has_quadratic_term

Check if Expression Has a Quadratic Term

Direct Standardization: Population

dpp_scope_active

Check if DPP Scope is Active

Check if an Expression is Constant

Check if Atom is Increasing in an Argument

Check if an Expression is Convex

Is the Expression a Matrix?

is_linearizable_concave

Check if an Expression is Linearizable-Concave

Check if a Problem is a Linear Program

Check if Expression is Piecewise Linear

Horizontal concatenation of expressions

intf_is_skew_symmetric

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

Elementwise Floor

installed_solvers

List installed solvers

Create a Huber loss atom

Get Expression ID

Pretty-print an expression with labels substituted

Convert a value to a numeric matrix or sparse matrix

Check if a Problem is a Quadratic Program

Maximum eigenvalue

Minimum eigenvalue

Cumulative sum along an axis

Get Expression Curvature

condition_number

Condition number of a PSD matrix

Elementwise Ceiling

Variance of an expression

Get the Domain Constraints of an Expression

Get the Dual Value of a Constraint

Check if an Expression is DCP-Compliant

Check if Expression is Hermitian

Per-column Subgradient for AxisAtoms (private)

Check if Atom is Decreasing in an Argument

Check if a value is a sparse matrix

Determine the sign of a numeric value

Get the Dual Residual

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

Promote a scalar expression to the given shape

is_atom_quasiconcave

Check if Atom is Quasiconcave

is_atom_log_log_convex

Check if Atom is Log-Log Convex

Check DPP Compliance

Check if Expression is DQCP-Compliant

make_sparse_diagonal_matrix

Make a CSC sparse diagonal matrix

linop_set_linop_data

Set a LinOp data sub-tree on a LinOp

Standard R Functions for CVXR Expressions

linop_set_dense_data

Set dense data on a LinOp

Logical Implication

Maximum generalized eigenvalue

(Weighted) geometric mean of a vector

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

Create an entropy atom -x * log(x)

is_skew_symmetric

Check if Expression is Skew-Symmetric

Length of a Vector (Last Nonzero Index)

Is the Expression a Scalar?

Check if Expression is Imaginary

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

Sign of a product of two expressions

linop_args_push_back

Append a child LinOp to the args list

linop_size_push_back

Push a dimension to the LinOp size vector

Positive part: max(x, 0)

Compute the Numeric Value of an Atom

Get the Number of Cones in a Constraint

Indicator function for constraints

Check if Atom is Convex

Create a Power atom

Quadratic form x^T P x

linop_slice_push_back

Push a slice (index vector) to a LinOp

Minimum entry of an expression

partial_optimize

Partial optimization transform

Get Problem Data for a Solver

Get the Parameters in an Expression

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

Get Problem Objective (read-only)

Elementwise minimum of expressions

reduction-id-map

Reduction leaf-id maps

Square of an expression: x^2

Resolvent inverse(sI - X)

Sampling Bounds for NLP Random Restarts

problem_solution

Get the Raw Solution Object (deprecated)

reduction-chain-rule

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

quad_form_dpp_scope_active

Check if a quad_form DPP Scope is Active

Check if Expression is Negative Semidefinite

Check if Expression is Non-Positive

Per-atom Subgradient Hook (private)

is_quasiconcave

Check if Expression is Quasiconcave

Reshape an expression to a new shape

Access the gradient of a Variable or Parameter

Weighted sorted dot product

Direct Standardization: Sample

Get the Residual of a Constraint

Attach a label to an expression

Get the Gradient of an Expression

intf_is_hermitian

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

Get the Dual Cone Constraint

Get the DCP Sign of an Expression

Conjugate-Transpose of an Expression

graph_implementation

Get the Graph Implementation of an Atom

Check if Expression is Quasiconvex

vec_to_upper_tri

Reshape a vector into an upper triangular matrix

Harmonic mean: n / sum(1/x_i)

Check if an Expression is Affine

is_atom_concave

Check if Atom is Concave

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

status-constants

Solution Status Constants

is_atom_log_log_concave

Check if Atom is Log-Log Concave

Get Size Metrics for a Problem

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

Elementwise multiplication (deprecated)

Elementwise log of the standard normal CDF

Check if an Expression is Smooth

Check if Expression is Symmetric

Get all Variables of a Problem as a Named List

Check if a Constraint is DGP-Compliant

Check if an Atom is Smooth

is_atom_quasiconvex

Check if Atom is Quasiconvex

Get the Violation of a Constraint

Check if Expression is Quasilinear

is_mixed_integer

Check if a Problem is Mixed-Integer

Check if Expression is Non-Negative

L-infinity norm of an expression

Partial trace of a tensor product expression

Euclidean norm (deprecated alias)

Get Expression Name

Check if an Expression or Problem is DNLP-Compliant

is_linearizable_convex

Check if an Expression is Linearizable-Convex

Check if a symmetric matrix is PSD within tolerance

Check if an Expression is Concave

is_log_log_affine

Check if Expression is Log-Log Affine

Check if Expression is Complex

is_param_affine

Check if Expression is Parameter-Affine

lambda_sum_smallest

Sum of smallest k eigenvalues

Check if Expression is Real

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

shape_from_args

Infer Shape from Arguments

partial_transpose

Partial transpose of a tensor product expression

Scalarize multiple objectives into a single objective

lambda_sum_largest

Sum of largest k eigenvalues

Kronecker product of two expressions

problem_unpack_results

Unpack Solver Results into a Problem

Get the Solution Status of a Problem (deprecated)

Matrix fractional function

Trace of a square matrix expression

update_parameters

Update Parameters for DPP Fast Path

Get Expression Size

Check if Expression is Parameter-Free

L1 norm of an expression

smith_annotation

Smith Form Annotation for an Expression Node

General p-norm of an expression

Negative part: -min(x, 0)

Get all Parameters of a Problem as a Named List

Maximum singular value

is_log_log_concave

Check if Expression is Log-Log Concave

Infer Sign from Arguments

Check if Expression is Strictly Positive

Is the Expression a Vector?

is_log_log_convex

Check if Expression is Log-Log Convex

Check if Expression is Positive Semidefinite

Get the label of an expression

Set the label of an expression

Elementwise log of the gamma function

Check if Expression is Quadratic or Piecewise Affine

Check if an Expression is Quadratic

Get the Solution Status of a Problem

Get the Variables in an Expression

linop_set_data_ndim

Set the data dimensionality on a LinOp

Create a new C++ LinOp external pointer

Log-determinant

Elementwise maximum of expressions

Log(1 + x) -- elementwise

Set the type of a LinOp

Check if Expression is Zero

Perspective Transform

Product of entries along an axis

linop_set_sparse_data

Set sparse data on a LinOp

Solve a Convex Optimization Problem

Maximum entry of an expression

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

Nuclear norm (sum of singular values)

Standard Normal Cumulative Distribution Function

reduction_invert

Invert a Solution through a Reduction

solver_default_param

Standard Solver Parameter Mappings

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

Sum the entries of an expression

Scalar product (alias for vdot)

Project a Value onto the Domain of a Leaf

total_variation

Total variation of a vector or matrix

Relative Entropy: x*log(x/y)

Visualize the Canonicalization Pipeline of a CVXR Problem

Trace of matrix inverse

Perron-Frobenius eigenvalue of a positive matrix

Total variation (deprecated alias)

Sum of k largest entries

Sum of squares divided by a scalar

Create Solver Options

Get Solver Statistics

Get the Numeric Value of an Expression

Get Solver Name

reduction_accepts

Check if a Reduction Accepts a Problem

Unpack Results (backward-compatible alias)

x * exp(x) -- elementwise

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

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

Extract strict upper triangle of a square matrix

Get the Raw Solution Object

Vector dot product (inner product)

Sign of a sum of expressions

Adjoint of split_solution

Split a primal solution into per-variable arrays

reduction_apply

Apply a Reduction to a Problem

supports_quad_obj

Does Solver Support Quadratic Objectives?

Extract Real Part of Expression

Deep Copy of an Expression Tree

validate_arguments

Validate Arguments to an Atom

save_dual_value

Save Dual Variable Values from Solver Output

Solve via Raw Data

Sum of k smallest entries

Vectorize an expression (column vector)

Execute Expression Within DPP Scope

Vertical concatenation of expressions

Convert CVXR Object to LaTeX

solver-constants

Solver Name Constants

with_quad_form_dpp_scope

Execute Expression Within a quad_form DPP Scope

Set the Value of a Leaf Expression

DCP Error condition

Extract Diagonal from a Matrix

Create an Exponential Cone Constraint