All functions

Abs() to_numeric(<Abs>) sign_from_args(<Abs>) is_atom_convex(<Abs>) is_atom_concave(<Abs>) is_incr(<Abs>) is_decr(<Abs>) is_pwl(<Abs>) graph_implementation(<Abs>)

The Abs class.

`+`(<Expression>,<missing>) `+`(<Expression>,<Expression>) `+`(<Expression>,<ConstVal>) `+`(<ConstVal>,<Expression>) to_numeric(<AddExpression>) size_from_args(<AddExpression>) graph_implementation(<AddExpression>)

The AddExpression class.

sign_from_args(<AffAtom>) is_atom_convex(<AffAtom>) is_atom_concave(<AffAtom>) is_incr(<AffAtom>) is_decr(<AffAtom>) is_quadratic(<AffAtom>) is_pwl(<AffAtom>)

The AffAtom class.

AffineProd() validate_args(<AffineProd>) to_numeric(<AffineProd>) size_from_args(<AffineProd>) sign_from_args(<AffineProd>) is_atom_convex(<AffineProd>) is_atom_concave(<AffineProd>) is_incr(<AffineProd>) is_decr(<AffineProd>) is_quadratic(<AffineProd>)

The AffineProd class.

validate_args(<Atom>) size(<Atom>) dim(<Atom>) nrow(<Atom>) ncol(<Atom>) is_positive(<Atom>) is_negative(<Atom>) is_convex(<Atom>) is_concave(<Atom>) canonicalize(<Atom>) graph_implementation(<Atom>) variables(<Atom>) parameters(<Atom>) constants(<Atom>) value(<Atom>) grad(<Atom>) domain(<Atom>)

The Atom class.

size_from_args(<AxisAtom>) get_data(<AxisAtom>) validate_args(<AxisAtom>)

The AxisAtom class.

to_numeric(<BinaryOperator>) sign_from_args(<BinaryOperator>)

The BinaryOperator class.

Bool() as.character(<Bool>) canonicalize(<Bool>) is_positive(<Bool>) is_negative(<Bool>)

The Bool class.

BoolConstr() format_constr(<BoolConstr>) size(<BoolConstr>)

The BoolConstr class.

CVXR-package

CVXR: Disciplined Convex Optimization in R

CallbackParam() value(<CallbackParam>) get_data(<CallbackParam>)

The CallbackParam class.

canonicalize(<Canonical>) variables(<Canonical>) parameters(<Canonical>) constants(<Canonical>) get_data(<Canonical>)

The Canonical class.

Constant() as.character(<Constant>) constants(<Constant>) get_data(<Constant>) value(<Constant>) grad(<Constant>) size(<Constant>) is_positive(<Constant>) is_negative(<Constant>) canonicalize(<Constant>) as.Constant()

The Constant class.

Constraint-class

The Constraint class.

Conv() validate_args(<Conv>) to_numeric(<Conv>) size_from_args(<Conv>) sign_from_args(<Conv>) is_incr(<Conv>) is_decr(<Conv>) graph_implementation(<Conv>)

The Conv class.

CumSum() to_numeric(<CumSum>) size_from_args(<CumSum>) validate_args(<CumSum>) graph_implementation(<CumSum>)

The CumSum class.

DiagMat() to_numeric(<DiagMat>) size_from_args(<DiagMat>) graph_implementation(<DiagMat>)

The DiagMat class.

DiagVec() to_numeric(<DiagVec>) size_from_args(<DiagVec>) graph_implementation(<DiagVec>)

The DiagVec class.

`/`(<Expression>,<Expression>) `/`(<Expression>,<ConstVal>) `/`(<ConstVal>,<Expression>) is_quadratic(<DivExpression>) size_from_args(<DivExpression>) is_incr(<DivExpression>) is_decr(<DivExpression>) graph_implementation(<DivExpression>)

The DivExpression class.

ECOS() lp_capable(<ECOS>) socp_capable(<ECOS>) sdp_capable(<ECOS>) exp_capable(<ECOS>) mip_capable(<ECOS>) name(<ECOS>) import_solver(<ECOS>) Solver.solve(<ECOS>) format_results(<ECOS>)

The ECOS class.

status_map(<ECOS>)

