All functions

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

The Abs class.

`+`(<Expression>,<missing>) `+`(<Expression>,<Expression>) `+`(<Expression>,<ConstVal>) `+`(<ConstVal>,<Expression>) dim_from_args(<AddExpression>) name(<AddExpression>) to_numeric(<AddExpression>) is_atom_log_log_convex(<AddExpression>) is_atom_log_log_concave(<AddExpression>) is_symmetric(<AddExpression>) is_hermitian(<AddExpression>) copy(<AddExpression>) graph_implementation(<AddExpression>)

The AddExpression class.

allow_complex(<AffAtom>) sign_from_args(<AffAtom>) is_imag(<AffAtom>) is_complex(<AffAtom>) is_atom_convex(<AffAtom>) is_atom_concave(<AffAtom>) is_incr(<AffAtom>) is_decr(<AffAtom>) is_quadratic(<AffAtom>) is_qpwa(<AffAtom>) is_pwl(<AffAtom>) is_psd(<AffAtom>) is_nsd(<AffAtom>) .grad(<AffAtom>)

The AffAtom class.

name(<Atom>) validate_args(<Atom>) dim(<Atom>) nrow(<Atom>) ncol(<Atom>) allow_complex(<Atom>) is_nonneg(<Atom>) is_nonpos(<Atom>) is_imag(<Atom>) is_complex(<Atom>) is_convex(<Atom>) is_concave(<Atom>) is_log_log_convex(<Atom>) is_log_log_concave(<Atom>) canonicalize(<Atom>) graph_implementation(<Atom>) value_impl(<Atom>) value(<Atom>) grad(<Atom>) domain(<Atom>) atoms(<Atom>)

The Atom class.

dim_from_args(<AxisAtom>) get_data(<AxisAtom>) validate_args(<AxisAtom>) .axis_grad(<AxisAtom>) .column_grad(<AxisAtom>)

The AxisAtom class.

name(<BinaryOperator>) to_numeric(<BinaryOperator>) sign_from_args(<BinaryOperator>) is_imag(<BinaryOperator>) is_complex(<BinaryOperator>)

The BinaryOperator class.

CBC_CONIC() mip_capable(<CBC_CONIC>) status_map(<CBC_CONIC>) status_map_mip(<CBC_CONIC>) status_map_lp(<CBC_CONIC>) name(<CBC_CONIC>) import_solver(<CBC_CONIC>) accepts(<CBC_CONIC>,<Problem>) perform(<CBC_CONIC>,<Problem>) invert(<CBC_CONIC>,<list>,<list>) solve_via_data(<CBC_CONIC>)

An interface to the CBC solver

CPLEX_CONIC() CPLEX_CONIC() mip_capable(<CPLEX_CONIC>) name(<CPLEX_CONIC>) import_solver(<CPLEX_CONIC>) accepts(<CPLEX_CONIC>,<Problem>) status_map(<CPLEX_CONIC>) perform(<CPLEX_CONIC>,<Problem>) invert(<CPLEX_CONIC>,<list>,<list>) solve_via_data(<CPLEX_CONIC>)

An interface for the CPLEX solver

CPLEX_QP() mip_capable(<CPLEX_QP>) status_map(<CPLEX_QP>) name(<CPLEX_QP>) import_solver(<CPLEX_QP>) invert(<CPLEX_QP>,<list>,<InverseData>) solve_via_data(<CPLEX_QP>)

An interface for the CPLEX solver.

mip_capable(<CVXOPT>) status_map(<CVXOPT>) name(<CVXOPT>) import_solver(<CVXOPT>) accepts(<CVXOPT>,<Problem>) perform(<CVXOPT>,<Problem>) solve_via_data(<CVXOPT>)

An interface for the CVXOPT solver.

CVXR-package

CVXR: Disciplined Convex Optimization in R

CallbackParam() value(<CallbackParam>)

The CallbackParam class.

expr(<Canonical>) id(<Canonical>) canonical_form(<Canonical>) variables(<Canonical>) parameters(<Canonical>) constants(<Canonical>) atoms(<Canonical>) get_data(<Canonical>)

The Canonical class.

perform(<Canonicalization>,<Problem>) invert(<Canonicalization>,<Solution>,<InverseData>) canonicalize_tree(<Canonicalization>) canonicalize_expr(<Canonicalization>)

The Canonicalization class.

as.character(<Chain>) accepts(<Chain>,<Problem>) perform(<Chain>,<Problem>) invert(<Chain>,<SolutionORList>,<list>)

The Chain class.

accepts(<Complex2Real>,<Problem>) perform(<Complex2Real>,<Problem>) invert(<Complex2Real>,<Solution>,<InverseData>)

Lifts complex numbers to a real representation.

Complex2Real.abs_canon()

Complex canonicalizer for the absolute value atom

Complex2Real.add()

Helper function to sum arguments.

Complex2Real.at_least_2D()

Upcast 0D and 1D to 2D.

Complex2Real.binary_canon()

Complex canonicalizer for the binary atom

Complex2Real.canonicalize_expr()

Canonicalizes a Complex Expression

Complex2Real.canonicalize_tree()

Recursively Canonicalizes a Complex Expression.

Complex2Real.conj_canon()

Complex canonicalizer for the conjugate atom

Complex2Real.constant_canon()

Complex canonicalizer for the constant atom

Complex2Real.hermitian_canon()

Complex canonicalizer for the hermitian atom

Complex2Real.imag_canon()

Complex canonicalizer for the imaginary atom

Complex2Real.join()

Helper function to combine arguments.

Complex2Real.lambda_sum_largest_canon()

Complex canonicalizer for the largest sum atom

Complex2Real.matrix_frac_canon()

Complex canonicalizer for the matrix fraction atom

Complex2Real.nonpos_canon()

Complex canonicalizer for the non-positive atom

Complex2Real.norm_nuc_canon()

Complex canonicalizer for the nuclear norm atom

Complex2Real.param_canon()

Complex canonicalizer for the parameter matrix atom

Complex2Real.pnorm_canon()

Complex canonicalizer for the p norm atom

Complex2Real.psd_canon()

Complex canonicalizer for the positive semidefinite atom

Complex2Real.quad_canon()

Complex canonicalizer for the quadratic atom

Complex2Real.quad_over_lin_canon()

Complex canonicalizer for the quadratic over linear term atom

Complex2Real.real_canon()

Complex canonicalizer for the real atom

Complex2Real.separable_canon()

Complex canonicalizer for the separable atom

Complex2Real.soc_canon()

Complex canonicalizer for the SOC atom

Complex2Real.variable_canon()

Complex canonicalizer for the variable atom

Complex2Real.zero_canon()

Complex canonicalizer for the zero atom

