C++ API Reference

The Cardinal Optimizer provides C++ API library. This chapter documents all COPT constants, including parameters and attributes, and API functions for C++ applications.

Constants

All C++ constants are the same as C constants. Please refer to C API Reference: Constants for more details.

Attributes

All C++ attributes are the same as C attributes. Please refer to C API Reference: Attributes for more details.

In the C++ API, user can get the attribute value by specifying the attribute name. The provided functions are as follows, please refer to C++ API: Model Class for details.

• Model::GetIntAttr() : Get value of a COPT integer attribute.

• Model::GetDblAttr() : Get value of a COPT double attribute.

Parameters

All C++ parameters are the same as C parameters. Please refer to C API Reference: Parameters for more details.

In the C++ API, user can get and set the parameter value by specifying the parameter name. The provided functions are as follows, please refer to C++ Model class for details.

• Get detailed information of the specified parameter (current value/max/min): Model::GetParamInfo()

• Get the current value of the specified integer/double parameter: Model::GetIntParam() / Model::GetDblParam()

• Set the specified integer/double parameter value: Model::SetIntParam() / Model::SetDblParam()

C++ Modeling Classes

This chapter documents COPT C++ interface. Users may refer to C++ classes described below for details of how to construct and solve C++ models.

Envr

Essentially, any C++ application using Cardinal Optimizer should start with a COPT environment. COPT models are always associated with a COPT environment. User must create an environment object before populating models. User generally only need a single environment object in program.

• Envr::Envr()
• Envr::Envr()
• Envr::Envr()
• Envr::Close()
• Envr::CreateModel()

EnvrConfig

If user connects to COPT remote services, such as floating token server or compute cluster, it is necessary to add config settings with EnvrConfig object.

• EnvrConfig::EnvrConfig()
• EnvrConfig::Set()

Model

In general, a COPT model consists of a set of variables, a (linear) objective function on these variables, a set of constraints on there varaibles, etc. COPT model class encapsulates all required methods for constructing a COPT model.