ECOS Status Map

ECOS_BB() lp_capable(<ECOS_BB>) socp_capable(<ECOS_BB>) sdp_capable(<ECOS_BB>) exp_capable(<ECOS_BB>) mip_capable(<ECOS_BB>) name(<ECOS_BB>) Solver.solve(<ECOS_BB>)

The ECOS_BB class.

validate_args(<Elementwise>) size_from_args(<Elementwise>)

The Elementwise class.

Entr() to_numeric(<Entr>) sign_from_args(<Entr>) is_atom_convex(<Entr>) is_atom_concave(<Entr>) is_incr(<Entr>) is_decr(<Entr>) graph_implementation(<Entr>)

The Entr class.

`==`(<Expression>,<Expression>) `==`(<Expression>,<ConstVal>) `==`(<ConstVal>,<Expression>) EqConstraint() is_dcp(<EqConstraint>) residual(<EqConstraint>) canonicalize(<EqConstraint>)

The EqConstraint class.

Exp() to_numeric(<Exp>) sign_from_args(<Exp>) is_atom_convex(<Exp>) is_atom_concave(<Exp>) is_incr(<Exp>) is_decr(<Exp>) graph_implementation(<Exp>)

The Exp class.

ExpCone() size(<ExpCone>) as.character(<ExpCone>) variables(<ExpCone>) format_constr(<ExpCone>)

The ExpCone class.

value(<Expression>) grad(<Expression>) domain(<Expression>) as.character(<Expression>) name(<Expression>) curvature(<Expression>) is_constant(<Expression>) is_affine(<Expression>) is_convex(<Expression>) is_concave(<Expression>) is_dcp(<Expression>) is_quadratic(<Expression>) is_pwl(<Expression>) is_zero(<Expression>) is_positive(<Expression>) is_negative(<Expression>) size(<Expression>) is_scalar(<Expression>) is_vector(<Expression>) is_matrix(<Expression>) nrow(<Expression>) ncol(<Expression>)

The Expression class.

GLPK() lp_capable(<GLPK>) socp_capable(<GLPK>) sdp_capable(<GLPK>) exp_capable(<GLPK>) mip_capable(<GLPK>) name(<GLPK>) import_solver(<GLPK>) Solver.solve(<GLPK>) format_results(<GLPK>)

The GLPK class

status_map(<GLPK>)

GLPK Status Map

GUROBI() lp_capable(<GUROBI>) socp_capable(<GUROBI>) sdp_capable(<GUROBI>) exp_capable(<GUROBI>) mip_capable(<GUROBI>) name(<GUROBI>) import_solver(<GUROBI>) Solver.solve(<GUROBI>)

The GUROBI class.

status_map(<GUROBI>)

GUROBI Status Map

GeoMean() validate_args(<GeoMean>) to_numeric(<GeoMean>) size_from_args(<GeoMean>) sign_from_args(<GeoMean>) is_atom_convex(<GeoMean>) is_atom_concave(<GeoMean>) is_incr(<GeoMean>) is_decr(<GeoMean>) get_data(<GeoMean>) graph_implementation(<GeoMean>)

The GeoMean class.

HStack() validate_args(<HStack>) to_numeric(<HStack>) size_from_args(<HStack>) graph_implementation(<HStack>)

The HStack class.

Huber() validate_args(<Huber>) to_numeric(<Huber>) sign_from_args(<Huber>) is_atom_convex(<Huber>) is_atom_concave(<Huber>) is_incr(<Huber>) is_decr(<Huber>) get_data(<Huber>) graph_implementation(<Huber>)

The Huber class.

`[`(<Expression>,<missing>,<missing>,<ANY>) `[`(<Expression>,<index>,<missing>,<ANY>) `[`(<Expression>,<missing>,<index>,<ANY>) `[`(<Expression>,<index>,<index>,<ANY>) `[`(<Expression>,<matrix>,<index>,<ANY>) `[`(<Expression>,<index>,<matrix>,<ANY>) `[`(<Expression>,<matrix>,<matrix>,<ANY>) `[`(<Expression>,<matrix>,<missing>,<ANY>) Index() to_numeric(<Index>) size_from_args(<Index>) get_data(<Index>) graph_implementation(<Index>)