ConeDims-class

Summary of cone dimensions present in constraints.

accepts(<ConeMatrixStuffing>,<Problem>) stuffed_objective(<ConeMatrixStuffing>,<Problem>,<CoeffExtractor>)

Construct Matrices for Linear Cone Problems

accepts(<ConicSolver>,<Problem>) reduction_format_constr(<ConicSolver>) group_coeff_offset(<ConicSolver>) invert(<ConicSolver>,<Solution>,<InverseData>)

The ConicSolver class.

ConicSolver.get_coeff_offset()

Return the coefficient and offset in \(Ax + b\).

ConicSolver.get_spacing_matrix()

Returns a sparse matrix that spaces out an expression.

Conjugate() to_numeric(<Conjugate>) dim_from_args(<Conjugate>) is_incr(<Conjugate>) is_decr(<Conjugate>) is_symmetric(<Conjugate>) is_hermitian(<Conjugate>)

The Conjugate class.

Constant() show(<Constant>) name(<Constant>) constants(<Constant>) value(<Constant>) is_pos(<Constant>) grad(<Constant>) dim(<Constant>) canonicalize(<Constant>) is_nonneg(<Constant>) is_nonpos(<Constant>) is_imag(<Constant>) is_complex(<Constant>) is_symmetric(<Constant>) is_hermitian(<Constant>) is_psd(<Constant>) is_nsd(<Constant>) as.Constant()

The Constant class.

mip_capable(<ConstantSolver>) accepts(<ConstantSolver>,<Problem>) perform(<ConstantSolver>,<Problem>) invert(<ConstantSolver>,<Solution>,<list>) name(<ConstantSolver>) import_solver(<ConstantSolver>) is_installed(<ConstantSolver>) solve_via_data(<ConstantSolver>) reduction_solve(<ConstantSolver>,<ANY>)

The ConstantSolver class.

as.character(<Constraint>) dim(<Constraint>) size(<Constraint>) is_real(<Constraint>) is_imag(<Constraint>) is_complex(<Constraint>) is_dcp(<Constraint>) is_dgp(<Constraint>) residual(<Constraint>) violation(<Constraint>) constr_value(<Constraint>) get_data(<Constraint>) dual_value(<Constraint>) `dual_value<-`(<Constraint>) size(<ZeroConstraint>)

The Constraint class.

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

The Conv class.

CumMax() to_numeric(<CumMax>) .grad(<CumMax>) .column_grad(<CumMax>) dim_from_args(<CumMax>) sign_from_args(<CumMax>) get_data(<CumMax>) is_atom_convex(<CumMax>) is_atom_concave(<CumMax>) is_incr(<CumMax>) is_decr(<CumMax>)

The CumMax class.

CumSum() to_numeric(<CumSum>) dim_from_args(<CumSum>) get_data(<CumSum>) .grad(<CumSum>) graph_implementation(<CumSum>)

The CumSum class.

perform(<CvxAttr2Constr>,<Problem>) invert(<CvxAttr2Constr>,<Solution>,<list>)

The CvxAttr2Constr class.

accepts(<Dcp2Cone>,<Problem>) perform(<Dcp2Cone>,<Problem>)

Reduce DCP Problem to Conic Form

Dcp2Cone.entr_canon()

Dcp2Cone canonicalizer for the entropy atom

Dcp2Cone.exp_canon()

Dcp2Cone canonicalizer for the exponential atom

Dcp2Cone.geo_mean_canon()

Dcp2Cone canonicalizer for the geometric mean atom

Dcp2Cone.huber_canon()

Dcp2Cone canonicalizer for the huber atom

Dcp2Cone.indicator_canon()

Dcp2Cone canonicalizer for the indicator atom

Dcp2Cone.kl_div_canon()

Dcp2Cone canonicalizer for the KL Divergence atom

Dcp2Cone.lambda_max_canon()

Dcp2Cone canonicalizer for the lambda maximization atom

Dcp2Cone.lambda_sum_largest_canon()

Dcp2Cone canonicalizer for the largest lambda sum atom

Dcp2Cone.log1p_canon()

Dcp2Cone canonicalizer for the log 1p atom

Dcp2Cone.log_canon()

Dcp2Cone canonicalizer for the log atom

Dcp2Cone.log_det_canon()

Dcp2Cone canonicalizer for the log determinant atom

Dcp2Cone.log_sum_exp_canon()

Dcp2Cone canonicalizer for the log sum of the exp atom

Dcp2Cone.logistic_canon()

Dcp2Cone canonicalizer for the logistic function atom

Dcp2Cone.matrix_frac_canon()

Dcp2Cone canonicalizer for the matrix fraction atom

Dcp2Cone.normNuc_canon()

Dcp2Cone canonicalizer for the nuclear norm atom

Dcp2Cone.pnorm_canon()

Dcp2Cone canonicalizer for the p norm atom

Dcp2Cone.power_canon()

Dcp2Cone canonicalizer for the power atom

Dcp2Cone.quad_form_canon()

Dcp2Cone canonicalizer for the quadratic form atom

Dcp2Cone.quad_over_lin_canon()

Dcp2Cone canonicalizer for the quadratic over linear term atom

Dcp2Cone.sigma_max_canon()

Dcp2Cone canonicalizer for the sigma max atom

accepts(<Dgp2Dcp>,<Problem>) perform(<Dgp2Dcp>,<Problem>) canonicalize_expr(<Dgp2Dcp>) invert(<Dgp2Dcp>,<Solution>,<InverseData>)

Reduce DGP problems to DCP problems.

Dgp2Dcp.add_canon()

Dgp2Dcp canonicalizer for the addition atom

Dgp2Dcp.constant_canon()

Dgp2Dcp canonicalizer for the constant atom

Dgp2Dcp.div_canon()

Dgp2Dcp canonicalizer for the division atom

Dgp2Dcp.exp_canon()

Dgp2Dcp canonicalizer for the exp atom

Dgp2Dcp.eye_minus_inv_canon()

Dgp2Dcp canonicalizer for the (I - X)^-1 atom

Dgp2Dcp.geo_mean_canon()

Dgp2Dcp canonicalizer for the geometric mean atom

Dgp2Dcp.log_canon()

Dgp2Dcp canonicalizer for the log atom

Dgp2Dcp.mul_canon()

Dgp2Dcp canonicalizer for the multiplication atom

Dgp2Dcp.mulexpression_canon()

Dgp2Dcp canonicalizer for the multiplication expression atom

Dgp2Dcp.nonpos_constr_canon()

Dgp2Dcp canonicalizer for the non-positive constraint atom

Dgp2Dcp.norm1_canon()

Dgp2Dcp canonicalizer for the 1 norm atom