• Model::AddCone()
• Model::AddCone()
• Model::AddCone()
• Model::AddConstr()
• Model::AddConstr()
• Model::AddConstr()
• Model::AddConstr()
• Model::AddConstrs()
• Model::AddConstrs()
• Model::AddConstrs()
• Model::AddConstrs()
• Model::AddConstrs()
• Model::AddDenseMat()
• Model::AddDenseMat()
• Model::AddDiagMat()
• Model::AddDiagMat()
• Model::AddDiagMat()
• Model::AddDiagMat()
• Model::AddEyeMat()
• Model::AddGenConstrIndicator()
• Model::AddGenConstrIndicator()
• Model::AddGenConstrIndicator()
• Model::AddOnesMat()
• Model::AddPsdConstr()
• Model::AddPsdConstr()
• Model::AddPsdConstr()
• Model::AddPsdConstr()
• Model::AddPsdVar()
• Model::AddPsdVars()
• Model::AddPsdVars()
• Model::AddQConstr()
• Model::AddQConstr()
• Model::AddQConstr()
• Model::AddSos()
• Model::AddSos()
• Model::AddSparseMat()
• Model::AddSymMat()
• Model::AddVar()
• Model::AddVar()
• Model::AddVars()
• Model::AddVars()
• Model::AddVars()
• Model::AddVars()
• Model::AddVars()
• Model::AddVars()
• Model::AddVars()
• Model::Clear()
• Model::Clone()
• Model::ComputeIIS()
• Model::DelPsdObj()
• Model::DelQuadObj()
• Model::FeasRelax()
• Model::FeasRelax()
• Model::Get()
• Model::Get()
• Model::Get()
• Model::Get()
• Model::GetCoeff()
• Model::GetCol()
• Model::GetColBasis()
• Model::GetCone()
• Model::GetConeBuilders()
• Model::GetConeBuilders()
• Model::GetCones()
• Model::GetConstr()
• Model::GetConstrBuilder()
• Model::GetConstrBuilders()
• Model::GetConstrByName()
• Model::GetConstrLowerIIS()
• Model::GetConstrs()
• Model::GetConstrUpperIIS()
• Model::GetDblAttr()
• Model::GetDblParam()
• Model::GetGenConstrIndicator()
• Model::GetIndicatorIIS()
• Model::GetIntAttr()
• Model::GetIntParam()
• Model::GetLpSolution()
• Model::GetObjective()
• Model::GetParamAttrType()
• Model::GetParamInfo()
• Model::GetParamInfo()
• Model::GetPoolObjVal()
• Model::GetPoolSolution()
• Model::GetPsdCoeff()
• Model::GetPsdConstr()
• Model::GetPsdConstrBuilder()
• Model::GetPsdConstrBuilders()
• Model::GetPsdConstrByName()
• Model::GetPsdConstrs()
• Model::GetPsdObjective()
• Model::GetPsdRow()
• Model::GetPsdRow()
• Model::GetPsdVar()
• Model::GetPsdVarByName()
• Model::GetPsdVars()
• Model::GetQConstr()
• Model::GetQConstrBuilder()
• Model::GetQConstrBuilders()
• Model::GetQConstrByName()
• Model::GetQConstrs()
• Model::GetQuadObjective()
• Model::GetQuadRow()
• Model::GetQuadRow()
• Model::GetRow()
• Model::GetRowBasis()
• Model::GetSolution()
• Model::GetSos()
• Model::GetSosBuilders()
• Model::GetSosBuilders()
• Model::GetSOSIIS()
• Model::GetSoss()
• Model::GetSymMat()
• Model::GetVar()
• Model::GetVarByName()
• Model::GetVarLowerIIS()
• Model::GetVars()
• Model::GetVarUpperIIS()
• Model::Interrupt()
• Model::LoadMipStart()
• Model::LoadTuneParam()
• Model::Read()
• Model::ReadBasis()
• Model::ReadBin()
• Model::ReadCbf()
• Model::ReadLp()
• Model::ReadMps()
• Model::ReadMst()
• Model::ReadParam()
• Model::ReadSdpa()
• Model::ReadSol()
• Model::ReadTune()
• Model::Remove()
• Model::Remove()
• Model::Remove()
• Model::Remove()
• Model::Remove()
• Model::Remove()
• Model::Remove()
• Model::Remove()
• Model::Reset()
• Model::ResetAll()
• Model::ResetParam()
• Model::Set()
• Model::Set()
• Model::Set()
• Model::SetBasis()
• Model::SetCoeff()
• Model::SetDblParam()
• Model::SetIntParam()
• Model::SetLpSolution()
• Model::SetMipStart()
• Model::SetMipStart()
• Model::SetMipStart()
• Model::SetObjConst()
• Model::SetObjective()
• Model::SetObjSense()
• Model::SetPsdCoeff()
• Model::SetPsdObjective()
• Model::SetQuadObjective()
• Model::SetSlackBasis()
• Model::SetSolverLogCallback()
• Model::SetSolverLogFile()
• Model::Solve()
• Model::SolveLp()
• Model::Tune()
• Model::Write()
• Model::WriteBasis()
• Model::WriteBin()
• Model::WriteIIS()
• Model::WriteLp()
• Model::WriteMps()
• Model::WriteMpsStr()
• Model::WriteMst()
• Model::WriteParam()
• Model::WritePoolSol()
• Model::WriteRelax()
• Model::WriteSol()
• Model::WriteTuneParam()

Var

COPT variable object. Variables are always associated with a particular model. User creates a variable object by adding a variable to a model, rather than by using constructor of Var class.

• Var::Get()
• Var::GetIdx()
• Var::GetLowerIIS()
• Var::GetName()
• Var::GetType()
• Var::GetUpperIIS()
• Var::Remove()
• Var::Set()
• Var::SetName()
• Var::SetType()

VarArray

COPT variable array object. To store and access a set of C++ Var objects, Cardinal Optimizer provides C++ VarArray class, which defines the following methods.