The Index class.

Int() as.character(<Int>) canonicalize(<Int>)

The Int class.

IntConstr()

The IntConstr class.

KLDiv() to_numeric(<KLDiv>) sign_from_args(<KLDiv>) is_atom_convex(<KLDiv>) is_atom_concave(<KLDiv>) is_incr(<KLDiv>) is_decr(<KLDiv>) graph_implementation(<KLDiv>)

The KLDiv class.

Kron() validate_args(<Kron>) to_numeric(<Kron>) size_from_args(<Kron>) sign_from_args(<Kron>) is_incr(<Kron>) is_decr(<Kron>) graph_implementation(<Kron>)

The Kron class.

LPSOLVE() lp_capable(<LPSOLVE>) socp_capable(<LPSOLVE>) sdp_capable(<LPSOLVE>) exp_capable(<LPSOLVE>) mip_capable(<LPSOLVE>) name(<LPSOLVE>) import_solver(<LPSOLVE>) Solver.solve(<LPSOLVE>) format_results(<LPSOLVE>)

The LPSOLVE class

status_map(<LPSOLVE>)

LPSOLVE Status Map

LambdaMax() validate_args(<LambdaMax>) to_numeric(<LambdaMax>) size_from_args(<LambdaMax>) sign_from_args(<LambdaMax>) is_atom_convex(<LambdaMax>) is_atom_concave(<LambdaMax>) is_incr(<LambdaMax>) is_decr(<LambdaMax>) graph_implementation(<LambdaMax>)

The LambdaMax class.

variables(<Leaf>) parameters(<Leaf>) constants(<Leaf>) is_convex(<Leaf>) is_concave(<Leaf>) is_quadratic(<Leaf>) is_pwl(<Leaf>) domain(<Leaf>) validate_val(<Leaf>)

The Leaf class.

`<=`(<Expression>,<Expression>) `<=`(<Expression>,<ConstVal>) `<=`(<ConstVal>,<Expression>) `<`(<Expression>,<Expression>) `<`(<Expression>,<ConstVal>) `<`(<ConstVal>,<Expression>) `>=`(<Expression>,<Expression>) `>=`(<Expression>,<ConstVal>) `>=`(<ConstVal>,<Expression>) `>`(<Expression>,<Expression>) `>`(<Expression>,<ConstVal>) `>`(<ConstVal>,<Expression>) LeqConstraint() as.character(<LeqConstraint>) id(<LeqConstraint>) size(<LeqConstraint>) is_dcp(<LeqConstraint>) canonicalize(<LeqConstraint>) variables(<LeqConstraint>) parameters(<LeqConstraint>) constants(<LeqConstraint>) residual(<LeqConstraint>) value(<LeqConstraint>) violation(<LeqConstraint>)

The LeqConstraint class.

Log() to_numeric(<Log>) sign_from_args(<Log>) is_atom_convex(<Log>) is_atom_concave(<Log>) is_incr(<Log>) is_decr(<Log>) graph_implementation(<Log>)

The Log class.

Log1p() to_numeric(<Log1p>) sign_from_args(<Log1p>) graph_implementation(<Log1p>)

The Log1p class.

LogDet() validate_args(<LogDet>) to_numeric(<LogDet>) size_from_args(<LogDet>) sign_from_args(<LogDet>) is_atom_convex(<LogDet>) is_atom_concave(<LogDet>) is_incr(<LogDet>) is_decr(<LogDet>) graph_implementation(<LogDet>)

The LogDet class.

LogSumExp() to_numeric(<LogSumExp>) sign_from_args(<LogSumExp>) is_atom_convex(<LogSumExp>) is_atom_concave(<LogSumExp>) is_incr(<LogSumExp>) is_decr(<LogSumExp>) graph_implementation(<LogSumExp>)

The LogSumExp class.

Logistic() to_numeric(<Logistic>) sign_from_args(<Logistic>) is_atom_convex(<Logistic>) is_atom_concave(<Logistic>) is_incr(<Logistic>) is_decr(<Logistic>) graph_implementation(<Logistic>)

The Logistic class.