Dgp2Dcp.norm_inf_canon()

Dgp2Dcp canonicalizer for the infinite norm atom

Dgp2Dcp.one_minus_pos_canon()

Dgp2Dcp canonicalizer for the 1-x atom

Dgp2Dcp.parameter_canon()

Dgp2Dcp canonicalizer for the parameter atom

Dgp2Dcp.pf_eigenvalue_canon()

Dgp2Dcp canonicalizer for the spectral radius atom

Dgp2Dcp.pnorm_canon()

Dgp2Dcp canonicalizer for the p norm atom

Dgp2Dcp.power_canon()

Dgp2Dcp canonicalizer for the power atom

Dgp2Dcp.prod_canon()

Dgp2Dcp canonicalizer for the product atom

Dgp2Dcp.quad_form_canon()

Dgp2Dcp canonicalizer for the quadratic form atom

Dgp2Dcp.quad_over_lin_canon()

Dgp2Dcp canonicalizer for the quadratic over linear term atom

Dgp2Dcp.sum_canon()

Dgp2Dcp canonicalizer for the sum atom

Dgp2Dcp.trace_canon()

Dgp2Dcp canonicalizer for the trace atom

Dgp2Dcp.zero_constr_canon()

Dgp2Dcp canonicalizer for the zero constraint atom

names(<DgpCanonMethods>) `$`(<DgpCanonMethods>)

DGP canonical methods class.

Diag()

Turns an expression into a DiagVec object

DiagMat() to_numeric(<DiagMat>) dim_from_args(<DiagMat>) is_atom_log_log_convex(<DiagMat>) is_atom_log_log_concave(<DiagMat>) graph_implementation(<DiagMat>)

The DiagMat class.

DiagVec() to_numeric(<DiagVec>) dim_from_args(<DiagVec>) is_atom_log_log_convex(<DiagVec>) is_atom_log_log_concave(<DiagVec>) is_symmetric(<DiagVec>) is_hermitian(<DiagVec>) graph_implementation(<DiagVec>)

The DiagVec class.

Diff()

Takes the k-th order differences

DiffPos()

The DiffPos atom.

`/`(<Expression>,<Expression>) `/`(<Expression>,<ConstVal>) `/`(<ConstVal>,<Expression>) to_numeric(<DivExpression>) is_quadratic(<DivExpression>) is_qpwa(<DivExpression>) dim_from_args(<DivExpression>) is_atom_convex(<DivExpression>) is_atom_concave(<DivExpression>) is_atom_log_log_convex(<DivExpression>) is_atom_log_log_concave(<DivExpression>) is_incr(<DivExpression>) is_decr(<DivExpression>) graph_implementation(<DivExpression>)

The DivExpression class.

ECOS() mip_capable(<ECOS>) status_map(<ECOS>) import_solver(<ECOS>) name(<ECOS>) perform(<ECOS>,<Problem>) invert(<ECOS>,<list>,<list>)

An interface for the ECOS solver

ECOS.dims_to_solver_dict()

Utility method for formatting a ConeDims instance into a dictionary that can be supplied to ECOS.

ECOS_BB() mip_capable(<ECOS_BB>) name(<ECOS_BB>) perform(<ECOS_BB>,<Problem>) solve_via_data(<ECOS_BB>)

An interface for the ECOS BB solver.

dim_from_args(<Elementwise>) validate_args(<Elementwise>) is_symmetric(<Elementwise>)

The Elementwise class.

accepts(<EliminatePwl>,<Problem>)

The EliminatePwl class.

EliminatePwl.abs_canon()

EliminatePwl canonicalizer for the absolute atom

EliminatePwl.cummax_canon()

EliminatePwl canonicalizer for the cumulative max atom

EliminatePwl.cumsum_canon()

EliminatePwl canonicalizer for the cumulative sum atom

EliminatePwl.max_elemwise_canon()

EliminatePwl canonicalizer for the elementwise maximum atom

EliminatePwl.max_entries_canon()

EliminatePwl canonicalizer for the max entries atom

EliminatePwl.min_elemwise_canon()

EliminatePwl canonicalizer for the elementwise minimum atom

EliminatePwl.min_entries_canon()

EliminatePwl canonicalizer for the minimum entries atom

EliminatePwl.norm1_canon()

EliminatePwl canonicalizer for the 1 norm atom

EliminatePwl.norm_inf_canon()

EliminatePwl canonicalizer for the infinite norm atom

EliminatePwl.sum_largest_canon()

EliminatePwl canonicalizer for the largest sum atom

Entr() to_numeric(<Entr>) sign_from_args(<Entr>) is_atom_convex(<Entr>) is_atom_concave(<Entr>) is_incr(<Entr>) is_decr(<Entr>) .grad(<Entr>) .domain(<Entr>)

The Entr class.

`==`(<Expression>,<Expression>) `==`(<Expression>,<ConstVal>) `==`(<ConstVal>,<Expression>) name(<EqConstraint>) dim(<EqConstraint>) size(<EqConstraint>) expr(<EqConstraint>) is_dcp(<EqConstraint>) is_dgp(<EqConstraint>) residual(<EqConstraint>)

The EqConstraint class

perform(<EvalParams>,<Problem>) invert(<EvalParams>,<Solution>,<list>)

The EvalParams class.

Exp() to_numeric(<Exp>) sign_from_args(<Exp>) is_atom_convex(<Exp>) is_atom_concave(<Exp>) is_atom_log_log_convex(<Exp>) is_atom_log_log_concave(<Exp>) is_incr(<Exp>) is_decr(<Exp>) .grad(<Exp>)

The Exp class.

ExpCone() as.character(<ExpCone>) residual(<ExpCone>) size(<ExpCone>) num_cones(<ExpCone>) cone_sizes(<ExpCone>) is_dcp(<ExpCone>) is_dgp(<ExpCone>) canonicalize(<ExpCone>)

The ExpCone class.

value(<Expression>) grad(<Expression>) domain(<Expression>) as.character(<Expression>) name(<Expression>) expr(<Expression>) is_constant(<Expression>) is_affine(<Expression>) is_convex(<Expression>) is_concave(<Expression>) is_dcp(<Expression>) is_log_log_constant(<Expression>) is_log_log_affine(<Expression>) is_log_log_convex(<Expression>) is_log_log_concave(<Expression>) is_dgp(<Expression>) is_hermitian(<Expression>) is_psd(<Expression>) is_nsd(<Expression>) is_quadratic(<Expression>) is_symmetric(<Expression>) is_pwl(<Expression>) is_qpwa(<Expression>) is_zero(<Expression>) is_nonneg(<Expression>) is_nonpos(<Expression>) dim(<Expression>) is_real(<Expression>) is_imag(<Expression>) is_complex(<Expression>) size(<Expression>) ndim(<Expression>) flatten(<Expression>) is_scalar(<Expression>) is_vector(<Expression>) is_matrix(<Expression>) nrow(<Expression>) ncol(<Expression>)