• VarArray::GetVar()
• VarArray::PushBack()
• VarArray::Reserve()
• VarArray::Size()

Expr

COPT linear expression object. A linear expression consists of a constant term, a list of terms of variables and associated coefficients. Linear expressions are used to build constraints.

• Expr::Expr()
• Expr::Expr()
• Expr::AddConstant()
• Expr::AddExpr()
• Expr::AddTerm()
• Expr::AddTerms()
• Expr::Clone()
• Expr::Evaluate()
• Expr::GetCoeff()
• Expr::GetConstant()
• Expr::GetVar()
• Expr::operator*=()
• Expr::operator*()
• Expr::operator*()
• Expr::operator*()
• Expr::operator+=()
• Expr::operator+()
• Expr::operator-=()
• Expr::operator-()
• Expr::Remove()
• Expr::Remove()
• Expr::Reserve()
• Expr::SetCoeff()
• Expr::SetConstant()
• Expr::Size()

Constraint

COPT constraint object. Constraints are always associated with a particular model. User creates a constraint object by adding a constraint to a model, rather than by using constructor of Constraint class.

• Constraint::Get()
• Constraint::GetBasis()
• Constraint::GetIdx()
• Constraint::GetLowerIIS()
• Constraint::GetName()
• Constraint::GetUpperIIS()
• Constraint::Remove()
• Constraint::Set()
• Constraint::SetName()

ConstrArray

COPT constraint array object. To store and access a set of C++ Constraint objects, Cardinal Optimizer provides C++ ConstrArray class, which defines the following methods.

• ConstrArray::GetConstr()
• ConstrArray::PushBack()
• ConstrArray::Reserve()
• ConstrArray::Size()

ConstrBuilder

COPT constraint builder object. To help building a constraint, given a linear expression, constraint sense and right-hand side value, Cardinal Optimizer provides C++ ConstrBuilder class, which defines the following methods.

• ConstrBuilder::GetExpr()
• ConstrBuilder::GetRange()
• ConstrBuilder::GetSense()
• ConstrBuilder::Set()
• ConstrBuilder::SetRange()

ConstrBuilderArray

COPT constraint builder array object. To store and access a set of C++ ConstrBuilder objects, Cardinal Optimizer provides C++ ConstrBuilderArray class, which defines the following methods.

• ConstrBuilderArray::GetBuilder()
• ConstrBuilderArray::PushBack()
• ConstrBuilderArray::Reserve()
• ConstrBuilderArray::Size()

Column

COPT column object. A column consists of a list of constraints and associated coefficients. Columns are used to represent the set of constraints in which a variable participates, and the asssociated coefficents.

• Column::Column()
• Column::AddColumn()
• Column::AddTerm()
• Column::AddTerms()
• Column::Clear()
• Column::Clone()
• Column::GetCoeff()
• Column::GetConstr()
• Column::Remove()
• Column::Remove()
• Column::Reserve()
• Column::Size()

ColumnArray

COPT column array object. To store and access a set of C++ Column objects, Cardinal Optimizer provides C++ ColumnArray class, which defines the following methods.

• ColumnArray::Clear()
• ColumnArray::GetColumn()
• ColumnArray::PushBack()
• ColumnArray::Reserve()
• ColumnArray::Size()

Sos

COPT SOS constraint object. SOS constraints are always associated with a particular model. User creates an SOS constraint object by adding an SOS constraint to a model, rather than by using constructor of Sos class.

An SOS constraint can be type 1 or 2 (COPT_SOS_TYPE1 or COPT_SOS_TYPE2).

• Sos::GetIdx()
• Sos::GetIIS()
• Sos::Remove()

SosArray

COPT SOS constraint array object. To store and access a set of C++ Sos objects, Cardinal Optimizer provides C++ SosArray class, which defines the following methods.

• SosArray::GetSos()
• SosArray::PushBack()
• SosArray::Size()

SosBuilder