MOSEK() lp_capable(<MOSEK>) socp_capable(<MOSEK>) sdp_capable(<MOSEK>) exp_capable(<MOSEK>) mip_capable(<MOSEK>) name(<MOSEK>) import_solver(<MOSEK>) Solver.solve(<MOSEK>)

The MOSEK class.

status_map(<MOSEK>)

MOSEK Status Map

MatrixFrac() validate_args(<MatrixFrac>) to_numeric(<MatrixFrac>) size_from_args(<MatrixFrac>) sign_from_args(<MatrixFrac>) is_atom_convex(<MatrixFrac>) is_atom_concave(<MatrixFrac>) is_incr(<MatrixFrac>) is_decr(<MatrixFrac>) is_quadratic(<MatrixFrac>) graph_implementation(<MatrixFrac>)

The MatrixFrac class.

MaxElemwise() to_numeric(<MaxElemwise>) sign_from_args(<MaxElemwise>) is_atom_convex(<MaxElemwise>) is_atom_concave(<MaxElemwise>) is_incr(<MaxElemwise>) is_decr(<MaxElemwise>) is_pwl(<MaxElemwise>) graph_implementation(<MaxElemwise>)

The MaxElemwise class.

MaxEntries() to_numeric(<MaxEntries>) sign_from_args(<MaxEntries>) is_atom_convex(<MaxEntries>) is_atom_concave(<MaxEntries>) is_incr(<MaxEntries>) is_decr(<MaxEntries>) is_pwl(<MaxEntries>) graph_implementation(<MaxEntries>)

The MaxEntries class.

Maximize() canonicalize(<Maximize>) is_dcp(<Maximize>) is_quadratic(<Maximize>)

The Maximize class.

Minimize() canonicalize(<Minimize>) variables(<Minimize>) parameters(<Minimize>) constants(<Minimize>) is_dcp(<Minimize>) value(<Minimize>)

The Minimize class.

MulElemwise() validate_args(<MulElemwise>) to_numeric(<MulElemwise>) size_from_args(<MulElemwise>) sign_from_args(<MulElemwise>) is_incr(<MulElemwise>) is_decr(<MulElemwise>) is_quadratic(<MulElemwise>) graph_implementation(<MulElemwise>)

The MulElemwise class.

`%*%`(<Expression>,<Expression>) `%*%`(<Expression>,<ConstVal>) `%*%`(<ConstVal>,<Expression>) validate_args(<MulExpression>) size_from_args(<MulExpression>) is_incr(<MulExpression>) is_decr(<MulExpression>) graph_implementation(<MulExpression>)

The MulExpression class.

`-`(<Expression>,<missing>) `-`(<Expression>,<Expression>) `-`(<Expression>,<ConstVal>) `-`(<ConstVal>,<Expression>) to_numeric(<NegExpression>) size_from_args(<NegExpression>) sign_from_args(<NegExpression>) is_incr(<NegExpression>) is_decr(<NegExpression>) graph_implementation(<NegExpression>)

The NegExpression class.

NonNegative() as.character(<NonNegative>) canonicalize(<NonNegative>) is_positive(<NonNegative>) is_negative(<NonNegative>)

The NonNegative class.

NonlinearConstraint() variables(<NonlinearConstraint>)

The NonlinearConstraint class.

NormNuc() to_numeric(<NormNuc>) size_from_args(<NormNuc>) sign_from_args(<NormNuc>) is_atom_convex(<NormNuc>) is_atom_concave(<NormNuc>) is_incr(<NormNuc>) is_decr(<NormNuc>) graph_implementation(<NormNuc>)

The NormNuc class.

`-`(<Minimize>,<missing>) `+`(<Minimize>,<Minimize>) `+`(<Minimize>,<Maximize>) `+`(<Minimize>,<numeric>) `+`(<numeric>,<Minimize>) `-`(<Minimize>,<Minimize>) `-`(<Minimize>,<Maximize>) `-`(<Minimize>,<numeric>) `-`(<numeric>,<Minimize>) `*`(<Minimize>,<numeric>) `*`(<Maximize>,<numeric>) `*`(<numeric>,<Minimize>) `/`(<Minimize>,<numeric>) `-`(<Maximize>,<missing>) `+`(<Maximize>,<Maximize>) `+`(<Maximize>,<Minimize>)