The Expression class.

EyeMinusInv() to_numeric(<EyeMinusInv>) name(<EyeMinusInv>) dim_from_args(<EyeMinusInv>) sign_from_args(<EyeMinusInv>) is_atom_convex(<EyeMinusInv>) is_atom_concave(<EyeMinusInv>) is_atom_log_log_convex(<EyeMinusInv>) is_atom_log_log_concave(<EyeMinusInv>) is_incr(<EyeMinusInv>) is_decr(<EyeMinusInv>) .grad(<EyeMinusInv>)

The EyeMinusInv class.

perform(<FlipObjective>,<Problem>) invert(<FlipObjective>,<Solution>,<list>)

The FlipObjective class.

GLPK() mip_capable(<GLPK>) status_map(<GLPK>) name(<GLPK>) import_solver(<GLPK>) invert(<GLPK>,<list>,<list>) solve_via_data(<GLPK>)

An interface for the GLPK solver.

GLPK_MI() mip_capable(<GLPK_MI>) status_map(<GLPK_MI>) name(<GLPK_MI>) solve_via_data(<GLPK_MI>)

An interface for the GLPK MI solver.

GUROBI_CONIC() mip_capable(<GUROBI_CONIC>) name(<GUROBI_CONIC>) import_solver(<GUROBI_CONIC>) status_map(<GUROBI_CONIC>) accepts(<GUROBI_CONIC>,<Problem>) perform(<GUROBI_CONIC>,<Problem>) invert(<GUROBI_CONIC>,<list>,<list>) solve_via_data(<GUROBI_CONIC>)

An interface for the GUROBI conic solver.

GUROBI_QP() mip_capable(<GUROBI_QP>) status_map(<GUROBI_QP>) name(<GUROBI_QP>) import_solver(<GUROBI_QP>) solve_via_data(<GUROBI_QP>) invert(<GUROBI_QP>,<list>,<InverseData>)

An interface for the GUROBI_QP solver.

GeoMean() to_numeric(<GeoMean>) .domain(<GeoMean>) .grad(<GeoMean>) name(<GeoMean>) dim_from_args(<GeoMean>) sign_from_args(<GeoMean>) is_atom_convex(<GeoMean>) is_atom_concave(<GeoMean>) is_atom_log_log_convex(<GeoMean>) is_atom_log_log_concave(<GeoMean>) is_incr(<GeoMean>) is_decr(<GeoMean>) get_data(<GeoMean>) copy(<GeoMean>)

The GeoMean class.

HStack() to_numeric(<HStack>) dim_from_args(<HStack>) is_atom_log_log_convex(<HStack>) is_atom_log_log_concave(<HStack>) validate_args(<HStack>) graph_implementation(<HStack>)

The HStack class.

HarmonicMean()

The HarmonicMean atom.

Huber() to_numeric(<Huber>) sign_from_args(<Huber>) is_atom_convex(<Huber>) is_atom_concave(<Huber>) is_incr(<Huber>) is_decr(<Huber>) is_quadratic(<Huber>) get_data(<Huber>) validate_args(<Huber>) .grad(<Huber>)

The Huber class.

Imag() to_numeric(<Imag>) dim_from_args(<Imag>) is_imag(<Imag>) is_complex(<Imag>) is_symmetric(<Imag>)

The Imag class.

`[`(<Expression>,<missing>,<missing>,<ANY>) `[`(<Expression>,<numeric>,<missing>,<ANY>) `[`(<Expression>,<missing>,<numeric>,<ANY>) `[`(<Expression>,<numeric>,<numeric>,<ANY>) Index() to_numeric(<Index>) dim_from_args(<Index>) is_atom_log_log_convex(<Index>) is_atom_log_log_concave(<Index>) get_data(<Index>) graph_implementation(<Index>) to_numeric(<SpecialIndex>) dim_from_args(<SpecialIndex>)

The Index 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>) name(<IneqConstraint>) dim(<IneqConstraint>) size(<IneqConstraint>) expr(<IneqConstraint>) is_dcp(<IneqConstraint>) is_dgp(<IneqConstraint>) residual(<IneqConstraint>)

The IneqConstraint class

InverseData-class

The InverseData class.

KLDiv() to_numeric(<KLDiv>) sign_from_args(<KLDiv>) is_atom_convex(<KLDiv>) is_atom_concave(<KLDiv>) is_incr(<KLDiv>) is_decr(<KLDiv>) .grad(<KLDiv>) .domain(<KLDiv>)

The KLDiv class.

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

The Kron class.

LambdaMax() to_numeric(<LambdaMax>) .domain(<LambdaMax>) .grad(<LambdaMax>) validate_args(<LambdaMax>) dim_from_args(<LambdaMax>) sign_from_args(<LambdaMax>) is_atom_convex(<LambdaMax>) is_atom_concave(<LambdaMax>) is_incr(<LambdaMax>) is_decr(<LambdaMax>)

The LambdaMax class.

LambdaMin()

The LambdaMin atom.

LambdaSumLargest() allow_complex(<LambdaSumLargest>) to_numeric(<LambdaSumLargest>) validate_args(<LambdaSumLargest>) get_data(<LambdaSumLargest>) .grad(<LambdaSumLargest>)

The LambdaSumLargest class.

LambdaSumSmallest()

The LambdaSumSmallest atom.

get_data(<Leaf>) dim(<Leaf>) variables(<Leaf>) parameters(<Leaf>) constants(<Leaf>) atoms(<Leaf>) is_convex(<Leaf>) is_concave(<Leaf>) is_log_log_convex(<Leaf>) is_log_log_concave(<Leaf>) is_nonneg(<Leaf>) is_nonpos(<Leaf>) is_pos(<Leaf>) is_neg(<Leaf>) is_hermitian(<Leaf>) is_symmetric(<Leaf>) is_imag(<Leaf>) is_complex(<Leaf>) domain(<Leaf>) project(<Leaf>) project_and_assign(<Leaf>) value(<Leaf>) `value<-`(<Leaf>) validate_val(<Leaf>) is_psd(<Leaf>) is_nsd(<Leaf>) is_quadratic(<Leaf>) is_pwl(<Leaf>)

The Leaf class.

id(<ListORConstr>)

A Class Union of List and Constraint

Log() to_numeric(<Log>) sign_from_args(<Log>) is_atom_convex(<Log>) is_atom_concave(<Log>) is_atom_log_log_convex(<Log>) is_atom_log_log_concave(<Log>) is_incr(<Log>) is_decr(<Log>) .grad(<Log>) .domain(<Log>)