COPT SOS constraint builder object. To help building an SOS constraint, given the SOS type, a set of variables and associated weights, Cardinal Optimizer provides C++ SosBuilder class, which defines the following methods.

• SosBuilder::GetSize()
• SosBuilder::GetType()
• SosBuilder::GetVar()
• SosBuilder::GetVars()
• SosBuilder::GetWeight()
• SosBuilder::GetWeights()
• SosBuilder::Set()

SosBuilderArray

COPT SOS constraint builder array object. To store and access a set of C++ SosBuilder objects, Cardinal Optimizer provides C++ SosBuilderArray class, which defines the following methods.

• SosBuilderArray::GetBuilder()
• SosBuilderArray::PushBack()
• SosBuilderArray::Size()

GenConstr

COPT general constraint object. General constraints are always associated with a particular model. User creates a general constraint object by adding a general constraint to a model, rather than by using constructor of GenConstr class.

• GenConstr::GetIdx()
• GenConstr::GetIIS()
• GenConstr::Remove()

GenConstrArray

COPT general constraint array object. To store and access a set of C++ GenConstr objects, Cardinal Optimizer provides C++ GenConstrArray class, which defines the following methods.

• GenConstrArray::GetGenConstr()
• GenConstrArray::PushBack()
• GenConstrArray::Size()

GenConstrBuilder

COPT general constraint builder object. To help building a general constraint, given a binary variable and associated value, a linear expression and constraint sense, Cardinal Optimizer provides C++ GenConstrBuilder class, which defines the following methods.

• GenConstrBuilder::GetBinVal()
• GenConstrBuilder::GetBinVar()
• GenConstrBuilder::GetExpr()
• GenConstrBuilder::GetSense()
• GenConstrBuilder::Set()

GenConstrBuilderArray

COPT general constraint builder array object. To store and access a set of C++ GenConstrBuilder objects, Cardinal Optimizer provides C++ GenConstrBuilderArray class, which defines the following methods.

• GenConstrBuilderArray::GetBuilder()
• GenConstrBuilderArray::PushBack()
• GenConstrBuilderArray::Size()

Cone

COPT cone constraint object. Cone constraints are always associated with a particular model. User creates a cone constraint object by adding a cone constraint to a model, rather than by using constructor of Cone class.

A cone constraint can be regular or rotated (COPT_CONE_QUAD or COPT_CONE_RQUAD).

• Cone::GetIdx()
• Cone::Remove()

ConeArray

COPT cone constraint array object. To store and access a set of C++ Cone objects, Cardinal Optimizer provides C++ ConeArray class, which defines the following methods.

• ConeArray::GetCone()
• ConeArray::PushBack()
• ConeArray::Size()

ConeBuilder

COPT cone constraint builder object. To help building a cone constraint, given the cone type and a set of variables, Cardinal Optimizer provides C++ ConeBuilder class, which defines the following methods.

• ConeBuilder::GetSize()
• ConeBuilder::GetType()
• ConeBuilder::GetVar()
• ConeBuilder::GetVars()
• ConeBuilder::Set()

ConeBuilderArray

COPT cone constraint builder array object. To store and access a set of C++ ConeBuilder objects, Cardinal Optimizer provides C++ ConeBuilderArray class, which defines the following methods.

• ConeBuilderArray::GetBuilder()
• ConeBuilderArray::PushBack()
• ConeBuilderArray::Size()

QuadExpr

COPT quadratic expression object. A quadratic expression consists of a linear expression, a list of variable pairs and associated coefficients of quadratic terms. Quadratic expressions are used to build quadratic constraints and objectives.