Arithmetic Operations on Objectives

`%>>%`() `%<<%`() PSDConstraint() is_dcp(<PSDConstraint>) residual(<PSDConstraint>) canonicalize(<PSDConstraint>)

The PSDConstraint class.

Parameter() as.character(<Parameter>) get_data(<Parameter>) name(<Parameter>) size(<Parameter>) is_positive(<Parameter>) is_negative(<Parameter>) grad(<Parameter>) parameters(<Parameter>) value(<Parameter>) `value<-`(<Parameter>) canonicalize(<Parameter>)

The Parameter class.

Pnorm() validate_args(<Pnorm>) name(<Pnorm>) to_numeric(<Pnorm>) sign_from_args(<Pnorm>) is_atom_convex(<Pnorm>) is_atom_concave(<Pnorm>) is_incr(<Pnorm>) is_decr(<Pnorm>) is_pwl(<Pnorm>) get_data(<Pnorm>) graph_implementation(<Pnorm>)

The Pnorm class.

Power() validate_args(<Power>) get_data(<Power>) to_numeric(<Power>) sign_from_args(<Power>) is_atom_convex(<Power>) is_atom_concave(<Power>) is_constant(<Power>) is_incr(<Power>) is_decr(<Power>) is_quadratic(<Power>) graph_implementation(<Power>)

The Power class.

`+`(<Problem>,<missing>) `-`(<Problem>,<missing>) `+`(<Problem>,<numeric>) `+`(<numeric>,<Problem>) `+`(<Problem>,<Problem>) `-`(<Problem>,<numeric>) `-`(<numeric>,<Problem>) `-`(<Problem>,<Problem>) `*`(<Problem>,<numeric>) `*`(<numeric>,<Problem>) `/`(<Problem>,<numeric>)

Arithmetic Operations on Problems

Problem() objective(<Problem>) `objective<-`(<Problem>) constraints(<Problem>) `constraints<-`(<Problem>) value(<Problem>) `value<-`(<Problem>) is_dcp(<Problem>) is_qp(<Problem>) canonicalize(<Problem>) variables(<Problem>) parameters(<Problem>) constants(<Problem>) size_metrics(<Problem>) get_problem_data(<Problem>,<character>) unpack_results(<Problem>)

The Problem class.

QuadOverLin() validate_args(<QuadOverLin>) to_numeric(<QuadOverLin>) size_from_args(<QuadOverLin>) sign_from_args(<QuadOverLin>) is_atom_convex(<QuadOverLin>) is_atom_concave(<QuadOverLin>) is_incr(<QuadOverLin>) is_decr(<QuadOverLin>) is_quadratic(<QuadOverLin>) graph_implementation(<QuadOverLin>)

The QuadOverLin class.

is_incr(<RMulExpression>) is_decr(<RMulExpression>) graph_implementation(<RMulExpression>)

The RMulExpression class.

Rdict() `$`(<Rdict>) length(<Rdict>) is.element(<ANY>,<Rdict>) `[`(<Rdict>,<ANY>,<ANY>,<ANY>) `[<-`(<Rdict>,<ANY>,<ANY>,<ANY>)

The Rdict class.

Rdictdefault() `[`(<Rdictdefault>,<ANY>,<ANY>,<ANY>)

The Rdictdefault class.

Reshape() validate_args(<Reshape>) to_numeric(<Reshape>) size_from_args(<Reshape>) get_data(<Reshape>) graph_implementation(<Reshape>)

The Reshape class.

SCS() lp_capable(<SCS>) socp_capable(<SCS>) sdp_capable(<SCS>) exp_capable(<SCS>) mip_capable(<SCS>) name(<SCS>) import_solver(<SCS>) Solver.solve(<SCS>) format_results(<SCS>)

The SCS class.

status_map(<SCS>)

SCS Status Map

SDP() as.character(<SDP>) size(<SDP>) format_constr(<SDP>)

The SDP class.

SOC() as.character(<SOC>) format_constr(<SOC>) size(<SOC>)

The SOC class.

SOCAxis() as.character(<SOCAxis>) format_constr(<SOCAxis>) num_cones(<SOCAxis>) cone_size(<SOCAxis>) size(<SOCAxis>)