The Log class.

Log1p() to_numeric(<Log1p>) sign_from_args(<Log1p>) .grad(<Log1p>) .domain(<Log1p>)

The Log1p class.

LogDet() to_numeric(<LogDet>) validate_args(<LogDet>) dim_from_args(<LogDet>) sign_from_args(<LogDet>) is_atom_convex(<LogDet>) is_atom_concave(<LogDet>) is_incr(<LogDet>) is_decr(<LogDet>) .grad(<LogDet>) .domain(<LogDet>)

The LogDet class.

LogSumExp() to_numeric(<LogSumExp>) .grad(<LogSumExp>) .column_grad(<LogSumExp>) sign_from_args(<LogSumExp>) is_atom_convex(<LogSumExp>) is_atom_concave(<LogSumExp>) is_incr(<LogSumExp>) is_decr(<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>) .grad(<Logistic>)

The Logistic class.

MOSEK() mip_capable(<MOSEK>) import_solver(<MOSEK>) name(<MOSEK>) accepts(<MOSEK>,<Problem>) block_format(<MOSEK>) perform(<MOSEK>,<Problem>) solve_via_data(<MOSEK>) invert(<MOSEK>,<ANY>,<ANY>)

An interface for the MOSEK solver.

MOSEK.parse_dual_vars()

Parses MOSEK dual variables into corresponding CVXR constraints and dual values

MOSEK.recover_dual_variables()

Recovers MOSEK solutions dual variables

MatrixFrac() allow_complex(<MatrixFrac>) to_numeric(<MatrixFrac>) validate_args(<MatrixFrac>) dim_from_args(<MatrixFrac>) sign_from_args(<MatrixFrac>) is_atom_convex(<MatrixFrac>) is_atom_concave(<MatrixFrac>) is_incr(<MatrixFrac>) is_decr(<MatrixFrac>) is_quadratic(<MatrixFrac>) is_qpwa(<MatrixFrac>) .domain(<MatrixFrac>) .grad(<MatrixFrac>)

The MatrixFrac class.

perform(<MatrixStuffing>,<Problem>) invert(<MatrixStuffing>,<Solution>,<InverseData>)

The MatrixStuffing class.

MaxElemwise() to_numeric(<MaxElemwise>) sign_from_args(<MaxElemwise>) is_atom_convex(<MaxElemwise>) is_atom_concave(<MaxElemwise>) is_atom_log_log_convex(<MaxElemwise>) is_atom_log_log_concave(<MaxElemwise>) is_incr(<MaxElemwise>) is_decr(<MaxElemwise>) is_pwl(<MaxElemwise>) .grad(<MaxElemwise>)

The MaxElemwise class.

MaxEntries() to_numeric(<MaxEntries>) sign_from_args(<MaxEntries>) is_atom_convex(<MaxEntries>) is_atom_concave(<MaxEntries>) is_atom_log_log_convex(<MaxEntries>) is_atom_log_log_concave(<MaxEntries>) is_incr(<MaxEntries>) is_decr(<MaxEntries>) is_pwl(<MaxEntries>) .grad(<MaxEntries>) .column_grad(<MaxEntries>)

The MaxEntries class.

Maximize() canonicalize(<Maximize>) is_dcp(<Maximize>) is_dgp(<Maximize>)

The Maximize class.

MinElemwise() to_numeric(<MinElemwise>) sign_from_args(<MinElemwise>) is_atom_convex(<MinElemwise>) is_atom_concave(<MinElemwise>) is_atom_log_log_convex(<MinElemwise>) is_atom_log_log_concave(<MinElemwise>) is_incr(<MinElemwise>) is_decr(<MinElemwise>) is_pwl(<MinElemwise>) .grad(<MinElemwise>)

The MinElemwise class.

MinEntries() to_numeric(<MinEntries>) sign_from_args(<MinEntries>) is_atom_convex(<MinEntries>) is_atom_concave(<MinEntries>) is_atom_log_log_convex(<MinEntries>) is_atom_log_log_concave(<MinEntries>) is_incr(<MinEntries>) is_decr(<MinEntries>) is_pwl(<MinEntries>) .grad(<MinEntries>) .column_grad(<MinEntries>)

The MinEntries class.

Minimize() canonicalize(<Minimize>) is_dcp(<Minimize>) is_dgp(<Minimize>)

The Minimize class.

MixedNorm()

The MixedNorm atom.

`%*%`(<Expression>,<Expression>) `%*%`(<Expression>,<ConstVal>) `%*%`(<ConstVal>,<Expression>) to_numeric(<MulExpression>) dim_from_args(<MulExpression>) is_atom_convex(<MulExpression>) is_atom_concave(<MulExpression>) is_atom_log_log_convex(<MulExpression>) is_atom_log_log_concave(<MulExpression>) is_incr(<MulExpression>) is_decr(<MulExpression>) .grad(<MulExpression>) graph_implementation(<MulExpression>)

The MulExpression class.

Multiply() to_numeric(<Multiply>) dim_from_args(<Multiply>) is_atom_log_log_convex(<Multiply>) is_atom_log_log_concave(<Multiply>) is_psd(<Multiply>) is_nsd(<Multiply>) graph_implementation(<Multiply>)

The Multiply class.

Neg()

An alias for -MinElemwise(x, 0)

`-`(<Expression>,<missing>) `-`(<Expression>,<Expression>) `-`(<Expression>,<ConstVal>) `-`(<ConstVal>,<Expression>) dim_from_args(<NegExpression>) sign_from_args(<NegExpression>) is_incr(<NegExpression>) is_decr(<NegExpression>) is_symmetric(<NegExpression>) is_hermitian(<NegExpression>) graph_implementation(<NegExpression>)

The NegExpression class.

name(<NonPosConstraint>) is_dcp(<NonPosConstraint>) is_dgp(<NonPosConstraint>) canonicalize(<NonPosConstraint>) residual(<NonPosConstraint>)

The NonPosConstraint class

NonlinearConstraint()

The NonlinearConstraint class.

Norm()

The Norm atom.

Norm1() name(<Norm1>) to_numeric(<Norm1>) allow_complex(<Norm1>) sign_from_args(<Norm1>) is_atom_convex(<Norm1>) is_atom_concave(<Norm1>) is_incr(<Norm1>) is_decr(<Norm1>) is_pwl(<Norm1>) get_data(<Norm1>) .domain(<Norm1>) .grad(<Norm1>) .column_grad(<Norm1>)

The Norm1 class.

Norm2()

The Norm2 atom.