• QuadExpr::QuadExpr()
• QuadExpr::QuadExpr()
• QuadExpr::QuadExpr()
• QuadExpr::QuadExpr()
• QuadExpr::QuadExpr()
• QuadExpr::AddConstant()
• QuadExpr::AddLinExpr()
• QuadExpr::AddQuadExpr()
• QuadExpr::AddTerm()
• QuadExpr::AddTerm()
• QuadExpr::AddTerms()
• QuadExpr::AddTerms()
• QuadExpr::Clone()
• QuadExpr::Evaluate()
• QuadExpr::GetCoeff()
• QuadExpr::GetConstant()
• QuadExpr::GetLinExpr()
• QuadExpr::GetVar1()
• QuadExpr::GetVar2()
• QuadExpr::operator*=()
• QuadExpr::operator*()
• QuadExpr::operator+=()
• QuadExpr::operator+()
• QuadExpr::operator-=()
• QuadExpr::operator-()
• QuadExpr::Remove()
• QuadExpr::Remove()
• QuadExpr::Reserve()
• QuadExpr::SetCoeff()
• QuadExpr::SetConstant()
• QuadExpr::Size()

QConstraint

COPT quadratic constraint object. Quadratic constraints are always associated with a particular model. User creates a quadratic constraint object by adding a quadratic constraint to a model, rather than by using constructor of QConstraint class.

• QConstraint::Get()
• QConstraint::GetIdx()
• QConstraint::GetName()
• QConstraint::GetRhs()
• QConstraint::GetSense()
• QConstraint::Remove()
• QConstraint::Set()
• QConstraint::SetName()
• QConstraint::SetRhs()
• QConstraint::SetSense()

QConstrArray

COPT quadratic constraint array object. To store and access a set of C++ QConstraint objects, Cardinal Optimizer provides C++ QConstrArray class, which defines the following methods.

• QConstrArray::GetQConstr()
• QConstrArray::PushBack()
• QConstrArray::Reserve()
• QConstrArray::Size()

QConstrBuilder

COPT quadratic constraint builder object. To help building a quadratic constraint, given a quadratic expression, constraint sense and right-hand side value, Cardinal Optimizer provides C++ QConstrBuilder class, which defines the following methods.

• QConstrBuilder::GetQuadExpr()
• QConstrBuilder::GetSense()
• QConstrBuilder::Set()

QConstrBuilderArray

COPT quadratic constraint builder array object. To store and access a set of C++ QConstrBuilder objects, Cardinal Optimizer provides C++ QConstrBuilderArray class, which defines the following methods.

• QConstrBuilderArray::GetBuilder()
• QConstrBuilderArray::PushBack()
• QConstrBuilderArray::Reserve()
• QConstrBuilderArray::Size()

PsdVar

COPT PSD variable object. PSD variables are always associated with a particular model. User creates a PSD variable object by adding a PSD variable to model, rather than by constructor of PsdVar class.

• PsdVar::Get()
• PsdVar::GetDim()
• PsdVar::GetIdx()
• PsdVar::GetLen()
• PsdVar::GetName()
• PsdVar::Remove()
• PsdVar::SetName()

PsdVarArray

COPT PSD variable array object. To store and access a set of PsdVar objects, Cardinal Optimizer provides PsdVarArray class, which defines the following methods.

• PsdVarArray::GetPsdVar()
• PsdVarArray::PushBack()
• PsdVarArray::Reserve()
• PsdVarArray::Size()

PsdExpr

COPT PSD expression object. A PSD expression consists of a linear expression, a list of PSD variables and associated coefficient matrices of PSD terms. PSD expressions are used to build PSD constraints and objectives.

• PsdExpr::PsdExpr()
• PsdExpr::PsdExpr()
• PsdExpr::PsdExpr()
• PsdExpr::PsdExpr()
• PsdExpr::PsdExpr()
• PsdExpr::AddConstant()
• PsdExpr::AddLinExpr()
• PsdExpr::AddPsdExpr()
• PsdExpr::AddTerm()
• PsdExpr::AddTerm()
• PsdExpr::AddTerm()
• PsdExpr::AddTerms()
• PsdExpr::AddTerms()
• PsdExpr::Clone()
• PsdExpr::Evaluate()
• PsdExpr::GetCoeff()
• PsdExpr::GetConstant()
• PsdExpr::GetLinExpr()
• PsdExpr::GetPsdVar()
• PsdExpr::operator*=()
• PsdExpr::operator*()
• PsdExpr::operator+=()
• PsdExpr::operator+()
• PsdExpr::operator-=()
• PsdExpr::operator-()
• PsdExpr::Remove()
• PsdExpr::Remove()
• PsdExpr::Remove()
• PsdExpr::Reserve()
• PsdExpr::SetCoeff()
• PsdExpr::SetConstant()
• PsdExpr::Size()