The SOCAxis class.

Semidef()

Positive Semidefinite Variable

SemidefUpperTri() as.character(<SemidefUpperTri>) get_data(<SemidefUpperTri>) canonicalize(<SemidefUpperTri>) canonicalize(<SymmetricUpperTri>)

The SemidefUpperTri class.

SigmaMax() to_numeric(<SigmaMax>) size_from_args(<SigmaMax>) sign_from_args(<SigmaMax>) is_atom_convex(<SigmaMax>) is_atom_concave(<SigmaMax>) is_incr(<SigmaMax>) is_decr(<SigmaMax>) graph_implementation(<SigmaMax>)

The SigmaMax class.

SizeMetrics()

The SizeMetrics class.

lp_capable() socp_capable() sdp_capable() exp_capable() mip_capable()

Solver Capabilities

Solver.choose_solver()

Choose a Solver

validate_solver(<Solver>) nonlin_constr(<Solver>) Solver.solve(<Solver>) format_results(<Solver>)

The Solver class.

Solver.solve()

Call to Solver

SolverStats()

The SolverStats class.

Sqrt() validate_args(<Sqrt>) to_numeric(<Sqrt>) get_data(<Sqrt>) sign_from_args(<Sqrt>) is_atom_convex(<Sqrt>) is_atom_concave(<Sqrt>) is_incr(<Sqrt>) is_decr(<Sqrt>) is_quadratic(<Sqrt>) graph_implementation(<Sqrt>)

The Sqrt class.

Square() validate_args(<Square>) to_numeric(<Square>) get_data(<Square>) sign_from_args(<Square>) is_atom_convex(<Square>) is_atom_concave(<Square>) is_incr(<Square>) is_decr(<Square>) is_quadratic(<Square>) graph_implementation(<Square>)

The Square class.

SumEntries() to_numeric(<SumEntries>) graph_implementation(<SumEntries>)

The SumEntries class.

SumLargest() validate_args(<SumLargest>) to_numeric(<SumLargest>) size_from_args(<SumLargest>) sign_from_args(<SumLargest>) is_atom_convex(<SumLargest>) is_atom_concave(<SumLargest>) is_incr(<SumLargest>) is_decr(<SumLargest>) get_data(<SumLargest>) graph_implementation(<SumLargest>)

The SumLargest class.

Symmetric()

Symmetric Variable

SymmetricUpperTri() as.character(<SymmetricUpperTri>) get_data(<SymmetricUpperTri>)

The SymmetricUpperTri class.

Trace() validate_args(<Trace>) to_numeric(<Trace>) size_from_args(<Trace>) graph_implementation(<Trace>)

The Trace class.

to_numeric(<Transpose>) size_from_args(<Transpose>) graph_implementation(<Transpose>)

The Transpose class.

UnaryOperator-class

The UnaryOperator class.

UpperTri() validate_args(<UpperTri>) to_numeric(<UpperTri>) size_from_args(<UpperTri>) graph_implementation(<UpperTri>)

The UpperTri class.

VStack() validate_args(<VStack>) to_numeric(<VStack>) size_from_args(<VStack>) graph_implementation(<VStack>)

The VStack class.

Variable() as.character(<Variable>) id(<Variable>) is_positive(<Variable>) is_negative(<Variable>) size(<Variable>) get_data(<Variable>) name(<Variable>) value(<Variable>) `value<-`(<Variable>) grad(<Variable>) variables(<Variable>) canonicalize(<Variable>)

The Variable class.

abs(<Expression>)

Absolute Value

affine_prod()

Affine Product

bmat()

Block Matrix

canonicalize() canonical_form()

Canonicalize

cdiac

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

num_cones() cone_size()

Second-Order Cone Methods

conv()

Discrete Convolution

cumsum_axis() cumsum(<Expression>)

Cumulative Sum

is_atom_convex() is_atom_concave() is_atom_affine()

Curvature of an Atom

is_incr() is_decr()

Curvature of Composition

is_constant() is_affine() is_convex() is_concave() is_quadratic() is_pwl()

Curvature Properties

curvature()

Curvature of Expression

cvxr_norm()

Matrix Norm (Alternative)

diag(<Expression>)