name(<NormInf>) to_numeric(<NormInf>) allow_complex(<NormInf>) sign_from_args(<NormInf>) is_atom_convex(<NormInf>) is_atom_concave(<NormInf>) is_atom_log_log_convex(<NormInf>) is_atom_log_log_concave(<NormInf>) is_incr(<NormInf>) is_decr(<NormInf>) is_pwl(<NormInf>) get_data(<NormInf>) .domain(<NormInf>) .grad(<NormInf>) .column_grad(<NormInf>)

The NormInf class.

NormNuc() to_numeric(<NormNuc>) allow_complex(<NormNuc>) dim_from_args(<NormNuc>) sign_from_args(<NormNuc>) is_atom_convex(<NormNuc>) is_atom_concave(<NormNuc>) is_incr(<NormNuc>) is_decr(<NormNuc>) .grad(<NormNuc>)

The NormNuc class.

OSQP() status_map(<OSQP>) name(<OSQP>) import_solver(<OSQP>) invert(<OSQP>,<list>,<InverseData>) solve_via_data(<OSQP>)

An interface for the OSQP solver.

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

Arithmetic Operations on Objectives

Objective() value(<Objective>) is_quadratic(<Objective>) is_qpwa(<Objective>)

The Objective class.

OneMinusPos() name(<OneMinusPos>) to_numeric(<OneMinusPos>) dim_from_args(<OneMinusPos>) sign_from_args(<OneMinusPos>) is_atom_convex(<OneMinusPos>) is_atom_concave(<OneMinusPos>) is_atom_log_log_convex(<OneMinusPos>) is_atom_log_log_concave(<OneMinusPos>) is_incr(<OneMinusPos>) is_decr(<OneMinusPos>) .grad(<OneMinusPos>)

The OneMinusPos class.

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

The PSDConstraint class.

PSDWrap() is_psd(<PSDWrap>)

The PSDWrap class.

Parameter() get_data(<Parameter>) name(<Parameter>) value(<Parameter>) `value<-`(<Parameter>) grad(<Parameter>) parameters(<Parameter>) canonicalize(<Parameter>)

The Parameter class.

PfEigenvalue() name(<PfEigenvalue>) to_numeric(<PfEigenvalue>) dim_from_args(<PfEigenvalue>) sign_from_args(<PfEigenvalue>) is_atom_convex(<PfEigenvalue>) is_atom_concave(<PfEigenvalue>) is_atom_log_log_convex(<PfEigenvalue>) is_atom_log_log_concave(<PfEigenvalue>) is_incr(<PfEigenvalue>) is_decr(<PfEigenvalue>) .grad(<PfEigenvalue>)

The PfEigenvalue class.

Pnorm() allow_complex(<Pnorm>) to_numeric(<Pnorm>) validate_args(<Pnorm>) sign_from_args(<Pnorm>) is_atom_convex(<Pnorm>) is_atom_concave(<Pnorm>) is_atom_log_log_convex(<Pnorm>) is_atom_log_log_concave(<Pnorm>) is_incr(<Pnorm>) is_decr(<Pnorm>) is_pwl(<Pnorm>) get_data(<Pnorm>) name(<Pnorm>) .domain(<Pnorm>) .grad(<Pnorm>) .column_grad(<Pnorm>)

The Pnorm class.

Pos()

An alias for MaxElemwise(x, 0)

Power() to_numeric(<Power>) sign_from_args(<Power>) is_atom_convex(<Power>) is_atom_concave(<Power>) is_atom_log_log_convex(<Power>) is_atom_log_log_concave(<Power>) is_constant(<Power>) is_incr(<Power>) is_decr(<Power>) is_quadratic(<Power>) is_qpwa(<Power>) .grad(<Power>) .domain(<Power>) get_data(<Power>) copy(<Power>) name(<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>) status(<Problem>) is_dcp(<Problem>) is_dgp(<Problem>) is_qp(<Problem>) canonicalize(<Problem>) is_mixed_integer(<Problem>) variables(<Problem>) parameters(<Problem>) constants(<Problem>) atoms(<Problem>) size_metrics(<Problem>) solver_stats(<Problem>) `solver_stats<-`(<Problem>) get_problem_data(<Problem>,<character>,<logical>) get_problem_data(<Problem>,<character>,<missing>) unpack_results(<Problem>)

The Problem class.

ProdEntries() to_numeric(<ProdEntries>) sign_from_args(<ProdEntries>) is_atom_convex(<ProdEntries>) is_atom_concave(<ProdEntries>) is_atom_log_log_convex(<ProdEntries>) is_atom_log_log_concave(<ProdEntries>) is_incr(<ProdEntries>) is_decr(<ProdEntries>) .column_grad(<ProdEntries>) .grad(<ProdEntries>)

The ProdEntries class.

Promote() to_numeric(<Promote>) is_symmetric(<Promote>) dim_from_args(<Promote>) is_atom_log_log_convex(<Promote>) is_atom_log_log_concave(<Promote>) get_data(<Promote>) graph_implementation(<Promote>)

The Promote class.

Qp2SymbolicQp-class

The Qp2SymbolicQp class.

QpMatrixStuffing-class

The QpMatrixStuffing class.

accepts(<QpSolver>,<Problem>) perform(<QpSolver>,<Problem>)

A QP solver interface.

QuadForm() name(<QuadForm>) allow_complex(<QuadForm>) to_numeric(<QuadForm>) validate_args(<QuadForm>) sign_from_args(<QuadForm>) dim_from_args(<QuadForm>) is_atom_convex(<QuadForm>) is_atom_concave(<QuadForm>) is_atom_log_log_convex(<QuadForm>) is_atom_log_log_concave(<QuadForm>) is_incr(<QuadForm>) is_decr(<QuadForm>) is_quadratic(<QuadForm>) is_pwl(<QuadForm>) .grad(<QuadForm>)

The QuadForm class.

QuadOverLin() allow_complex(<QuadOverLin>) to_numeric(<QuadOverLin>) validate_args(<QuadOverLin>) dim_from_args(<QuadOverLin>) sign_from_args(<QuadOverLin>) is_atom_convex(<QuadOverLin>) is_atom_concave(<QuadOverLin>) is_atom_log_log_convex(<QuadOverLin>) is_atom_log_log_concave(<QuadOverLin>) is_incr(<QuadOverLin>) is_decr(<QuadOverLin>) is_quadratic(<QuadOverLin>) is_qpwa(<QuadOverLin>) .domain(<QuadOverLin>) .grad(<QuadOverLin>)

The QuadOverLin 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.

Real() to_numeric(<Real>) dim_from_args(<Real>) is_imag(<Real>) is_complex(<Real>) is_symmetric(<Real>)

The Real class.