PsdConstraint

COPT PSD constraint object. PSD constraints are always associated with a particular model. User creates a PSD constraint object by adding a PSD constraint to model, rather than by constructor of PsdConstraint class.

• PsdConstraint::Get()
• PsdConstraint::GetIdx()
• PsdConstraint::GetName()
• PsdConstraint::Remove()
• PsdConstraint::Set()
• PsdConstraint::SetName()

PsdConstrArray

COPT PSD constraint array object. To store and access a set of PsdConstraint objects, Cardinal Optimizer provides PsdConstrArray class, which defines the following methods.

• PsdConstrArray::GetPsdConstr()
• PsdConstrArray::PushBack()
• PsdConstrArray::Reserve()
• PsdConstrArray::Size()

PsdConstrBuilder

COPT PSD constraint builder object. To help building a PSD constraint, given a PSD expression, constraint sense and right-hand side value, Cardinal Optimizer provides PsdConstrBuilder class, which defines the following methods.

• PsdConstrBuilder::GetPsdExpr()
• PsdConstrBuilder::GetRange()
• PsdConstrBuilder::GetSense()
• PsdConstrBuilder::Set()
• PsdConstrBuilder::SetRange()

PsdConstrBuilderArray

COPT PSD constraint builder array object. To store and access a set of PsdConstrBuilder objects, Cardinal Optimizer provides PsdConstrBuilderArray class, which defines the following methods.

• PsdConstrBuilderArray::GetBuilder()
• PsdConstrBuilderArray::PushBack()
• PsdConstrBuilderArray::Reserve()
• PsdConstrBuilderArray::Size()

SymMatrix

COPT symmetric matrix object. Symmetric matrices are always associated with a particular model. User creates a symmetric matrix object by adding a symmetric matrix to model, rather than by constructor of SymMatrix class.

Symmetric matrices are used as coefficient matrices of PSD terms in PSD expressions, PSD constraints or PSD objectives.

• SymMatrix::GetDim()
• SymMatrix::GetIdx()

SymMatrixArray

COPT symmetric matrix object. To store and access a set of SymMatrix objects, Cardinal Optimizer provides SymMatrixArray class, which defines the following methods.

• SymMatrixArray::GetMatrix()
• SymMatrixArray::PushBack()
• SymMatrixArray::Reserve()
• SymMatrixArray::Size()

SymMatExpr

COPT symmetric matrix expression object. A symmetric matrix expression is a linear combination of symmetric matrices, which is still a symmetric matrix. However, by doing so, we are able to delay computing the final matrix until setting PSD constraints or PSD objective.

• SymMatExpr::SymMatExpr()
• SymMatExpr::SymMatExpr()
• SymMatExpr::AddSymMatExpr()
• SymMatExpr::AddTerm()
• SymMatExpr::AddTerms()
• SymMatExpr::Clone()
• SymMatExpr::GetCoeff()
• SymMatExpr::GetDim()
• SymMatExpr::GetSymMat()
• SymMatExpr::operator*=()
• SymMatExpr::operator*()
• SymMatExpr::operator+=()
• SymMatExpr::operator+()
• SymMatExpr::operator-=()
• SymMatExpr::operator-()
• SymMatExpr::Remove()
• SymMatExpr::Remove()
• SymMatExpr::Reserve()
• SymMatExpr::SetCoeff()
• SymMatExpr::Size()

ProbBuffer

Buffer object for COPT problem. ProbBuffer object holds the (MPS) problem in string format.

• ProbBuffer::ProbBuffer()
• ProbBuffer::GetData()
• ProbBuffer::Resize()
• ProbBuffer::Size()