Matrix Diagonal

diff(<Expression>)

Lagged and Iterated Differences

domain()

Domain

dspop

Direct Standardization: Population

dssamp

Direct Standardization: Sample

entr()

Entropy Function

exp(<Expression>)

Natural Exponential

variables() parameters() constants()

Parts of an Expression

format_constr()

Format Constraints

format_results()

Format Solver Results

geo_mean()

Geometric Mean

get_data()

Get Expression Data

get_gurobiglue()

Get our gurobiglue handle

get_id()

Get ID

get_mosekglue()

Get our mosekglue handle

get_np()

Get numpy handle

get_problem_data()

Get Problem Data

get_sp()

Get scipy handle

grad()

Sub/Super-Gradient

graph_implementation()

Graph Implementation

harmonic_mean()

Harmonic Mean

hstack()

Horizontal Concatenation

huber()

Huber Function

id()

Identification Number

import_solver()

Import Solver

installed_solvers()

Installed Solvers

inv_pos()

Reciprocal Function

is_dcp()

DCP Compliance

is_qp()

Is Problem a QP?

kl_div()

Kullback-Leibler Divergence

kronecker(<Expression>,<ANY>) kronecker(<ANY>,<Expression>) `%x%`(<Expression>,<ANY>) `%x%`(<ANY>,<Expression>)

Kronecker Product

lambda_max()

Maximum Eigenvalue

lambda_min()

Minimum Eigenvalue

lambda_sum_largest()

Sum of Largest Eigenvalues

lambda_sum_smallest()

Sum of Smallest Eigenvalues

log(<Expression>) log10(<Expression>) log2(<Expression>) log1p(<Expression>)

Logarithms

log_det()

Log-Determinant

log_sum_exp()

Log-Sum-Exponential

logistic()

Logistic Function

matrix_frac()

Matrix Fraction

matrix_trace()

Matrix Trace

max_elemwise()

Elementwise Maximum

max_entries() max(<Expression>)

Maximum

mean(<Expression>)

Arithmetic Mean

min_elemwise()

Elementwise Minimum

min_entries() min(<Expression>)

Minimum

mixed_norm()

Mixed Norm

`*`(<Expression>,<Expression>) `*`(<Expression>,<ConstVal>) `*`(<ConstVal>,<Expression>) mul_elemwise()

Elementwise Multiplication

name()

Variable, Parameter, or Expression Name

neg()

Elementwise Negative

norm(<Expression>,<character>)

Matrix Norm

norm1()

1-Norm

norm2()

Euclidean Norm

norm_inf()

Infinity-Norm

norm_nuc()

Nuclear Norm

p_norm()

P-Norm

pos()

Elementwise Positive

`^`(<Expression>,<numeric>) power()

Elementwise Power

objective() `objective<-`() constraints() `constraints<-`() size_metrics()

Parts of a Problem

psolve() solve(<Problem>)

Solve a DCP Problem

quad_form()

Quadratic Form

quad_over_lin()

Quadratic over Linear

resetOptions()

Reset Options

reshape_expr()

Reshape an Expression

residual() violation()

Constraint Residual

scalene()

Scalene Function

setIdCounter()

Set ID Counter

sigma_max()

Maximum Singular Value

is_zero() is_positive() is_negative()

Sign Properties

sign(<Expression>)

Sign of Expression

sign_from_args()

Atom Sign

is_scalar() is_vector() is_matrix()

Size Properties

size()

Size of Expression

size_from_args()

Atom Size

sqrt(<Expression>)

Square Root

square()

Square Function

sum_entries() sum(<Expression>)

Sum of Entries

sum_largest()

Sum of Largest Values

sum_smallest()

Sum of Smallest Values

sum_squares()

Sum of Squares

to_numeric()

Numeric Value of Atom

t(<Expression>) t(<Expression>)

Matrix Transpose

tv()

Total Variation

unpack_results()

Parse output from a solver and updates problem state

upper_tri()

Upper Triangle of a Matrix

validate_args()

Validate Arguments

validate_solver()

Validate Solver

validate_val()

Validate Value

value() `value<-`()

Get or Set Value

vec()

Vectorization of a Matrix

vstack()

Vertical Concatenation