accepts(<Reduction>,<Problem>) reduce(<Reduction>) retrieve(<Reduction>,<Solution>) perform(<Reduction>,<Problem>) invert(<Reduction>,<Solution>,<list>)

The Reduction class.

mip_capable(<ReductionSolver>) name(<ReductionSolver>) import_solver(<ReductionSolver>) is_installed(<ReductionSolver>) solve_via_data(<ReductionSolver>) reduction_solve(<ReductionSolver>,<ANY>) solve_via_data(<ECOS>)

The ReductionSolver class.

Reshape() to_numeric(<Reshape>) validate_args(<Reshape>) dim_from_args(<Reshape>) is_atom_log_log_convex(<Reshape>) is_atom_log_log_concave(<Reshape>) get_data(<Reshape>) graph_implementation(<Reshape>)

The Reshape class.

SCS() mip_capable(<SCS>) status_map(<SCS>) name(<SCS>) import_solver(<SCS>) reduction_format_constr(<SCS>) perform(<SCS>,<Problem>) invert(<SCS>,<list>,<list>) solve_via_data(<SCS>)

An interface for the SCS solver

SCS.dims_to_solver_dict()

Utility method for formatting a ConeDims instance into a dictionary that can be supplied to SCS.

SCS.extract_dual_value()

Extracts the dual value for constraint starting at offset.

SOC() as.character(<SOC>) residual(<SOC>) get_data(<SOC>) format_constr(<SOC>) num_cones(<SOC>) size(<SOC>) cone_sizes(<SOC>) is_dcp(<SOC>) is_dgp(<SOC>) canonicalize(<SOC>)

The SOC class.

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

The SOCAxis class.

SigmaMax() to_numeric(<SigmaMax>) allow_complex(<SigmaMax>) dim_from_args(<SigmaMax>) sign_from_args(<SigmaMax>) is_atom_convex(<SigmaMax>) is_atom_concave(<SigmaMax>) is_incr(<SigmaMax>) is_decr(<SigmaMax>) .grad(<SigmaMax>)

The SigmaMax class.

SizeMetrics()

The SizeMetrics class.

as.character(<Solution>)

The Solution class.

SolverStats()

The SolverStats class.

prepend(<SolvingChain>,<Chain>) reduction_solve(<SolvingChain>,<Problem>) reduction_solve_via_data(<SolvingChain>)

The SolvingChain class.

`[`(<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>) SpecialIndex() name(<SpecialIndex>) is_atom_log_log_convex(<SpecialIndex>) is_atom_log_log_concave(<SpecialIndex>) get_data(<SpecialIndex>) .grad(<SpecialIndex>)

The SpecialIndex class.

SumEntries() to_numeric(<SumEntries>) is_atom_log_log_convex(<SumEntries>) is_atom_log_log_concave(<SumEntries>) graph_implementation(<SumEntries>)

The SumEntries class.

SumLargest() to_numeric(<SumLargest>) validate_args(<SumLargest>) dim_from_args(<SumLargest>) sign_from_args(<SumLargest>) is_atom_convex(<SumLargest>) is_atom_concave(<SumLargest>) is_incr(<SumLargest>) is_decr(<SumLargest>) get_data(<SumLargest>) .grad(<SumLargest>)

The SumLargest class.

SumSmallest()

The SumSmallest atom.

SumSquares()

The SumSquares atom.

SymbolicQuadForm() dim_from_args(<SymbolicQuadForm>) sign_from_args(<SymbolicQuadForm>) get_data(<SymbolicQuadForm>) is_atom_convex(<SymbolicQuadForm>) is_atom_concave(<SymbolicQuadForm>) is_incr(<SymbolicQuadForm>) is_decr(<SymbolicQuadForm>) is_quadratic(<SymbolicQuadForm>) .grad(<SymbolicQuadForm>)

The SymbolicQuadForm class.

TotalVariation()

The TotalVariation atom.

Trace() to_numeric(<Trace>) validate_args(<Trace>) dim_from_args(<Trace>) is_atom_log_log_convex(<Trace>) is_atom_log_log_concave(<Trace>) graph_implementation(<Trace>)

The Trace class.

to_numeric(<Transpose>) is_symmetric(<Transpose>) is_hermitian(<Transpose>) dim_from_args(<Transpose>) is_atom_log_log_convex(<Transpose>) is_atom_log_log_concave(<Transpose>) get_data(<Transpose>) graph_implementation(<Transpose>)

The Transpose class.

name(<UnaryOperator>) to_numeric(<UnaryOperator>)

The UnaryOperator class.

UpperTri() to_numeric(<UpperTri>) validate_args(<UpperTri>) dim_from_args(<UpperTri>) is_atom_log_log_convex(<UpperTri>) is_atom_log_log_concave(<UpperTri>) graph_implementation(<UpperTri>)

The UpperTri class.

VStack() to_numeric(<VStack>) validate_args(<VStack>) dim_from_args(<VStack>) is_atom_log_log_convex(<VStack>) is_atom_log_log_concave(<VStack>) graph_implementation(<VStack>)

The VStack class.

Variable() as.character(<Variable>) name(<Variable>) value(<Variable>) grad(<Variable>) variables(<Variable>) canonicalize(<Variable>)

The Variable class.

to_numeric(<Wrap>) dim_from_args(<Wrap>) is_atom_log_log_convex(<Wrap>) is_atom_log_log_concave(<Wrap>) graph_implementation(<Wrap>)

The Wrap class.

name(<ZeroConstraint>) dim(<ZeroConstraint>) is_dcp(<ZeroConstraint>) is_dgp(<ZeroConstraint>) residual(<ZeroConstraint>) canonicalize(<ZeroConstraint>)

The ZeroConstraint class

abs(<Expression>)

Absolute Value

accepts()

Reduction Acceptance

are_args_affine()

Are the arguments affine?

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)

Re(<Expression>) Im(<Expression>) Conj(<Expression>)

Complex Numbers

is_real() is_imag() is_complex()

Complex Properties

num_cones() cone_sizes()

Second-Order Cone Methods

constr_value()

Is Constraint Violated?

construct_intermediate_chain(<Problem>,<list>)

Builds a chain that rewrites a problem into an intermediate representation suitable for numeric reductions.

construct_solving_chain()

Build a reduction chain from a problem to an installed solver.

conv()

Discrete Convolution

cummax_axis() cummax(<Expression>)

Cumulative Maximum

cumsum_axis() cumsum(<Expression>)

Cumulative Sum

is_atom_convex() is_atom_concave() is_atom_affine() is_atom_log_log_convex(<Atom>) is_atom_log_log_concave(<Atom>) is_atom_log_log_affine(<Atom>)

Curvature of an Atom

is_incr() is_decr()

Curvature of Composition

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

Curvature Properties

curvature()

Curvature of Expression

cvxr_norm()

Matrix Norm (Alternative)

diag(<Expression>)

Matrix Diagonal

diff(<Expression>)

Lagged and Iterated Differences

dim_from_args()

Atom Dimensions

domain()

Domain

.LinOpVector__new()

Create a new LinOpVector object.

.LinOpVector__push_back()

Perform a push back operation on the args field of LinOp

.LinOp__args_push_back()

Perform a push back operation on the args field of LinOp

.LinOp__get_dense_data()

Get the field dense_data for the LinOp object

.LinOp__get_id()

Get the id field of the LinOp Object

.LinOp__get_size()

Get the field size for the LinOp object

.LinOp__get_slice()

Get the slice field of the LinOp Object

.LinOp__get_sparse()

Get the sparse flag field for the LinOp object

.LinOp__get_sparse_data()

Get the field named sparse_data from the LinOp object

.LinOp__get_type()

Get the field named type for the LinOp object

.LinOp__new()

Create a new LinOp object.

.LinOp__set_dense_data()

Set the field dense_data of the LinOp object

.LinOp__set_size()

Set the field size of the LinOp object

.LinOp__set_slice()

Set the slice field of the LinOp Object

.LinOp__set_sparse()

Set the flag sparse of the LinOp object

.LinOp__set_sparse_data()

Set the field named sparse_data of the LinOp object

.LinOp__set_type()

Set the field named type for the LinOp object

.LinOp__size_push_back()

Perform a push back operation on the size field of LinOp

.LinOp__slice_push_back()

Perform a push back operation on the slice field of LinOp

.LinOp_at_index()

Return the LinOp element at index i (0-based)

.ProblemData__get_I()

Get the I field of the ProblemData Object

.ProblemData__get_J()

Get the J field of the ProblemData Object

.ProblemData__get_V()

Get the V field of the ProblemData Object

.ProblemData__get_const_to_row()

Get the const_to_row field of the ProblemData Object

.ProblemData__get_const_vec()

Get the const_vec field from the ProblemData Object

.ProblemData__get_id_to_col()

Get the id_to_col field of the ProblemData Object

.ProblemData__new()

Create a new ProblemData object.

.ProblemData__set_I()

Set the I field in the ProblemData Object

.ProblemData__set_J()

Set the J field in the ProblemData Object

.ProblemData__set_V()

Set the V field in the ProblemData Object

.ProblemData__set_const_to_row()

Set the const_to_row map of the ProblemData Object

.ProblemData__set_const_vec()

Set the const_vec field in the ProblemData Object

.ProblemData__set_id_to_col()

Set the id_to_col field of the ProblemData Object

.build_matrix_0()

Get the sparse flag field for the LinOp object

.build_matrix_1()

Get the sparse flag field for the LinOp object

.decomp_quad()

Compute a Matrix Decomposition.

.p_norm()

Internal method for calculating the p-norm

dspop

Direct Standardization: Population

dssamp

Direct Standardization: Sample

dual_value() `dual_value<-`()

Get and Set Dual Value

entr()

Entropy Function

exp(<Expression>)

Natural Exponential

variables() parameters() constants() atoms()

Parts of an Expression Leaf

extract_dual_value()

Gets a specified value of a dual variable.

extract_mip_idx()

Coalesces bool, int indices for variables.

eye_minus_inv()

Unity Resolvent

format_constr()

Format Constraints

geo_mean()

Geometric Mean

get_data()

Get Expression Data

get_dual_values()

Gets the values of the dual variables.

get_id()

Get ID

get_np()

Get numpy handle

get_problem_data()

Get Problem Data

get_sp()

Get scipy handle

grad()

Sub/Super-Gradient

graph_implementation()

Graph Implementation

group_constraints()

Organize the constraints into a dictionary keyed by constraint names.

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

invert()

Return Original Solution

is_dcp()

DCP Compliance

is_dgp()

DGP Compliance

is_mixed_integer()

Is Problem Mixed Integer?

is_qp()

Is Problem a QP?

is_stuffed_cone_constraint()

Is the constraint a stuffed cone constraint?

is_stuffed_cone_objective()

Is the objective a stuffed cone objective?

is_stuffed_qp_objective()

Is the QP objective stuffed?

kl_div()

Kullback-Leibler Divergence

kronecker(<Expression>,<ANY>) kronecker(<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

is_pos() is_neg()

Attributes of an Expression Leaf

linearize()

Affine Approximation to an Expression

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

Logarithms

log_det()

Log-Determinant

is_atom_log_log_convex() is_atom_log_log_concave() is_atom_log_log_affine()

Log-Log Curvature of an Atom

is_log_log_constant() is_log_log_affine() is_log_log_convex() is_log_log_concave()

Log-Log Curvature Properties

log_log_curvature()

Log-Log Curvature of Expression

log_sum_exp()

Log-Sum-Exponential

logistic()

Logistic Function

matrix_frac()

Matrix Fraction

is_psd() is_nsd() is_hermitian() is_symmetric()

Matrix Properties

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

mip_capable()

Solver Capabilities

mixed_norm()

Mixed Norm

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

Elementwise multiplication operator

multiply()

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

one_minus_pos()

Difference on Restricted Domain

p_norm()

P-Norm

perform()

Perform Reduction

pf_eigenvalue()

Perron-Frobenius Eigenvalue

pos()

Elementwise Positive

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

Elementwise Power

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

Parts of a Problem

prod_entries() prod(<Expression>)

Product of Entries

project() project_and_assign()

Project Value

psd_coeff_offset()

Given a problem returns a PSD constrain

psolve() solve(<Problem>,<ANY>)

Solve a DCP Problem

quad_form()

Quadratic Form

quad_over_lin()

Quadratic over Linear

reduce()

Reduce a Problem

resetOptions()

Reset Options

reshape_expr()

Reshape an Expression

residual() violation()

Constraint Residual

retrieve()

Retrieve Solution

scaled_lower_tri()

Utility methods for special handling of semidefinite constraints.

scalene()

Scalene Function

setIdCounter()

Set ID Counter

sigma_max()

Maximum Singular Value

is_zero() is_nonneg() is_nonpos()

Sign Properties

sign(<Expression>)

Sign of Expression

sign_from_args()

Atom Sign

is_scalar() is_vector() is_matrix()

Size Properties

size()

Size of Expression

sqrt(<Expression>)

Square Root

square(<Expression>)

Square

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

tri_to_full()

Expands lower triangular to full matrix.

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_val()

Validate Value

value() `value<-`()

Get or Set Value

vec()

Vectorization of a Matrix

vectorized_lower_tri_to_mat()

Turns symmetric 2D array into a lower triangular matrix

vstack()

Vertical Concatenation