15.4 Class Task

mosek.Task

Represents an optimization task.

Task.Task
Task()
Task(
  int numcon,
  int numvar)
Task(Env env)
Task(
  Env env,
  int numcon,
  int numvar)
Task(Task task)

Constructor of a new optimization task.

Parameters
  • numcon (int) – An optional hint about the maximal number of constraints in the task. (input)

  • numvar (int) – An optional hint about the maximal number of variables in the task. (input)

  • env (Env) – Parent environment. (input)

  • task (Task) – A task that will be cloned. (input)

Task.Dispose
void Dispose()

Free the underlying native allocation.

Task.analyzenames
analyzenames(streamtype whichstream,
             nametype nametype)

The function analyzes the names and issues an error if a name is invalid.

Parameters
  • whichstream (mosek.streamtype) – Index of the stream. (input)

  • nametype (mosek.nametype) – The type of names e.g. valid in MPS or LP files. (input)

Groups

Names

Task.analyzeproblem
analyzeproblem(streamtype whichstream)

The function analyzes the data of a task and writes out a report.

Parameters

whichstream (mosek.streamtype) – Index of the stream. (input)

Groups

Inspecting the task

Task.analyzesolution
analyzesolution(streamtype whichstream,
                soltype whichsol)

Print information related to the quality of the solution and other solution statistics.

By default this function prints information about the largest infeasibilites in the solution, the primal (and possibly dual) objective value and the solution status.

Following parameters can be used to configure the printed statistics:

  • iparam.ana_sol_basis enables or disables printing of statistics specific to the basis solution (condition number, number of basic variables etc.). Default is on.

  • iparam.ana_sol_print_violated enables or disables listing names of all constraints (both primal and dual) which are violated by the solution. Default is off.

  • dparam.ana_sol_infeas_tol is the tolerance defining when a constraint is considered violated. If a constraint is violated more than this, it will be listed in the summary.

Parameters
Groups

Solution information, Inspecting the task

Task.appendacc
appendacc(long domidx,
          long[] afeidxlist,
          double[] b)

Appends an affine conic constraint to the task. The affine constraint has the form a sequence of affine expressions belongs to a domain.

The domain index is specified with domidx and should refer to a domain previously appended with one of the append...domain functions.

The length of the affine expression list afeidxlist must be equal to the dimension \(n\) of the domain. The elements of afeidxlist are indexes to the store of affine expressions, i.e. the affine expressions appearing in the affine conic constraint are:

\[F_{\mathrm{afeidxlist}[k],:}x + g_{\mathrm{afeidxlist}[k]} \quad \mathrm{for}\ k=0,\ldots,n-1.\]

If an optional vector b of the same length as afeidxlist is specified then the expressions appearing in the affine constraint will instead be taken as:

\[F_{\mathrm{afeidxlist}[k],:}x + g_{\mathrm{afeidxlist}[k]} - b_k \quad \mathrm{for}\ k=0,\ldots,n-1.\]
Parameters
  • domidx (long) – Domain index. (input)

  • afeidxlist (long[]) – List of affine expression indexes. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. Optional, can be NULL. (input)

Groups

Problem data - affine conic constraints

Task.appendaccs
appendaccs(long[] domidxs,
           long[] afeidxlist,
           double[] b)

Appends numaccs affine conic constraint to the task. Each single affine conic constraint should be specified as in Task.appendacc and the input of this function should contain the concatenation of all these descriptions.

In particular, the length of afeidxlist must equal the sum of dimensions of domains indexed in domainsidxs.

Parameters
  • domidxs (long[]) – Domain indices. (input)

  • afeidxlist (long[]) – List of affine expression indexes. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. Optional, can be NULL. (input)

Groups

Problem data - affine conic constraints

Task.appendaccseq
appendaccseq(long domidx,
             long afeidxfirst,
             double[] b)

Appends an affine conic constraint to the task, as in Task.appendacc. The function assumes the affine expressions forming the constraint are sequential. The affine constraint has the form a sequence of affine expressions belongs to a domain.

The domain index is specified with domidx and should refer to a domain previously appended with one of the append...domain functions.

The number of affine expressions should be equal to the dimension \(n\) of the domain. The affine expressions forming the affine constraint are arranged sequentially in a contiguous block of the affine expression store starting from position afeidxfirst. That is, the affine expressions appearing in the affine conic constraint are:

\[F_{\mathrm{afeidxfirst}+k,:}x + g_{\mathrm{afeidxfirst}+k} \quad \mathrm{for}\ k=0,\ldots,n-1.\]

If an optional vector b of length numafeidx is specified then the expressions appearing in the affine constraint will instead be taken as

\[F_{\mathrm{afeidxfirst}+k,:}x + g_{\mathrm{afeidxfirst}+k} - b_k \quad \mathrm{for}\ k=0,\ldots,n-1.\]
Parameters
  • domidx (long) – Domain index. (input)

  • afeidxfirst (long) – Index of the first affine expression. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. Optional, can be NULL. (input)

Groups

Problem data - affine conic constraints

Task.appendaccsseq
appendaccsseq(long[] domidxs,
              long numafeidx,
              long afeidxfirst,
              double[] b)

Appends numaccs affine conic constraint to the task. It is the block variant of Task.appendaccs, that is it assumes that the affine expressions appearing in the affine conic constraints are sequential in the affine expression store, starting from position afeidxfirst.

Parameters
  • domidxs (long[]) – Domain indices. (input)

  • numafeidx (long) – Number of affine expressions in the affine expression list (must equal the sum of dimensions of the domains). (input)

  • afeidxfirst (long) – Index of the first affine expression. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. Optional, can be NULL. (input)

Groups

Problem data - affine conic constraints

Task.appendafes
appendafes(long num)

Appends a number of empty affine expressions to the task.

Parameters

num (long) – Number of empty affine expressions which should be appended. (input)

Groups

Problem data - affine expressions

Task.appendbarvars
appendbarvars(int[] dim)

Appends positive semidefinite matrix variables of dimensions given by dim to the problem.

Parameters

dim (int[]) – Dimensions of symmetric matrix variables to be added. (input)

Groups

Problem data - semidefinite

Task.appendcone Deprecated
appendcone(conetype ct,
           double conepar,
           int[] submem)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Appends a new conic constraint to the problem. Hence, add a constraint

\[\hat{x} \in \K\]

to the problem, where \(\K\) is a convex cone. \(\hat{x}\) is a subset of the variables which will be specified by the argument submem. Cone type is specified by ct.

Define

\[\hat{x} = x_{\mathtt{submem}[0]},\ldots,x_{\mathtt{submem}[\mathtt{nummem}-1]}.\]

Depending on the value of ct this function appends one of the constraints:

  • Quadratic cone (conetype.quad, requires \(\mathtt{nummem}\geq 1\)):

    \[\hat{x}_0 \geq \sqrt{\sum_{i=1}^{i<\mathtt{nummem}} \hat{x}_i^2}\]
  • Rotated quadratic cone (conetype.rquad, requires \(\mathtt{nummem}\geq 2\)):

    \[2 \hat{x}_0 \hat{x}_1 \geq \sum_{i=2}^{i<\mathtt{nummem}} \hat{x}^2_i, \quad \hat{x}_{0}, \hat{x}_1 \geq 0\]
  • Primal exponential cone (conetype.pexp, requires \(\mathtt{nummem}=3\)):

    \[\hat{x}_0 \geq \hat{x}_1\exp(\hat{x}_2/\hat{x}_1), \quad \hat{x}_0,\hat{x}_1 \geq 0\]
  • Primal power cone (conetype.ppow, requires \(\mathtt{nummem}\geq 2\)):

    \[\hat{x}_0^\alpha \hat{x}_1^{1-\alpha} \geq \sqrt{\sum_{i=2}^{i<\mathtt{nummem}} \hat{x}^2_i}, \quad \hat{x}_{0}, \hat{x}_1 \geq 0\]

    where \(\alpha\) is the cone parameter specified by conepar.

  • Dual exponential cone (conetype.dexp, requires \(\mathtt{nummem}=3\)):

    \[\hat{x}_0 \geq -\hat{x}_2 e^{-1}\exp(\hat{x}_1/\hat{x}_2), \quad \hat{x}_2\leq 0,\hat{x}_0 \geq 0\]
  • Dual power cone (conetype.dpow, requires \(\mathtt{nummem}\geq 2\)):

    \[\left(\frac{\hat{x}_0}{\alpha}\right)^\alpha \left(\frac{\hat{x}_1}{1-\alpha}\right)^{1-\alpha} \geq \sqrt{\sum_{i=2}^{i<\mathtt{nummem}} \hat{x}^2_i}, \quad \hat{x}_{0}, \hat{x}_1 \geq 0\]

    where \(\alpha\) is the cone parameter specified by conepar.

  • Zero cone (conetype.zero):

    \[\hat{x}_i = 0 \ \textrm{for all}\ i\]

Please note that the sets of variables appearing in different conic constraints must be disjoint.

For an explained code example see Sec. 6.3 (Conic Quadratic Optimization), Sec. 6.5 (Conic Exponential Optimization) or Sec. 6.4 (Power Cone Optimization).

Parameters
  • ct (mosek.conetype) – Specifies the type of the cone. (input)

  • conepar (double) – For the power cone it denotes the exponent alpha. For other cone types it is unused and can be set to 0. (input)

  • submem (int[]) – Variable subscripts of the members in the cone. (input)

Groups

Problem data - cones (deprecated)

Task.appendconeseq Deprecated
appendconeseq(conetype ct,
              double conepar,
              int nummem,
              int j)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Appends a new conic constraint to the problem, as in Task.appendcone. The function assumes the members of cone are sequential where the first member has index j and the last j+nummem-1.

Parameters
  • ct (mosek.conetype) – Specifies the type of the cone. (input)

  • conepar (double) – For the power cone it denotes the exponent alpha. For other cone types it is unused and can be set to 0. (input)

  • nummem (int) – Number of member variables in the cone. (input)

  • j (int) – Index of the first variable in the conic constraint. (input)

Groups

Problem data - cones (deprecated)

Task.appendconesseq Deprecated
appendconesseq(conetype[] ct,
               double[] conepar,
               int[] nummem,
               int j)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Appends a number of conic constraints to the problem, as in Task.appendcone. The \(k\)th cone is assumed to be of dimension nummem[k]. Moreover, it is assumed that the first variable of the first cone has index \(j\) and starting from there the sequentially following variables belong to the first cone, then to the second cone and so on.

Parameters
  • ct (mosek.conetype[]) – Specifies the type of the cone. (input)

  • conepar (double[]) – For the power cone it denotes the exponent alpha. For other cone types it is unused and can be set to 0. (input)

  • nummem (int[]) – Numbers of member variables in the cones. (input)

  • j (int) – Index of the first variable in the first cone to be appended. (input)

Groups

Problem data - cones (deprecated)

Task.appendcons
appendcons(int num)

Appends a number of constraints to the model. Appended constraints will be declared free. Please note that MOSEK will automatically expand the problem dimension to accommodate the additional constraints.

Parameters

num (int) – Number of constraints which should be appended. (input)

Groups

Problem data - linear part, Problem data - constraints

Task.appenddjcs
appenddjcs(long num)

Appends a number of empty disjunctive constraints to the task.

Parameters

num (long) – Number of empty disjunctive constraints which should be appended. (input)

Groups

Problem data - disjunctive constraints

Task.appenddualexpconedomain
appenddualexpconedomain(out long domidx)
appenddualexpconedomain() -> long domidx

Appends the dual exponential cone \(\left\{ x\in \real^3 ~:~ x_0 \geq -x_2 e^{-1} e^{x_1/x_2},\ x_0> 0,\ x_2< 0 \right\}\) to the list of domains.

Parameters

domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appenddualgeomeanconedomain
appenddualgeomeanconedomain(long n,
                            out long domidx)
appenddualgeomeanconedomain(long n) -> long domidx

Appends the dual geometric mean cone \(\left\{ x\in \real^n ~:~ (n-1) \left(\prod_{i=0}^{n-2} x_i\right)^{1/(n-1)} \geq |x_{n-1}|,\ x_0,\ldots,x_{n-2}\geq 0 \right\}\) to the list of domains.

Parameters
  • n (long) – Dimmension of the domain. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appenddualpowerconedomain
appenddualpowerconedomain(long n,
                          double[] alpha,
                          out long domidx)
appenddualpowerconedomain(long n,
                          double[] alpha) -> long domidx

Appends the dual power cone domain of dimension \(n\), with \(n_\ell\) variables appearing on the left-hand side, where \(n_\ell\) is the length of \(\alpha\), and with a homogenous sequence of exponents \(\alpha_0,\ldots,\alpha_{n_\ell-1}\).

Formally, let \(s = \sum_i \alpha_i\) and \(\beta_i = \alpha_i / s\), so that \(\sum_i \beta_i=1\). Then the dual power cone is defined as follows:

\[\left\{ x\in \real^n ~:~ \prod_{i=0}^{n_\ell-1} \left(\frac{x_i}{\beta_i}\right)^{\beta_i} \geq \sqrt{\sum_{j=n_\ell}^{n-1}x_j^2},\ x_0\ldots,x_{n_\ell-1}\geq 0 \right\}\]
Parameters
  • n (long) – Dimension of the domain. (input)

  • alpha (double[]) – The sequence proportional to exponents. Must be positive. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendprimalexpconedomain
appendprimalexpconedomain(out long domidx)
appendprimalexpconedomain() -> long domidx

Appends the primal exponential cone \(\left\{ x\in \real^3 ~:~ x_0 \geq x_1 e^{x_2/x_1},\ x_0,x_1> 0 \right\}\) to the list of domains.

Parameters

domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendprimalgeomeanconedomain
appendprimalgeomeanconedomain(long n,
                              out long domidx)
appendprimalgeomeanconedomain(long n) -> long domidx

Appends the primal geometric mean cone \(\left\{ x\in \real^n ~:~ \left(\prod_{i=0}^{n-2} x_i\right)^{1/(n-1)} \geq |x_{n-1}|,\ x_0\ldots,x_{n-2}\geq 0 \right\}\) to the list of domains.

Parameters
  • n (long) – Dimmension of the domain. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendprimalpowerconedomain
appendprimalpowerconedomain(long n,
                            double[] alpha,
                            out long domidx)
appendprimalpowerconedomain(long n,
                            double[] alpha) -> long domidx

Appends the primal power cone domain of dimension \(n\), with \(n_\ell\) variables appearing on the left-hand side, where \(n_\ell\) is the length of \(\alpha\), and with a homogenous sequence of exponents \(\alpha_0,\ldots,\alpha_{n_\ell-1}\).

Formally, let \(s = \sum_i \alpha_i\) and \(\beta_i = \alpha_i / s\), so that \(\sum_i \beta_i=1\). Then the primal power cone is defined as follows:

\[\left\{ x\in \real^n ~:~ \prod_{i=0}^{n_\ell-1} x_i^{\beta_i} \geq \sqrt{\sum_{j=n_\ell}^{n-1}x_j^2},\ x_0\ldots,x_{n_\ell-1}\geq 0 \right\}\]
Parameters
  • n (long) – Dimension of the domain. (input)

  • alpha (double[]) – The sequence proportional to exponents. Must be positive. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendquadraticconedomain
appendquadraticconedomain(long n,
                          out long domidx)
appendquadraticconedomain(long n) -> long domidx

Appends the \(n\)-dimensional quadratic cone \(\left\{x\in\real^n~:~x_0 \geq \sqrt{\sum_{i=1}^{n-1} x_i^2}\right\}\) to the list of domains.

Parameters
  • n (long) – Dimmension of the domain. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendrdomain
appendrdomain(long n,
              out long domidx)
appendrdomain(long n) -> long domidx

Appends the \(n\)-dimensional real space \(\{ x \in \real^n \}\) to the list of domains.

Parameters
  • n (long) – Dimmension of the domain. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendrminusdomain
appendrminusdomain(long n,
                   out long domidx)
appendrminusdomain(long n) -> long domidx

Appends the \(n\)-dimensional negative orthant \(\{ x \in \real^n: \, x \leq 0 \}\) to the list of domains.

Parameters
  • n (long) – Dimmension of the domain. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendrplusdomain
appendrplusdomain(long n,
                  out long domidx)
appendrplusdomain(long n) -> long domidx

Appends the \(n\)-dimensional positive orthant \(\{ x \in \real^n: \, x \geq 0 \}\) to the list of domains.

Parameters
  • n (long) – Dimmension of the domain. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendrquadraticconedomain
appendrquadraticconedomain(long n,
                           out long domidx)
appendrquadraticconedomain(long n) -> long domidx

Appends the \(n\)-dimensional rotated quadratic cone \(\left\{x\in\real^n~:~2 x_0 x_1 \geq \sum_{i=2}^{n-1} x_i^2,\ x_0,x_1\geq 0\right\}\) to the list of domains.

Parameters
  • n (long) – Dimmension of the domain. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendrzerodomain
appendrzerodomain(long n,
                  out long domidx)
appendrzerodomain(long n) -> long domidx

Appends the zero in \(n\)-dimensional real space \(\{ x \in \real^n: \, x = 0 \}\) to the list of domains.

Parameters
  • n (long) – Dimmension of the domain. (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendsparsesymmat
appendsparsesymmat(int dim,
                   int[] subi,
                   int[] subj,
                   double[] valij,
                   out long idx)
appendsparsesymmat(int dim,
                   int[] subi,
                   int[] subj,
                   double[] valij) -> long idx

MOSEK maintains a storage of symmetric data matrices that is used to build \(\barC\) and \(\barA\). The storage can be thought of as a vector of symmetric matrices denoted \(E\). Hence, \(E_i\) is a symmetric matrix of certain dimension.

This function appends a general sparse symmetric matrix on triplet form to the vector \(E\) of symmetric matrices. The vectors subi, subj, and valij contains the row subscripts, column subscripts and values of each element in the symmetric matrix to be appended. Since the matrix that is appended is symmetric, only the lower triangular part should be specified. Moreover, duplicates are not allowed.

Observe the function reports the index (position) of the appended matrix in \(E\). This index should be used for later references to the appended matrix.

Parameters
  • dim (int) – Dimension of the symmetric matrix that is appended. (input)

  • subi (int[]) – Row subscript in the triplets. (input)

  • subj (int[]) – Column subscripts in the triplets. (input)

  • valij (double[]) – Values of each triplet. (input)

  • idx (long) – Unique index assigned to the inputted matrix that can be used for later reference. (output)

Return

idx (long) – Unique index assigned to the inputted matrix that can be used for later reference.

Groups

Problem data - semidefinite

Task.appendsparsesymmatlist
appendsparsesymmatlist(int[] dims,
                       long[] nz,
                       int[] subi,
                       int[] subj,
                       double[] valij,
                       long[] idx)
appendsparsesymmatlist(int[] dims,
                       long[] nz,
                       int[] subi,
                       int[] subj,
                       double[] valij) -> long[] idx

MOSEK maintains a storage of symmetric data matrices that is used to build \(\barC\) and \(\barA\). The storage can be thought of as a vector of symmetric matrices denoted \(E\). Hence, \(E_i\) is a symmetric matrix of certain dimension.

This function appends general sparse symmetric matrixes on triplet form to the vector \(E\) of symmetric matrices. The vectors subi, subj, and valij contains the row subscripts, column subscripts and values of each element in the symmetric matrix to be appended. Since the matrix that is appended is symmetric, only the lower triangular part should be specified. Moreover, duplicates are not allowed.

Observe the function reports the index (position) of the appended matrix in \(E\). This index should be used for later references to the appended matrix.

Parameters
  • dims (int[]) – Dimensions of the symmetric matrixes. (input)

  • nz (long[]) – Number of nonzeros for each matrix. (input)

  • subi (int[]) – Row subscript in the triplets. (input)

  • subj (int[]) – Column subscripts in the triplets. (input)

  • valij (double[]) – Values of each triplet. (input)

  • idx (long[]) – Unique index assigned to the inputted matrix that can be used for later reference. (output)

Return

idx (long[]) – Unique index assigned to the inputted matrix that can be used for later reference.

Groups

Problem data - semidefinite

Task.appendsvecpsdconedomain
appendsvecpsdconedomain(long n,
                        out long domidx)
appendsvecpsdconedomain(long n) -> long domidx

Appends the domain consisting of vectors of length \(n=d(d+1)/2\) defined as follows

\[\{(x_1,\ldots,x_{d(d+1)/2})\in \real^n~:~ \mathrm{sMat}(x)\in\PSD^d\} = \{\mathrm{sVec}(X)~:~X\in\PSD^d\},\]

where

\[\mathrm{sVec}(X) = (X_{11},\sqrt{2}X_{21},\ldots,\sqrt{2}X_{d1},X_{22},\sqrt{2}X_{32},\ldots,X_{dd}),\]

and

\[\begin{split}\mathrm{sMat}(x) = \left[\begin{array}{cccc}x_1 & x_2/\sqrt{2} & \cdots & x_{d}/\sqrt{2} \\ x_2/\sqrt{2} & x_{d+1} & \cdots & x_{2d-1}/\sqrt{2} \\ \cdots & \cdots & \cdots & \cdots \\ x_{d}/\sqrt{2} & x_{2d-1}/\sqrt{2} & \cdots & x_{d(d+1)/2}\end{array}\right].\end{split}\]

In other words, the domain consists of vectorizations of the lower-triangular part of a positive semidefinite matrix, with the non-diagonal elements additionally rescaled.

This domain is a self-dual cone.

Parameters
  • n (long) – Dimension of the domain, must be of the form \(d(d+1)/2\). (input)

  • domidx (long) – Index of the domain. (output)

Return

domidx (long) – Index of the domain.

Groups

Problem data - domain

Task.appendvars
appendvars(int num)

Appends a number of variables to the model. Appended variables will be fixed at zero. Please note that MOSEK will automatically expand the problem dimension to accommodate the additional variables.

Parameters

num (int) – Number of variables which should be appended. (input)

Groups

Problem data - linear part, Problem data - variables

Task.asyncgetresult
asyncgetresult(string address,
               string accesstoken,
               string token,
               out bool respavailable,
               out rescode resp,
               out rescode trm)
asyncgetresult(string address,
               string accesstoken,
               string token,
               out rescode resp,
               out rescode trm) -> bool respavailable
asyncgetresult(string address,
               string accesstoken,
               string token) ->
              (bool respavailable,
               rescode resp,
               rescode trm)

Request a solution from a remote job identified by the argument token. For other arguments see Task.asyncoptimize. If the solution is available it will be retrieved and loaded into the local task.

Parameters
  • address (string) – Address of the OptServer. (input)

  • accesstoken (string) – Access token. (input)

  • token (string) – The task token. (input)

  • respavailable (bool) – Indicates if a remote response is available. If this is not true, resp and trm should be ignored. (output)

  • resp (mosek.rescode) – Is the response code from the remote solver. (output)

  • trm (mosek.rescode) – Is either rescode.ok or a termination response code. (output)

Return
  • respavailable (bool) – Indicates if a remote response is available. If this is not true, resp and trm should be ignored.

  • resp (mosek.rescode) – Is the response code from the remote solver.

  • trm (mosek.rescode) – Is either rescode.ok or a termination response code.

Groups

Remote optimization

Task.asyncoptimize
asyncoptimize(string address,
              string accesstoken,
              StringBuilder token)
asyncoptimize(string address,
              string accesstoken) -> string token

Offload the optimization task to an instance of OptServer specified by addr, which should be a valid URL, for example http://server:port or https://server:port. The call will exit immediately.

If the server requires authentication, the authentication token can be passed in the accesstoken argument.

If the server requires encryption, the keys can be passed using one of the solver parameters sparam.remote_tls_cert or sparam.remote_tls_cert_path.

The function returns a token which should be used in future calls to identify the task.

Parameters
  • address (string) – Address of the OptServer. (input)

  • accesstoken (string) – Access token. (input)

  • token (StringBuilder) – Returns the task token. (output)

Return

token (string) – Returns the task token.

Groups

Remote optimization

Task.asyncpoll
asyncpoll(string address,
          string accesstoken,
          string token,
          out bool respavailable,
          out rescode resp,
          out rescode trm)
asyncpoll(string address,
          string accesstoken,
          string token,
          out rescode resp,
          out rescode trm) -> bool respavailable
asyncpoll(string address,
          string accesstoken,
          string token) ->
         (bool respavailable,
          rescode resp,
          rescode trm)

Requests information about the status of the remote job identified by the argument token. For other arguments see Task.asyncoptimize.

Parameters
  • address (string) – Address of the OptServer. (input)

  • accesstoken (string) – Access token. (input)

  • token (string) – The task token. (input)

  • respavailable (bool) – Indicates if a remote response is available. If this is not true, resp and trm should be ignored. (output)

  • resp (mosek.rescode) – Is the response code from the remote solver. (output)

  • trm (mosek.rescode) – Is either rescode.ok or a termination response code. (output)

Return
  • respavailable (bool) – Indicates if a remote response is available. If this is not true, resp and trm should be ignored.

  • resp (mosek.rescode) – Is the response code from the remote solver.

  • trm (mosek.rescode) – Is either rescode.ok or a termination response code.

Groups

Remote optimization

Task.asyncstop
asyncstop(string address,
          string accesstoken,
          string token)

Request that the remote job identified by token is terminated. For other arguments see Task.asyncoptimize.

Parameters
  • address (string) – Address of the OptServer. (input)

  • accesstoken (string) – Access token. (input)

  • token (string) – The task token. (input)

Groups

Remote optimization

Task.basiscond
basiscond(out double nrmbasis,
          out double nrminvbasis)
basiscond() ->
         (double nrmbasis,
          double nrminvbasis)

If a basic solution is available and it defines a nonsingular basis, then this function computes the 1-norm estimate of the basis matrix and a 1-norm estimate for the inverse of the basis matrix. The 1-norm estimates are computed using the method outlined in [Ste98], pp. 388-391.

By definition the 1-norm condition number of a matrix \(B\) is defined as

\[\kappa_1(B) := \|B\|_1 \|B^{-1}\|_1.\]

Moreover, the larger the condition number is the harder it is to solve linear equation systems involving \(B\). Given estimates for \(\|B\|_1\) and \(\|B^{-1}\|_1\) it is also possible to estimate \(\kappa_1(B)\).

Parameters
  • nrmbasis (double) – An estimate for the 1-norm of the basis. (output)

  • nrminvbasis (double) – An estimate for the 1-norm of the inverse of the basis. (output)

Return
  • nrmbasis (double) – An estimate for the 1-norm of the basis.

  • nrminvbasis (double) – An estimate for the 1-norm of the inverse of the basis.

Groups

Solving systems with basis matrix

Task.checkmem
checkmem(string file,
         int line)

Checks the memory allocated by the task.

Parameters
  • file (string) – File from which the function is called. (input)

  • line (int) – Line in the file from which the function is called. (input)

Groups

System, memory and debugging

Task.chgconbound
chgconbound(int i,
            int lower,
            int finite,
            double value)

Changes a bound for one constraint.

If lower is non-zero, then the lower bound is changed as follows:

\[\begin{split}\mbox{new lower bound} = \left\{ \begin{array}{ll} - \infty, & \mathtt{finite}=0, \\ \mathtt{value} & \mbox{otherwise}. \end{array} \right.\end{split}\]

Otherwise if lower is zero, then

\[\begin{split}\mbox{new upper bound} = \left\{ \begin{array}{ll} \infty, & \mathtt{finite}=0, \\ \mathtt{value} & \mbox{otherwise}. \end{array} \right.\end{split}\]

Please note that this function automatically updates the bound key for the bound, in particular, if the lower and upper bounds are identical, the bound key is changed to fixed.

Parameters
  • i (int) – Index of the constraint for which the bounds should be changed. (input)

  • lower (int) – If non-zero, then the lower bound is changed, otherwise the upper bound is changed. (input)

  • finite (int) – If non-zero, then value is assumed to be finite. (input)

  • value (double) – New value for the bound. (input)

Groups

Problem data - bounds, Problem data - constraints, Problem data - linear part

Task.chgvarbound
chgvarbound(int j,
            int lower,
            int finite,
            double value)

Changes a bound for one variable.

If lower is non-zero, then the lower bound is changed as follows:

\[\begin{split}\mbox{new lower bound} = \left\{ \begin{array}{ll} - \infty, & \mathtt{finite}=0, \\ \mathtt{value} & \mbox{otherwise}. \end{array} \right.\end{split}\]

Otherwise if lower is zero, then

\[\begin{split}\mbox{new upper bound} = \left\{ \begin{array}{ll} \infty, & \mathtt{finite}=0, \\ \mathtt{value} & \mbox{otherwise}. \end{array} \right.\end{split}\]

Please note that this function automatically updates the bound key for the bound, in particular, if the lower and upper bounds are identical, the bound key is changed to fixed.

Parameters
  • j (int) – Index of the variable for which the bounds should be changed. (input)

  • lower (int) – If non-zero, then the lower bound is changed, otherwise the upper bound is changed. (input)

  • finite (int) – If non-zero, then value is assumed to be finite. (input)

  • value (double) – New value for the bound. (input)

Groups

Problem data - bounds, Problem data - variables, Problem data - linear part

Task.commitchanges
commitchanges()

Commits all cached problem changes to the task. It is usually not necessary to call this function explicitly since changes will be committed automatically when required.

Groups

Environment and task management

Task.deletesolution
deletesolution(soltype whichsol)

Undefine a solution and free the memory it uses.

Parameters

whichsol (mosek.soltype) – Selects a solution. (input)

Groups

Environment and task management, Solution information

Task.dualsensitivity
dualsensitivity(int[] subj,
                double[] leftpricej,
                double[] rightpricej,
                double[] leftrangej,
                double[] rightrangej)
dualsensitivity(int[] subj) ->
               (double[] leftpricej,
                double[] rightpricej,
                double[] leftrangej,
                double[] rightrangej)

Calculates sensitivity information for objective coefficients. The indexes of the coefficients to analyze are

\[\{\mathtt{subj}[i] ~|~ i = 0,\ldots,\mathtt{numj}-1\}\]

The type of sensitivity analysis to perform (basis or optimal partition) is controlled by the parameter iparam.sensitivity_type.

For an example, please see Section Example: Sensitivity Analysis.

Parameters
  • subj (int[]) – Indexes of objective coefficients to analyze. (input)

  • leftpricej (double[]) – \(\mathtt{leftpricej}[j]\) is the left shadow price for the coefficient with index \(\mathtt{subj[j]}\). (output)

  • rightpricej (double[]) – \(\mathtt{rightpricej}[j]\) is the right shadow price for the coefficient with index \(\mathtt{subj[j]}\). (output)

  • leftrangej (double[]) – \(\mathtt{leftrangej}[j]\) is the left range \(\beta_1\) for the coefficient with index \(\mathtt{subj[j]}\). (output)

  • rightrangej (double[]) – \(\mathtt{rightrangej}[j]\) is the right range \(\beta_2\) for the coefficient with index \(\mathtt{subj[j]}\). (output)

Return
  • leftpricej (double[]) – \(\mathtt{leftpricej}[j]\) is the left shadow price for the coefficient with index \(\mathtt{subj[j]}\).

  • rightpricej (double[]) – \(\mathtt{rightpricej}[j]\) is the right shadow price for the coefficient with index \(\mathtt{subj[j]}\).

  • leftrangej (double[]) – \(\mathtt{leftrangej}[j]\) is the left range \(\beta_1\) for the coefficient with index \(\mathtt{subj[j]}\).

  • rightrangej (double[]) – \(\mathtt{rightrangej}[j]\) is the right range \(\beta_2\) for the coefficient with index \(\mathtt{subj[j]}\).

Groups

Sensitivity analysis

Task.emptyafebarfrow
emptyafebarfrow(long afeidx)

Clears a row in \(\barF\) i.e. sets \(\barF_{\mathrm{afeidx},*} = 0\).

Parameters

afeidx (long) – Row index of \(\barF\). (input)

Groups

Problem data - affine expressions, Problem data - semidefinite

Task.emptyafebarfrowlist
emptyafebarfrowlist(long[] afeidxlist)

Clears a number of rows in \(\barF\) i.e. sets \(\barF_{i,*} = 0\) for all indices \(i\) in afeidxlist.

Parameters

afeidxlist (long[]) – Indices of rows in \(\barF\) to clear. (input)

Groups

Problem data - affine expressions, Problem data - semidefinite

Task.emptyafefcol
emptyafefcol(int varidx)

Clears one column in the affine constraint matrix \(F\), that is sets \(F_{*,\mathrm{varidx}}=0\).

Parameters

varidx (int) – Index of a variable (column in \(F\)). (input)

Groups

Problem data - affine expressions

Task.emptyafefcollist
emptyafefcollist(int[] varidx)

Clears a number of columns in \(F\) i.e. sets \(F_{*,j} = 0\) for all indices \(j\) in varidx.

Parameters

varidx (int[]) – Indices of variables (columns) in \(F\) to clear. (input)

Groups

Problem data - affine expressions

Task.emptyafefrow
emptyafefrow(long afeidx)

Clears one row in the affine constraint matrix \(F\), that is sets \(F_{\mathrm{afeidx},*}=0\).

Parameters

afeidx (long) – Index of a row in \(F\). (input)

Groups

Problem data - affine expressions

Task.emptyafefrowlist
emptyafefrowlist(long[] afeidx)

Clears a number of rows in \(F\) i.e. sets \(F_{i,*} = 0\) for all indices \(i\) in afeidx.

Parameters

afeidx (long[]) – Indices of rows in \(F\) to clear. (input)

Groups

Problem data - affine expressions

Task.evaluateacc
evaluateacc(soltype whichsol,
            long accidx,
            double[] activity)
evaluateacc(soltype whichsol,
            long accidx) -> double[] activity

Evaluates the activity of an affine conic constraint.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • accidx (long) – The index of the affine conic constraint. (input)

  • activity (double[]) – The activity of the affine conic constraint. The array should have length equal to the dimension of the constraint. (output)

Return

activity (double[]) – The activity of the affine conic constraint. The array should have length equal to the dimension of the constraint.

Groups

Solution - primal, Problem data - affine conic constraints

Task.evaluateaccs
evaluateaccs(soltype whichsol,
             double[] activity)
evaluateaccs(soltype whichsol) -> double[] activity

Evaluates the activities of all affine conic constraints.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • activity (double[]) – The activity of affine conic constraints. The array should have length equal to the sum of dimensions of all affine conic constraints. (output)

Return

activity (double[]) – The activity of affine conic constraints. The array should have length equal to the sum of dimensions of all affine conic constraints.

Groups

Solution - primal, Problem data - affine conic constraints

Task.generateaccnames
generateaccnames(long[] sub,
                 string fmt,
                 int[] dims,
                 long[] sp,
                 int[] namedaxisidxs,
                 string[] names)

Internal.

Parameters
  • sub (long[]) – Indexes of the affine conic constraints. (input)

  • fmt (string) – The variable name formatting string. (input)

  • dims (int[]) – Dimensions in the shape. (input)

  • sp (long[]) – Items that should be named. (input)

  • namedaxisidxs (int[]) – List if named index axes (input)

Groups

Names

Task.generatebarvarnames
generatebarvarnames(int[] subj,
                    string fmt,
                    int[] dims,
                    long[] sp,
                    int[] namedaxisidxs,
                    string[] names)

Generates systematic names for variables.

Parameters
  • subj (int[]) – Indexes of the variables. (input)

  • fmt (string) – The variable name formatting string. (input)

  • dims (int[]) – Dimensions in the shape. (input)

  • sp (long[]) – Items that should be named. (input)

  • namedaxisidxs (int[]) – List if named index axes (input)

Groups

Names, Problem data - variables, Problem data - linear part

Task.generateconenames Deprecated
generateconenames(int[] subk,
                  string fmt,
                  int[] dims,
                  long[] sp,
                  int[] namedaxisidxs,
                  string[] names)

Internal, deprecated.

Parameters
  • subk (int[]) – Indexes of the cone. (input)

  • fmt (string) – The cone name formatting string. (input)

  • dims (int[]) – Dimensions in the shape. (input)

  • sp (long[]) – Items that should be named. (input)

  • namedaxisidxs (int[]) – List if named index axes (input)

Groups

Names, Problem data - cones (deprecated)

Task.generateconnames
generateconnames(int[] subi,
                 string fmt,
                 int[] dims,
                 long[] sp,
                 int[] namedaxisidxs,
                 string[] names)

Generates systematic names for constraints.

Parameters
  • subi (int[]) – Indexes of the constraints. (input)

  • fmt (string) – The constraint name formatting string. (input)

  • dims (int[]) – Dimensions in the shape. (input)

  • sp (long[]) – Items that should be named. (input)

  • namedaxisidxs (int[]) – List if named index axes (input)

Groups

Names, Problem data - constraints, Problem data - linear part

Task.generatedjcnames
generatedjcnames(long[] sub,
                 string fmt,
                 int[] dims,
                 long[] sp,
                 int[] namedaxisidxs,
                 string[] names)

Internal.

Parameters
  • sub (long[]) – Indexes of the disjunctive constraints. (input)

  • fmt (string) – The variable name formatting string. (input)

  • dims (int[]) – Dimensions in the shape. (input)

  • sp (long[]) – Items that should be named. (input)

  • namedaxisidxs (int[]) – List if named index axes (input)

Groups

Names

Task.generatevarnames
generatevarnames(int[] subj,
                 string fmt,
                 int[] dims,
                 long[] sp,
                 int[] namedaxisidxs,
                 string[] names)

Generates systematic names for variables.

Parameters
  • subj (int[]) – Indexes of the variables. (input)

  • fmt (string) – The variable name formatting string. (input)

  • dims (int[]) – Dimensions in the shape. (input)

  • sp (long[]) – Items that should be named. (input)

  • namedaxisidxs (int[]) – List if named index axes (input)

Groups

Names, Problem data - variables, Problem data - linear part

Task.getaccafeidxlist
getaccafeidxlist(long accidx,
                 long[] afeidxlist)
getaccafeidxlist(long accidx) -> long[] afeidxlist

Obtains the list of affine expressions appearing in the affine conic constraint.

Parameters
  • accidx (long) – Index of the affine conic constraint. (input)

  • afeidxlist (long[]) – List of indexes of affine expressions appearing in the constraint. (output)

Return

afeidxlist (long[]) – List of indexes of affine expressions appearing in the constraint.

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getaccb
getaccb(long accidx,
        double[] b)
getaccb(long accidx) -> double[] b

Obtains the additional constant term vector appearing in the affine conic constraint.

Parameters
  • accidx (long) – Index of the affine conic constraint. (input)

  • b (double[]) – The vector b appearing in the constraint. (output)

Return

b (double[]) – The vector b appearing in the constraint.

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getaccbarfblocktriplet
getaccbarfblocktriplet(out long numtrip,
                       long[] acc_afe,
                       int[] bar_var,
                       int[] blk_row,
                       int[] blk_col,
                       double[] blk_val)
getaccbarfblocktriplet(long[] acc_afe,
                       int[] bar_var,
                       int[] blk_row,
                       int[] blk_col,
                       double[] blk_val) -> long numtrip
getaccbarfblocktriplet() ->
                      (long numtrip,
                       long[] acc_afe,
                       int[] bar_var,
                       int[] blk_row,
                       int[] blk_col,
                       double[] blk_val)

Obtains \(\barF\), implied by the ACCs, in block triplet form. If the AFEs passed to the ACCs were out of order, then this function can be used to obtain the barF as seen by the ACCs.

Parameters
  • numtrip (long) – Number of elements in the block triplet form. (output)

  • acc_afe (long[]) – Index of the AFE within the concatenated list of AFEs in ACCs. (output)

  • bar_var (int[]) – Symmetric matrix variable index. (output)

  • blk_row (int[]) – Block row index. (output)

  • blk_col (int[]) – Block column index. (output)

  • blk_val (double[]) – The numerical value associated with each block triplet. (output)

Return
  • numtrip (long) – Number of elements in the block triplet form.

  • acc_afe (long[]) – Index of the AFE within the concatenated list of AFEs in ACCs.

  • bar_var (int[]) – Symmetric matrix variable index.

  • blk_row (int[]) – Block row index.

  • blk_col (int[]) – Block column index.

  • blk_val (double[]) – The numerical value associated with each block triplet.

Groups

Problem data - affine expressions, Problem data - semidefinite

Task.getaccbarfnumblocktriplets
getaccbarfnumblocktriplets(out long numtrip)
getaccbarfnumblocktriplets() -> long numtrip

Obtains an upper bound on the number of elements in the block triplet form of \(\barF\), as used within the ACCs.

Parameters

numtrip (long) – An upper bound on the number of elements in the block triplet form of \(\barF.\), as used within the ACCs. (output)

Return

numtrip (long) – An upper bound on the number of elements in the block triplet form of \(\barF.\), as used within the ACCs.

Groups

Problem data - semidefinite, Problem data - affine conic constraints, Inspecting the task

Task.getaccdomain
getaccdomain(long accidx,
             out long domidx)
getaccdomain(long accidx) -> long domidx

Obtains the domain appearing in the affine conic constraint.

Parameters
  • accidx (long) – The index of the affine conic constraint. (input)

  • domidx (long) – The index of domain in the affine conic constraint. (output)

Return

domidx (long) – The index of domain in the affine conic constraint.

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getaccdoty
getaccdoty(soltype whichsol,
           long accidx,
           double[] doty)
getaccdoty(soltype whichsol,
           long accidx) -> double[] doty

Obtains the \(\dot{y}\) vector for a solution (the dual values of an affine conic constraint).

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • accidx (long) – The index of the affine conic constraint. (input)

  • doty (double[]) – The dual values for this affine conic constraint. The array should have length equal to the dimension of the constraint. (output)

Return

doty (double[]) – The dual values for this affine conic constraint. The array should have length equal to the dimension of the constraint.

Groups

Solution - dual, Problem data - affine conic constraints

Task.getaccdotys
getaccdotys(soltype whichsol,
            double[] doty)
getaccdotys(soltype whichsol) -> double[] doty

Obtains the \(\dot{y}\) vector for a solution (the dual values of all affine conic constraint).

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • doty (double[]) – The dual values of affine conic constraints. The array should have length equal to the sum of dimensions of all affine conic constraints. (output)

Return

doty (double[]) – The dual values of affine conic constraints. The array should have length equal to the sum of dimensions of all affine conic constraints.

Groups

Solution - dual, Problem data - affine conic constraints

Task.getaccfnumnz
getaccfnumnz(out long accfnnz)
getaccfnumnz() -> long accfnnz

If the AFEs are not added sequentially to the ACCs, then the present function gives the number of nonzero elements in the F matrix that would be implied by the ordering of AFEs within ACCs.

Parameters

accfnnz (long) – Number of non-zeros in \(F\) implied by ACCs. (output)

Return

accfnnz (long) – Number of non-zeros in \(F\) implied by ACCs.

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getaccftrip
getaccftrip(long[] frow,
            int[] fcol,
            double[] fval)
getaccftrip() ->
           (long[] frow,
            int[] fcol,
            double[] fval)

Obtains the \(F\) (that would be implied by the ordering of the AFEs within the ACCs) in triplet format.

Parameters
  • frow (long[]) – Row indices of nonzeros in the implied F matrix. (output)

  • fcol (int[]) – Column indices of nonzeros in the implied F matrix. (output)

  • fval (double[]) – Values of nonzero entries in the implied F matrix. (output)

Return
  • frow (long[]) – Row indices of nonzeros in the implied F matrix.

  • fcol (int[]) – Column indices of nonzeros in the implied F matrix.

  • fval (double[]) – Values of nonzero entries in the implied F matrix.

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getaccgvector
getaccgvector(double[] g)
getaccgvector() -> double[] g

If the AFEs are passed out of sequence to the ACCs, then this function can be used to obtain the vector \(g\) of constant terms used within the ACCs.

Parameters

g (double[]) – The \(g\) used within the ACCs as a dense vector. The length is sum of the dimensions of the ACCs. (output)

Return

g (double[]) – The \(g\) used within the ACCs as a dense vector. The length is sum of the dimensions of the ACCs.

Groups

Inspecting the task, Problem data - affine conic constraints

Task.getaccn
getaccn(long accidx,
        out long n)
getaccn(long accidx) -> long n

Obtains the dimension of the affine conic constraint.

Parameters
  • accidx (long) – The index of the affine conic constraint. (input)

  • n (long) – The dimension of the affine conic constraint (equal to the dimension of its domain). (output)

Return

n (long) – The dimension of the affine conic constraint (equal to the dimension of its domain).

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getaccname
getaccname(long accidx,
           StringBuilder name)
getaccname(long accidx) -> string name

Obtains the name of an affine conic constraint.

Parameters
  • accidx (long) – Index of an affine conic constraint. (input)

  • name (StringBuilder) – Returns the required name. (output)

Return

name (string) – Returns the required name.

Groups

Names, Problem data - affine conic constraints, Inspecting the task

Task.getaccnamelen
getaccnamelen(long accidx,
              out int len)
getaccnamelen(long accidx) -> int len

Obtains the length of the name of an affine conic constraint.

Parameters
  • accidx (long) – Index of an affine conic constraint. (input)

  • len (int) – Returns the length of the indicated name. (output)

Return

len (int) – Returns the length of the indicated name.

Groups

Names, Problem data - affine conic constraints, Inspecting the task

Task.getaccntot
getaccntot(out long n)
getaccntot() -> long n

Obtains the total dimension of all affine conic constraints (the sum of all their dimensions).

Parameters

n (long) – The total dimension of all affine conic constraints. (output)

Return

n (long) – The total dimension of all affine conic constraints.

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getaccs
getaccs(long[] domidxlist,
        long[] afeidxlist,
        double[] b)
getaccs() ->
       (long[] domidxlist,
        long[] afeidxlist,
        double[] b)

Obtains full data of all affine conic constraints. The output array domainidxlist must have at least length determined by Task.getnumacc. The output arrays afeidxlist and b must have at least length determined by Task.getaccntot.

Parameters
  • domidxlist (long[]) – The list of domains appearing in all affine conic constraints. (output)

  • afeidxlist (long[]) – The concatenation of index lists of affine expressions appearing in all affine conic constraints. (output)

  • b (double[]) – The concatenation of vectors b appearing in all affine conic constraints. (output)

Return
  • domidxlist (long[]) – The list of domains appearing in all affine conic constraints.

  • afeidxlist (long[]) – The concatenation of index lists of affine expressions appearing in all affine conic constraints.

  • b (double[]) – The concatenation of vectors b appearing in all affine conic constraints.

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getacol
getacol(int j,
        out int nzj,
        int[] subj,
        double[] valj)
getacol(int j) ->
       (int nzj,
        int[] subj,
        double[] valj)

Obtains one column of \(A\) in a sparse format.

Parameters
  • j (int) – Index of the column. (input)

  • nzj (int) – Number of non-zeros in the column obtained. (output)

  • subj (int[]) – Row indices of the non-zeros in the column obtained. (output)

  • valj (double[]) – Numerical values in the column obtained. (output)

Return
  • nzj (int) – Number of non-zeros in the column obtained.

  • subj (int[]) – Row indices of the non-zeros in the column obtained.

  • valj (double[]) – Numerical values in the column obtained.

Groups

Problem data - linear part, Inspecting the task

Task.getacolnumnz
getacolnumnz(int i,
             out int nzj)
getacolnumnz(int i) -> int nzj

Obtains the number of non-zero elements in one column of \(A\).

Parameters
  • i (int) – Index of the column. (input)

  • nzj (int) – Number of non-zeros in the \(j\)-th column of \(A\). (output)

Return

nzj (int) – Number of non-zeros in the \(j\)-th column of \(A\).

Groups

Problem data - linear part, Inspecting the task

Task.getacolslice
getacolslice(int first,
             int last,
             long[] ptrb,
             long[] ptre,
             int[] sub,
             double[] val)
getacolslice(int first,
             int last) ->
            (long[] ptrb,
             long[] ptre,
             int[] sub,
             double[] val)

Obtains a sequence of columns from \(A\) in sparse format.

Parameters
  • first (int) – Index of the first column in the sequence. (input)

  • last (int) – Index of the last column in the sequence plus one. (input)

  • ptrb (long[]) – ptrb[t] is an index pointing to the first element in the \(t\)-th column obtained. (output)

  • ptre (long[]) – ptre[t] is an index pointing to the last element plus one in the \(t\)-th column obtained. (output)

  • sub (int[]) – Contains the row subscripts. (output)

  • val (double[]) – Contains the coefficient values. (output)

Return
  • ptrb (long[]) – ptrb[t] is an index pointing to the first element in the \(t\)-th column obtained.

  • ptre (long[]) – ptre[t] is an index pointing to the last element plus one in the \(t\)-th column obtained.

  • sub (int[]) – Contains the row subscripts.

  • val (double[]) – Contains the coefficient values.

Groups

Problem data - linear part, Inspecting the task

Task.getacolslicenumnz
getacolslicenumnz(int first,
                  int last,
                  out long numnz)
getacolslicenumnz(int first,
                  int last) -> long numnz

Obtains the number of non-zeros in a slice of columns of \(A\).

Parameters
  • first (int) – Index of the first column in the sequence. (input)

  • last (int) – Index of the last column plus one in the sequence. (input)

  • numnz (long) – Number of non-zeros in the slice. (output)

Return

numnz (long) – Number of non-zeros in the slice.

Groups

Problem data - linear part, Inspecting the task

Task.getacolslicetrip
getacolslicetrip(int first,
                 int last,
                 int[] subi,
                 int[] subj,
                 double[] val)
getacolslicetrip(int first,
                 int last) ->
                (int[] subi,
                 int[] subj,
                 double[] val)

Obtains a sequence of columns from \(A\) in sparse triplet format. The function returns the content of all columns whose index j satisfies first <= j < last. The triplets corresponding to nonzero entries are stored in the arrays subi, subj and val.

Parameters
  • first (int) – Index of the first column in the sequence. (input)

  • last (int) – Index of the last column in the sequence plus one. (input)

  • subi (int[]) – Constraint subscripts. (output)

  • subj (int[]) – Column subscripts. (output)

  • val (double[]) – Values. (output)

Return
  • subi (int[]) – Constraint subscripts.

  • subj (int[]) – Column subscripts.

  • val (double[]) – Values.

Groups

Problem data - linear part, Inspecting the task

Task.getafebarfblocktriplet
getafebarfblocktriplet(out long numtrip,
                       long[] afeidx,
                       int[] barvaridx,
                       int[] subk,
                       int[] subl,
                       double[] valkl)
getafebarfblocktriplet(long[] afeidx,
                       int[] barvaridx,
                       int[] subk,
                       int[] subl,
                       double[] valkl) -> long numtrip
getafebarfblocktriplet() ->
                      (long numtrip,
                       long[] afeidx,
                       int[] barvaridx,
                       int[] subk,
                       int[] subl,
                       double[] valkl)

Obtains \(\barF\) in block triplet form.

Parameters
  • numtrip (long) – Number of elements in the block triplet form. (output)

  • afeidx (long[]) – Constraint index. (output)

  • barvaridx (int[]) – Symmetric matrix variable index. (output)

  • subk (int[]) – Block row index. (output)

  • subl (int[]) – Block column index. (output)

  • valkl (double[]) – The numerical value associated with each block triplet. (output)

Return
  • numtrip (long) – Number of elements in the block triplet form.

  • afeidx (long[]) – Constraint index.

  • barvaridx (int[]) – Symmetric matrix variable index.

  • subk (int[]) – Block row index.

  • subl (int[]) – Block column index.

  • valkl (double[]) – The numerical value associated with each block triplet.

Groups

Problem data - affine expressions, Problem data - semidefinite

Task.getafebarfnumblocktriplets
getafebarfnumblocktriplets(out long numtrip)
getafebarfnumblocktriplets() -> long numtrip

Obtains an upper bound on the number of elements in the block triplet form of \(\barF\).

Parameters

numtrip (long) – An upper bound on the number of elements in the block triplet form of \(\barF.\) (output)

Return

numtrip (long) – An upper bound on the number of elements in the block triplet form of \(\barF.\)

Groups

Problem data - semidefinite, Inspecting the task

Task.getafebarfnumrowentries
getafebarfnumrowentries(long afeidx,
                        out int numentr)
getafebarfnumrowentries(long afeidx) -> int numentr

Obtains the number of nonzero entries in one row of \(\barF\), that is the number of \(j\) such that \(\barF_{\mathrm{afeidx},j}\) is not the zero matrix.

Parameters
  • afeidx (long) – Row index of \(\barF\). (input)

  • numentr (int) – Number of nonzero entries in a row of \(\barF\). (output)

Return

numentr (int) – Number of nonzero entries in a row of \(\barF\).

Groups

Problem data - affine expressions, Problem data - semidefinite, Inspecting the task

Task.getafebarfrow
getafebarfrow(long afeidx,
              int[] barvaridx,
              long[] ptrterm,
              long[] numterm,
              long[] termidx,
              double[] termweight)
getafebarfrow(long afeidx) ->
             (int[] barvaridx,
              long[] ptrterm,
              long[] numterm,
              long[] termidx,
              double[] termweight)

Obtains all nonzero entries in one row \(\barF_{\mathrm{afeidx},*}\) of \(\barF\). For every \(k\) there is a nonzero entry \(\barF_{\mathrm{afeidx}, \mathrm{barvaridx}[k]}\), which is represented as a weighted sum of \(\mathrm{numterm}[k]\) terms. The indices in the matrix store \(E\) and their weights for the \(k\)-th entry appear in the arrays termidx and termweight in positions

\[\mathrm{ptrterm}[k],\ldots,\mathrm{ptrterm}[k]+\mathrm{numterm}[k]-1.\]

The arrays should be long enough to accommodate the data; their required lengths can be obtained with Task.getafebarfrowinfo.

Parameters
  • afeidx (long) – Row index of \(\barF\). (input)

  • barvaridx (int[]) – Semidefinite variable indices of nonzero entries in the row of \(\barF\). (output)

  • ptrterm (long[]) – Pointers to the start of each entry’s description. (output)

  • numterm (long[]) – Number of terms in the weighted sum representation of each entry. (output)

  • termidx (long[]) – Indices of semidefinite matrices from the matrix store \(E\). (output)

  • termweight (double[]) – Weights appearing in the weighted sum representations of all entries. (output)

Return
  • barvaridx (int[]) – Semidefinite variable indices of nonzero entries in the row of \(\barF\).

  • ptrterm (long[]) – Pointers to the start of each entry’s description.

  • numterm (long[]) – Number of terms in the weighted sum representation of each entry.

  • termidx (long[]) – Indices of semidefinite matrices from the matrix store \(E\).

  • termweight (double[]) – Weights appearing in the weighted sum representations of all entries.

Groups

Problem data - affine expressions, Problem data - semidefinite, Inspecting the task

Task.getafebarfrowinfo
getafebarfrowinfo(long afeidx,
                  out int numentr,
                  out long numterm)
getafebarfrowinfo(long afeidx) ->
                 (int numentr,
                  long numterm)

Obtains information about one row of \(\barF\): the number of nonzero entries, that is the number of \(j\) such that \(\barF_{\mathrm{afeidx},j}\) is not the zero matrix, as well as the total number of terms in the representations of all these entries as weighted sums of matrices from \(E\). This information provides the data sizes required for a call to Task.getafebarfrow.

Parameters
  • afeidx (long) – Row index of \(\barF\). (input)

  • numentr (int) – Number of nonzero entries in a row of \(\barF\). (output)

  • numterm (long) – Number of terms in the weighted sums representation of the row of \(\barF\). (output)

Return
  • numentr (int) – Number of nonzero entries in a row of \(\barF\).

  • numterm (long) – Number of terms in the weighted sums representation of the row of \(\barF\).

Groups

Problem data - affine expressions, Problem data - semidefinite, Inspecting the task

Task.getafefnumnz
getafefnumnz(out long numnz)
getafefnumnz() -> long numnz

Obtains the total number of nonzeros in \(F\).

Parameters

numnz (long) – Number of non-zeros in \(F\). (output)

Return

numnz (long) – Number of non-zeros in \(F\).

Groups

Problem data - affine expressions, Inspecting the task

Task.getafefrow
getafefrow(long afeidx,
           out int numnz,
           int[] varidx,
           double[] val)
getafefrow(long afeidx) ->
          (int numnz,
           int[] varidx,
           double[] val)

Obtains one row of \(F\) in sparse format.

Parameters
  • afeidx (long) – Index of a row in \(F\). (input)

  • numnz (int) – Number of non-zeros in the row obtained. (output)

  • varidx (int[]) – Column indices of the non-zeros in the row obtained. (output)

  • val (double[]) – Values of the non-zeros in the row obtained. (output)

Return
  • numnz (int) – Number of non-zeros in the row obtained.

  • varidx (int[]) – Column indices of the non-zeros in the row obtained.

  • val (double[]) – Values of the non-zeros in the row obtained.

Groups

Problem data - affine expressions, Inspecting the task

Task.getafefrownumnz
getafefrownumnz(long afeidx,
                out int numnz)
getafefrownumnz(long afeidx) -> int numnz

Obtains the number of nonzeros in one row of \(F\).

Parameters
  • afeidx (long) – Index of a row in \(F\). (input)

  • numnz (int) – Number of non-zeros in row afeidx of \(F\). (output)

Return

numnz (int) – Number of non-zeros in row afeidx of \(F\).

Groups

Problem data - affine expressions, Inspecting the task

Task.getafeftrip
getafeftrip(long[] afeidx,
            int[] varidx,
            double[] val)
getafeftrip() ->
           (long[] afeidx,
            int[] varidx,
            double[] val)

Obtains the \(F\) in triplet format.

Parameters
  • afeidx (long[]) – Row indices of nonzeros. (output)

  • varidx (int[]) – Column indices of nonzeros. (output)

  • val (double[]) – Values of nonzero entries. (output)

Return
  • afeidx (long[]) – Row indices of nonzeros.

  • varidx (int[]) – Column indices of nonzeros.

  • val (double[]) – Values of nonzero entries.

Groups

Problem data - affine expressions, Inspecting the task

Task.getafeg
getafeg(long afeidx,
        out double g)
getafeg(long afeidx) -> double g

Obtains a single coefficient in \(g\).

Parameters
  • afeidx (long) – Index of an element in \(g\). (input)

  • g (double) – The value of \(g_{\mathrm{afeidx}}\). (output)

Return

g (double) – The value of \(g_{\mathrm{afeidx}}\).

Groups

Problem data - affine expressions, Inspecting the task

Task.getafegslice
getafegslice(long first,
             long last,
             double[] g)
getafegslice(long first,
             long last) -> double[] g

Obtains a sequence of elements from the vector \(g\) of constant terms in the affine expressions list.

Parameters
  • first (long) – First index in the sequence. (input)

  • last (long) – Last index plus 1 in the sequence. (input)

  • g (double[]) – The slice \(g\) as a dense vector. The length is last-first. (output)

Return

g (double[]) – The slice \(g\) as a dense vector. The length is last-first.

Groups

Inspecting the task, Problem data - affine expressions

Task.getaij
getaij(int i,
       int j,
       out double aij)
getaij(int i,
       int j) -> double aij

Obtains a single coefficient in \(A\).

Parameters
  • i (int) – Row index of the coefficient to be returned. (input)

  • j (int) – Column index of the coefficient to be returned. (input)

  • aij (double) – The required coefficient \(a_{i,j}\). (output)

Return

aij (double) – The required coefficient \(a_{i,j}\).

Groups

Problem data - linear part, Inspecting the task

Task.getapiecenumnz
getapiecenumnz(int firsti,
               int lasti,
               int firstj,
               int lastj,
               out int numnz)
getapiecenumnz(int firsti,
               int lasti,
               int firstj,
               int lastj) -> int numnz

Obtains the number non-zeros in a rectangular piece of \(A\), i.e. the number of elements in the set

\[\{ (i,j)~:~ a_{i,j} \neq 0,~ \mathtt{firsti} \leq i \leq \mathtt{lasti}-1, ~\mathtt{firstj} \leq j \leq \mathtt{lastj}-1\}\]

This function is not an efficient way to obtain the number of non-zeros in one row or column. In that case use the function Task.getarownumnz or Task.getacolnumnz.

Parameters
  • firsti (int) – Index of the first row in the rectangular piece. (input)

  • lasti (int) – Index of the last row plus one in the rectangular piece. (input)

  • firstj (int) – Index of the first column in the rectangular piece. (input)

  • lastj (int) – Index of the last column plus one in the rectangular piece. (input)

  • numnz (int) – Number of non-zero \(A\) elements in the rectangular piece. (output)

Return

numnz (int) – Number of non-zero \(A\) elements in the rectangular piece.

Groups

Problem data - linear part, Inspecting the task

Task.getarow
getarow(int i,
        out int nzi,
        int[] subi,
        double[] vali)
getarow(int i) ->
       (int nzi,
        int[] subi,
        double[] vali)

Obtains one row of \(A\) in a sparse format.

Parameters
  • i (int) – Index of the row. (input)

  • nzi (int) – Number of non-zeros in the row obtained. (output)

  • subi (int[]) – Column indices of the non-zeros in the row obtained. (output)

  • vali (double[]) – Numerical values of the row obtained. (output)

Return
  • nzi (int) – Number of non-zeros in the row obtained.

  • subi (int[]) – Column indices of the non-zeros in the row obtained.

  • vali (double[]) – Numerical values of the row obtained.

Groups

Problem data - linear part, Inspecting the task

Task.getarownumnz
getarownumnz(int i,
             out int nzi)
getarownumnz(int i) -> int nzi

Obtains the number of non-zero elements in one row of \(A\).

Parameters
  • i (int) – Index of the row. (input)

  • nzi (int) – Number of non-zeros in the \(i\)-th row of \(A\). (output)

Return

nzi (int) – Number of non-zeros in the \(i\)-th row of \(A\).

Groups

Problem data - linear part, Inspecting the task

Task.getarowslice
getarowslice(int first,
             int last,
             long[] ptrb,
             long[] ptre,
             int[] sub,
             double[] val)
getarowslice(int first,
             int last) ->
            (long[] ptrb,
             long[] ptre,
             int[] sub,
             double[] val)

Obtains a sequence of rows from \(A\) in sparse format.

Parameters
  • first (int) – Index of the first row in the sequence. (input)

  • last (int) – Index of the last row in the sequence plus one. (input)

  • ptrb (long[]) – ptrb[t] is an index pointing to the first element in the \(t\)-th row obtained. (output)

  • ptre (long[]) – ptre[t] is an index pointing to the last element plus one in the \(t\)-th row obtained. (output)

  • sub (int[]) – Contains the column subscripts. (output)

  • val (double[]) – Contains the coefficient values. (output)

Return
  • ptrb (long[]) – ptrb[t] is an index pointing to the first element in the \(t\)-th row obtained.

  • ptre (long[]) – ptre[t] is an index pointing to the last element plus one in the \(t\)-th row obtained.

  • sub (int[]) – Contains the column subscripts.

  • val (double[]) – Contains the coefficient values.

Groups

Problem data - linear part, Inspecting the task

Task.getarowslicenumnz
getarowslicenumnz(int first,
                  int last,
                  out long numnz)
getarowslicenumnz(int first,
                  int last) -> long numnz

Obtains the number of non-zeros in a slice of rows of \(A\).

Parameters
  • first (int) – Index of the first row in the sequence. (input)

  • last (int) – Index of the last row plus one in the sequence. (input)

  • numnz (long) – Number of non-zeros in the slice. (output)

Return

numnz (long) – Number of non-zeros in the slice.

Groups

Problem data - linear part, Inspecting the task

Task.getarowslicetrip
getarowslicetrip(int first,
                 int last,
                 int[] subi,
                 int[] subj,
                 double[] val)
getarowslicetrip(int first,
                 int last) ->
                (int[] subi,
                 int[] subj,
                 double[] val)

Obtains a sequence of rows from \(A\) in sparse triplet format. The function returns the content of all rows whose index i satisfies first <= i < last. The triplets corresponding to nonzero entries are stored in the arrays subi, subj and val.

Parameters
  • first (int) – Index of the first row in the sequence. (input)

  • last (int) – Index of the last row in the sequence plus one. (input)

  • subi (int[]) – Constraint subscripts. (output)

  • subj (int[]) – Column subscripts. (output)

  • val (double[]) – Values. (output)

Return
  • subi (int[]) – Constraint subscripts.

  • subj (int[]) – Column subscripts.

  • val (double[]) – Values.

Groups

Problem data - linear part, Inspecting the task

Task.getatrip
getatrip(int[] subi,
         int[] subj,
         double[] val)
getatrip() ->
        (int[] subi,
         int[] subj,
         double[] val)

Obtains \(A\) in sparse triplet format. The triplets corresponding to nonzero entries are stored in the arrays subi, subj and val.

Parameters
  • subi (int[]) – Constraint subscripts. (output)

  • subj (int[]) – Column subscripts. (output)

  • val (double[]) – Values. (output)

Return
  • subi (int[]) – Constraint subscripts.

  • subj (int[]) – Column subscripts.

  • val (double[]) – Values.

Groups

Problem data - linear part, Inspecting the task

Task.getatruncatetol
getatruncatetol(double[] tolzero)
getatruncatetol() -> double[] tolzero

Obtains the tolerance value set with Task.putatruncatetol.

Parameters

tolzero (double[]) – All elements \(|a_{i,j}|\) less than this tolerance is truncated to zero. (output)

Return

tolzero (double[]) – All elements \(|a_{i,j}|\) less than this tolerance is truncated to zero.

Groups

Parameters, Problem data - linear part

Task.getbarablocktriplet
getbarablocktriplet(out long num,
                    int[] subi,
                    int[] subj,
                    int[] subk,
                    int[] subl,
                    double[] valijkl)
getbarablocktriplet(int[] subi,
                    int[] subj,
                    int[] subk,
                    int[] subl,
                    double[] valijkl) -> long num
getbarablocktriplet() ->
                   (long num,
                    int[] subi,
                    int[] subj,
                    int[] subk,
                    int[] subl,
                    double[] valijkl)

Obtains \(\barA\) in block triplet form.

Parameters
  • num (long) – Number of elements in the block triplet form. (output)

  • subi (int[]) – Constraint index. (output)

  • subj (int[]) – Symmetric matrix variable index. (output)

  • subk (int[]) – Block row index. (output)

  • subl (int[]) – Block column index. (output)

  • valijkl (double[]) – The numerical value associated with each block triplet. (output)

Return
  • num (long) – Number of elements in the block triplet form.

  • subi (int[]) – Constraint index.

  • subj (int[]) – Symmetric matrix variable index.

  • subk (int[]) – Block row index.

  • subl (int[]) – Block column index.

  • valijkl (double[]) – The numerical value associated with each block triplet.

Groups

Problem data - semidefinite, Inspecting the task

Task.getbaraidx
getbaraidx(long idx,
           out int i,
           out int j,
           out long num,
           long[] sub,
           double[] weights)
getbaraidx(long idx,
           out int i,
           out int j,
           long[] sub,
           double[] weights) -> long num
getbaraidx(long idx) ->
          (int i,
           int j,
           long num,
           long[] sub,
           double[] weights)

Obtains information about an element in \(\barA\). Since \(\barA\) is a sparse matrix of symmetric matrices, only the nonzero elements in \(\barA\) are stored in order to save space. Now \(\barA\) is stored vectorized i.e. as one long vector. This function makes it possible to obtain information such as the row index and the column index of a particular element of the vectorized form of \(\barA\).

Please observe if one element of \(\barA\) is inputted multiple times then it may be stored several times in vectorized form. In that case the element with the highest index is the one that is used.

Parameters
  • idx (long) – Position of the element in the vectorized form. (input)

  • i (int) – Row index of the element at position idx. (output)

  • j (int) – Column index of the element at position idx. (output)

  • num (long) – Number of terms in weighted sum that forms the element. (output)

  • sub (long[]) – A list indexes of the elements from symmetric matrix storage that appear in the weighted sum. (output)

  • weights (double[]) – The weights associated with each term in the weighted sum. (output)

Return
  • num (long) – Number of terms in weighted sum that forms the element.

  • i (int) – Row index of the element at position idx.

  • j (int) – Column index of the element at position idx.

  • sub (long[]) – A list indexes of the elements from symmetric matrix storage that appear in the weighted sum.

  • weights (double[]) – The weights associated with each term in the weighted sum.

Groups

Problem data - semidefinite, Inspecting the task

Task.getbaraidxij
getbaraidxij(long idx,
             out int i,
             out int j)
getbaraidxij(long idx) ->
            (int i,
             int j)

Obtains information about an element in \(\barA\). Since \(\barA\) is a sparse matrix of symmetric matrices, only the nonzero elements in \(\barA\) are stored in order to save space. Now \(\barA\) is stored vectorized i.e. as one long vector. This function makes it possible to obtain information such as the row index and the column index of a particular element of the vectorized form of \(\barA\).

Please note that if one element of \(\barA\) is inputted multiple times then it may be stored several times in vectorized form. In that case the element with the highest index is the one that is used.

Parameters
  • idx (long) – Position of the element in the vectorized form. (input)

  • i (int) – Row index of the element at position idx. (output)

  • j (int) – Column index of the element at position idx. (output)

Return
  • i (int) – Row index of the element at position idx.

  • j (int) – Column index of the element at position idx.

Groups

Problem data - semidefinite, Inspecting the task

Task.getbaraidxinfo
getbaraidxinfo(long idx,
               out long num)
getbaraidxinfo(long idx) -> long num

Each nonzero element in \(\barA_{ij}\) is formed as a weighted sum of symmetric matrices. Using this function the number of terms in the weighted sum can be obtained. See description of Task.appendsparsesymmat for details about the weighted sum.

Parameters
  • idx (long) – The internal position of the element for which information should be obtained. (input)

  • num (long) – Number of terms in the weighted sum that form the specified element in \(\barA\). (output)

Return

num (long) – Number of terms in the weighted sum that form the specified element in \(\barA\).

Groups

Problem data - semidefinite, Inspecting the task

Task.getbarasparsity
getbarasparsity(out long numnz,
                long[] idxij)
getbarasparsity() ->
               (long numnz,
                long[] idxij)

The matrix \(\barA\) is assumed to be a sparse matrix of symmetric matrices. This implies that many of the elements in \(\barA\) are likely to be zero matrices. Therefore, in order to save space, only nonzero elements in \(\barA\) are stored on vectorized form. This function is used to obtain the sparsity pattern of \(\barA\) and the position of each nonzero element in the vectorized form of \(\barA\). From the index detailed information about each nonzero \(\barA_{i,j}\) can be obtained using Task.getbaraidxinfo and Task.getbaraidx.

Parameters
  • numnz (long) – Number of nonzero elements in \(\barA\). (output)

  • idxij (long[]) – Position of each nonzero element in the vectorized form of \(\barA\). (output)

Return
  • numnz (long) – Number of nonzero elements in \(\barA\).

  • idxij (long[]) – Position of each nonzero element in the vectorized form of \(\barA\).

Groups

Problem data - semidefinite, Inspecting the task

Task.getbarcblocktriplet
getbarcblocktriplet(out long num,
                    int[] subj,
                    int[] subk,
                    int[] subl,
                    double[] valjkl)
getbarcblocktriplet(int[] subj,
                    int[] subk,
                    int[] subl,
                    double[] valjkl) -> long num
getbarcblocktriplet() ->
                   (long num,
                    int[] subj,
                    int[] subk,
                    int[] subl,
                    double[] valjkl)

Obtains \(\barC\) in block triplet form.

Parameters
  • num (long) – Number of elements in the block triplet form. (output)

  • subj (int[]) – Symmetric matrix variable index. (output)

  • subk (int[]) – Block row index. (output)

  • subl (int[]) – Block column index. (output)

  • valjkl (double[]) – The numerical value associated with each block triplet. (output)

Return
  • num (long) – Number of elements in the block triplet form.

  • subj (int[]) – Symmetric matrix variable index.

  • subk (int[]) – Block row index.

  • subl (int[]) – Block column index.

  • valjkl (double[]) – The numerical value associated with each block triplet.

Groups

Problem data - semidefinite, Inspecting the task

Task.getbarcidx
getbarcidx(long idx,
           out int j,
           out long num,
           long[] sub,
           double[] weights)
getbarcidx(long idx) ->
          (int j,
           long num,
           long[] sub,
           double[] weights)

Obtains information about an element in \(\barC\).

Parameters
  • idx (long) – Index of the element for which information should be obtained. (input)

  • j (int) – Row index in \(\barC\). (output)

  • num (long) – Number of terms in the weighted sum. (output)

  • sub (long[]) – Elements appearing the weighted sum. (output)

  • weights (double[]) – Weights of terms in the weighted sum. (output)

Return
  • j (int) – Row index in \(\barC\).

  • num (long) – Number of terms in the weighted sum.

  • sub (long[]) – Elements appearing the weighted sum.

  • weights (double[]) – Weights of terms in the weighted sum.

Groups

Problem data - semidefinite, Inspecting the task

Task.getbarcidxinfo
getbarcidxinfo(long idx,
               out long num)
getbarcidxinfo(long idx) -> long num

Obtains the number of terms in the weighted sum that forms a particular element in \(\barC\).

Parameters
  • idx (long) – Index of the element for which information should be obtained. The value is an index of a symmetric sparse variable. (input)

  • num (long) – Number of terms that appear in the weighted sum that forms the requested element. (output)

Return

num (long) – Number of terms that appear in the weighted sum that forms the requested element.

Groups

Problem data - semidefinite, Inspecting the task

Task.getbarcidxj
getbarcidxj(long idx,
            out int j)
getbarcidxj(long idx) -> int j

Obtains the row index of an element in \(\barC\).

Parameters
  • idx (long) – Index of the element for which information should be obtained. (input)

  • j (int) – Row index in \(\barC\). (output)

Return

j (int) – Row index in \(\barC\).

Groups

Problem data - semidefinite, Inspecting the task

Task.getbarcsparsity
getbarcsparsity(out long numnz,
                long[] idxj)
getbarcsparsity() ->
               (long numnz,
                long[] idxj)

Internally only the nonzero elements of \(\barC\) are stored in a vector. This function is used to obtain the nonzero elements of \(\barC\) and their indexes in the internal vector representation (in idx). From the index detailed information about each nonzero \(\barC_j\) can be obtained using Task.getbarcidxinfo and Task.getbarcidx.

Parameters
  • numnz (long) – Number of nonzero elements in \(\barC\). (output)

  • idxj (long[]) – Internal positions of the nonzeros elements in \(\barC\). (output)

Return
  • numnz (long) – Number of nonzero elements in \(\barC\).

  • idxj (long[]) – Internal positions of the nonzeros elements in \(\barC\).

Groups

Problem data - semidefinite, Inspecting the task

Task.getbarsj
getbarsj(soltype whichsol,
         int j,
         double[] barsj)
getbarsj(soltype whichsol,
         int j) -> double[] barsj

Obtains the dual solution for a semidefinite variable. Only the lower triangular part of \(\barS_j\) is returned because the matrix by construction is symmetric. The format is that the columns are stored sequentially in the natural order.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • j (int) – Index of the semidefinite variable. (input)

  • barsj (double[]) – Value of \(\barS_j\). (output)

Return

barsj (double[]) – Value of \(\barS_j\).

Groups

Solution - semidefinite

Task.getbarsslice
getbarsslice(soltype whichsol,
             int first,
             int last,
             long slicesize,
             double[] barsslice)
getbarsslice(soltype whichsol,
             int first,
             int last,
             long slicesize) -> double[] barsslice

Obtains the dual solution for a sequence of semidefinite variables. The format is that matrices are stored sequentially, and in each matrix the columns are stored as in Task.getbarsj.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – Index of the first semidefinite variable in the slice. (input)

  • last (int) – Index of the last semidefinite variable in the slice plus one. (input)

  • slicesize (long) – Denotes the length of the array barsslice. (input)

  • barsslice (double[]) – Dual solution values of symmetric matrix variables in the slice, stored sequentially. (output)

Return

barsslice (double[]) – Dual solution values of symmetric matrix variables in the slice, stored sequentially.

Groups

Solution - semidefinite

Task.getbarvarname
getbarvarname(int i,
              StringBuilder name)
getbarvarname(int i) -> string name

Obtains the name of a semidefinite variable.

Parameters
  • i (int) – Index of the variable. (input)

  • name (StringBuilder) – The requested name is copied to this buffer. (output)

Return

name (string) – The requested name is copied to this buffer.

Groups

Names, Inspecting the task

Task.getbarvarnameindex
getbarvarnameindex(string somename,
                   out int asgn,
                   out int index)
getbarvarnameindex(string somename,
                   out int asgn) -> int index
getbarvarnameindex(string somename) ->
                  (int asgn,
                   int index)

Obtains the index of semidefinite variable from its name.

Parameters
  • somename (string) – The name of the variable. (input)

  • asgn (int) – Non-zero if the name somename is assigned to some semidefinite variable. (output)

  • index (int) – The index of a semidefinite variable with the name somename (if one exists). (output)

Return
  • index (int) – The index of a semidefinite variable with the name somename (if one exists).

  • asgn (int) – Non-zero if the name somename is assigned to some semidefinite variable.

Groups

Names, Inspecting the task

Task.getbarvarnamelen
getbarvarnamelen(int i,
                 out int len)
getbarvarnamelen(int i) -> int len

Obtains the length of the name of a semidefinite variable.

Parameters
  • i (int) – Index of the variable. (input)

  • len (int) – Returns the length of the indicated name. (output)

Return

len (int) – Returns the length of the indicated name.

Groups

Names, Inspecting the task

Task.getbarxj
getbarxj(soltype whichsol,
         int j,
         double[] barxj)
getbarxj(soltype whichsol,
         int j) -> double[] barxj

Obtains the primal solution for a semidefinite variable. Only the lower triangular part of \(\barX_j\) is returned because the matrix by construction is symmetric. The format is that the columns are stored sequentially in the natural order.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • j (int) – Index of the semidefinite variable. (input)

  • barxj (double[]) – Value of \(\barX_j\). (output)

Return

barxj (double[]) – Value of \(\barX_j\).

Groups

Solution - semidefinite

Task.getbarxslice
getbarxslice(soltype whichsol,
             int first,
             int last,
             long slicesize,
             double[] barxslice)
getbarxslice(soltype whichsol,
             int first,
             int last,
             long slicesize) -> double[] barxslice

Obtains the primal solution for a sequence of semidefinite variables. The format is that matrices are stored sequentially, and in each matrix the columns are stored as in Task.getbarxj.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – Index of the first semidefinite variable in the slice. (input)

  • last (int) – Index of the last semidefinite variable in the slice plus one. (input)

  • slicesize (long) – Denotes the length of the array barxslice. (input)

  • barxslice (double[]) – Solution values of symmetric matrix variables in the slice, stored sequentially. (output)

Return

barxslice (double[]) – Solution values of symmetric matrix variables in the slice, stored sequentially.

Groups

Solution - semidefinite

Task.getc
getc(double[] c)
getc() -> double[] c

Obtains all objective coefficients \(c\).

Parameters

c (double[]) – Linear terms of the objective as a dense vector. The length is the number of variables. (output)

Return

c (double[]) – Linear terms of the objective as a dense vector. The length is the number of variables.

Groups

Problem data - linear part, Inspecting the task, Problem data - variables

Task.getcfix
getcfix(out double cfix)
getcfix() -> double cfix

Obtains the fixed term in the objective.

Parameters

cfix (double) – Fixed term in the objective. (output)

Return

cfix (double) – Fixed term in the objective.

Groups

Problem data - linear part, Inspecting the task

Task.getcj
getcj(int j,
      out double cj)
getcj(int j) -> double cj

Obtains one coefficient of \(c\).

Parameters
  • j (int) – Index of the variable for which the \(c\) coefficient should be obtained. (input)

  • cj (double) – The value of \(c_j\). (output)

Return

cj (double) – The value of \(c_j\).

Groups

Problem data - linear part, Inspecting the task, Problem data - variables

Task.getclist
getclist(int[] subj,
         double[] c)
getclist(int[] subj) -> double[] c

Obtains a sequence of elements in \(c\).

Parameters
  • subj (int[]) – A list of variable indexes. (input)

  • c (double[]) – Linear terms of the requested list of the objective as a dense vector. (output)

Return

c (double[]) – Linear terms of the requested list of the objective as a dense vector.

Groups

Inspecting the task, Problem data - linear part

Task.getconbound
getconbound(int i,
            out boundkey bk,
            out double bl,
            out double bu)
getconbound(int i) ->
           (boundkey bk,
            double bl,
            double bu)

Obtains bound information for one constraint.

Parameters
  • i (int) – Index of the constraint for which the bound information should be obtained. (input)

  • bk (mosek.boundkey) – Bound keys. (output)

  • bl (double) – Values for lower bounds. (output)

  • bu (double) – Values for upper bounds. (output)

Return
  • bk (mosek.boundkey) – Bound keys.

  • bl (double) – Values for lower bounds.

  • bu (double) – Values for upper bounds.

Groups

Problem data - linear part, Inspecting the task, Problem data - bounds, Problem data - constraints

Task.getconboundslice
getconboundslice(int first,
                 int last,
                 boundkey[] bk,
                 double[] bl,
                 double[] bu)
getconboundslice(int first,
                 int last) ->
                (boundkey[] bk,
                 double[] bl,
                 double[] bu)

Obtains bounds information for a slice of the constraints.

Parameters
  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • bk (mosek.boundkey[]) – Bound keys. (output)

  • bl (double[]) – Values for lower bounds. (output)

  • bu (double[]) – Values for upper bounds. (output)

Return
  • bk (mosek.boundkey[]) – Bound keys.

  • bl (double[]) – Values for lower bounds.

  • bu (double[]) – Values for upper bounds.

Groups

Problem data - linear part, Inspecting the task, Problem data - bounds, Problem data - constraints

Task.getcone Deprecated
getcone(int k,
        out conetype ct,
        out double conepar,
        out int nummem,
        int[] submem)
getcone(int k) ->
       (conetype ct,
        double conepar,
        int nummem,
        int[] submem)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Parameters
  • k (int) – Index of the cone. (input)

  • ct (mosek.conetype) – Specifies the type of the cone. (output)

  • conepar (double) – For the power cone it denotes the exponent alpha. For other cone types it is unused and can be set to 0. (output)

  • nummem (int) – Number of member variables in the cone. (output)

  • submem (int[]) – Variable subscripts of the members in the cone. (output)

Return
  • ct (mosek.conetype) – Specifies the type of the cone.

  • conepar (double) – For the power cone it denotes the exponent alpha. For other cone types it is unused and can be set to 0.

  • nummem (int) – Number of member variables in the cone.

  • submem (int[]) – Variable subscripts of the members in the cone.

Groups

Inspecting the task, Problem data - cones (deprecated)

Task.getconeinfo Deprecated
getconeinfo(int k,
            out conetype ct,
            out double conepar,
            out int nummem)
getconeinfo(int k) ->
           (conetype ct,
            double conepar,
            int nummem)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Parameters
  • k (int) – Index of the cone. (input)

  • ct (mosek.conetype) – Specifies the type of the cone. (output)

  • conepar (double) – For the power cone it denotes the exponent alpha. For other cone types it is unused and can be set to 0. (output)

  • nummem (int) – Number of member variables in the cone. (output)

Return
  • ct (mosek.conetype) – Specifies the type of the cone.

  • conepar (double) – For the power cone it denotes the exponent alpha. For other cone types it is unused and can be set to 0.

  • nummem (int) – Number of member variables in the cone.

Groups

Inspecting the task, Problem data - cones (deprecated)

Task.getconename Deprecated
getconename(int i,
            StringBuilder name)
getconename(int i) -> string name

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Parameters
  • i (int) – Index of the cone. (input)

  • name (StringBuilder) – The required name. (output)

Return

name (string) – The required name.

Groups

Names, Problem data - cones (deprecated), Inspecting the task

Task.getconenameindex Deprecated
getconenameindex(string somename,
                 out int asgn,
                 out int index)
getconenameindex(string somename,
                 out int asgn) -> int index
getconenameindex(string somename) ->
                (int asgn,
                 int index)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Checks whether the name somename has been assigned to any cone. If it has been assigned to a cone, then the index of the cone is reported.

Parameters
  • somename (string) – The name which should be checked. (input)

  • asgn (int) – Is non-zero if the name somename is assigned to some cone. (output)

  • index (int) – If the name somename is assigned to some cone, then index is the index of the cone. (output)

Return
  • index (int) – If the name somename is assigned to some cone, then index is the index of the cone.

  • asgn (int) – Is non-zero if the name somename is assigned to some cone.

Groups

Names, Problem data - cones (deprecated), Inspecting the task

Task.getconenamelen Deprecated
getconenamelen(int i,
               out int len)
getconenamelen(int i) -> int len

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Parameters
  • i (int) – Index of the cone. (input)

  • len (int) – Returns the length of the indicated name. (output)

Return

len (int) – Returns the length of the indicated name.

Groups

Names, Problem data - cones (deprecated), Inspecting the task

Task.getconname
getconname(int i,
           StringBuilder name)
getconname(int i) -> string name

Obtains the name of a constraint.

Parameters
  • i (int) – Index of the constraint. (input)

  • name (StringBuilder) – The required name. (output)

Return

name (string) – The required name.

Groups

Names, Problem data - linear part, Problem data - constraints, Inspecting the task

Task.getconnameindex
getconnameindex(string somename,
                out int asgn,
                out int index)
getconnameindex(string somename,
                out int asgn) -> int index
getconnameindex(string somename) ->
               (int asgn,
                int index)

Checks whether the name somename has been assigned to any constraint. If so, the index of the constraint is reported.

Parameters
  • somename (string) – The name which should be checked. (input)

  • asgn (int) – Is non-zero if the name somename is assigned to some constraint. (output)

  • index (int) – If the name somename is assigned to a constraint, then index is the index of the constraint. (output)

Return
  • index (int) – If the name somename is assigned to a constraint, then index is the index of the constraint.

  • asgn (int) – Is non-zero if the name somename is assigned to some constraint.

Groups

Names, Problem data - linear part, Problem data - constraints, Inspecting the task

Task.getconnamelen
getconnamelen(int i,
              out int len)
getconnamelen(int i) -> int len

Obtains the length of the name of a constraint.

Parameters
  • i (int) – Index of the constraint. (input)

  • len (int) – Returns the length of the indicated name. (output)

Return

len (int) – Returns the length of the indicated name.

Groups

Names, Problem data - linear part, Problem data - constraints, Inspecting the task

Task.getcslice
getcslice(int first,
          int last,
          double[] c)
getcslice(int first,
          int last) -> double[] c

Obtains a sequence of elements in \(c\).

Parameters
  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • c (double[]) – Linear terms of the requested slice of the objective as a dense vector. The length is last-first. (output)

Return

c (double[]) – Linear terms of the requested slice of the objective as a dense vector. The length is last-first.

Groups

Inspecting the task, Problem data - linear part

Task.getdimbarvarj
getdimbarvarj(int j,
              out int dimbarvarj)
getdimbarvarj(int j) -> int dimbarvarj

Obtains the dimension of a symmetric matrix variable.

Parameters
  • j (int) – Index of the semidefinite variable whose dimension is requested. (input)

  • dimbarvarj (int) – The dimension of the \(j\)-th semidefinite variable. (output)

Return

dimbarvarj (int) – The dimension of the \(j\)-th semidefinite variable.

Groups

Inspecting the task, Problem data - semidefinite

Task.getdjcafeidxlist
getdjcafeidxlist(long djcidx,
                 long[] afeidxlist)
getdjcafeidxlist(long djcidx) -> long[] afeidxlist

Obtains the list of affine expression indexes in a disjunctive constraint.

Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • afeidxlist (long[]) – List of affine expression indexes. (output)

Return

afeidxlist (long[]) – List of affine expression indexes.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcb
getdjcb(long djcidx,
        double[] b)
getdjcb(long djcidx) -> double[] b

Obtains the optional constant term vector of a disjunctive constraint.

Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • b (double[]) – The vector b. (output)

Return

b (double[]) – The vector b.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcdomainidxlist
getdjcdomainidxlist(long djcidx,
                    long[] domidxlist)
getdjcdomainidxlist(long djcidx) -> long[] domidxlist

Obtains the list of domain indexes in a disjunctive constraint.

Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • domidxlist (long[]) – List of term sizes. (output)

Return

domidxlist (long[]) – List of term sizes.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcname
getdjcname(long djcidx,
           StringBuilder name)
getdjcname(long djcidx) -> string name

Obtains the name of a disjunctive constraint.

Parameters
  • djcidx (long) – Index of a disjunctive constraint. (input)

  • name (StringBuilder) – Returns the required name. (output)

Return

name (string) – Returns the required name.

Groups

Names, Problem data - disjunctive constraints, Inspecting the task

Task.getdjcnamelen
getdjcnamelen(long djcidx,
              out int len)
getdjcnamelen(long djcidx) -> int len

Obtains the length of the name of a disjunctive constraint.

Parameters
  • djcidx (long) – Index of a disjunctive constraint. (input)

  • len (int) – Returns the length of the indicated name. (output)

Return

len (int) – Returns the length of the indicated name.

Groups

Names, Problem data - disjunctive constraints, Inspecting the task

Task.getdjcnumafe
getdjcnumafe(long djcidx,
             out long numafe)
getdjcnumafe(long djcidx) -> long numafe

Obtains the number of affine expressions in the disjunctive constraint.

Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • numafe (long) – Number of affine expressions in the disjunctive constraint. (output)

Return

numafe (long) – Number of affine expressions in the disjunctive constraint.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcnumafetot
getdjcnumafetot(out long numafetot)
getdjcnumafetot() -> long numafetot

Obtains the total number of affine expressions in all disjunctive constraints.

Parameters

numafetot (long) – Number of affine expressions in all disjunctive constraints. (output)

Return

numafetot (long) – Number of affine expressions in all disjunctive constraints.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcnumdomain
getdjcnumdomain(long djcidx,
                out long numdomain)
getdjcnumdomain(long djcidx) -> long numdomain

Obtains the number of domains in the disjunctive constraint.

Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • numdomain (long) – Number of domains in the disjunctive constraint. (output)

Return

numdomain (long) – Number of domains in the disjunctive constraint.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcnumdomaintot
getdjcnumdomaintot(out long numdomaintot)
getdjcnumdomaintot() -> long numdomaintot

Obtains the total number of domains in all disjunctive constraints.

Parameters

numdomaintot (long) – Number of domains in all disjunctive constraints. (output)

Return

numdomaintot (long) – Number of domains in all disjunctive constraints.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcnumterm
getdjcnumterm(long djcidx,
              out long numterm)
getdjcnumterm(long djcidx) -> long numterm

Obtains the number terms in the disjunctive constraint.

Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • numterm (long) – Number of terms in the disjunctive constraint. (output)

Return

numterm (long) – Number of terms in the disjunctive constraint.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcnumtermtot
getdjcnumtermtot(out long numtermtot)
getdjcnumtermtot() -> long numtermtot

Obtains the total number of terms in all disjunctive constraints.

Parameters

numtermtot (long) – Total number of terms in all disjunctive constraints. (output)

Return

numtermtot (long) – Total number of terms in all disjunctive constraints.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjcs
getdjcs(long[] domidxlist,
        long[] afeidxlist,
        double[] b,
        long[] termsizelist,
        long[] numterms)
getdjcs() ->
       (long[] domidxlist,
        long[] afeidxlist,
        double[] b,
        long[] termsizelist,
        long[] numterms)

Obtains full data of all disjunctive constraints. The output arrays must have minimal lengths determined by the following methods: domainidxlist by Task.getdjcnumdomaintot, afeidxlist and b by Task.getdjcnumafetot, termsizelist by Task.getdjcnumtermtot and numterms by Task.getnumdomain.

Parameters
  • domidxlist (long[]) – The concatenation of index lists of domains appearing in all disjunctive constraints. (output)

  • afeidxlist (long[]) – The concatenation of index lists of affine expressions appearing in all disjunctive constraints. (output)

  • b (double[]) – The concatenation of vectors b appearing in all disjunctive constraints. (output)

  • termsizelist (long[]) – The concatenation of lists of term sizes appearing in all disjunctive constraints. (output)

  • numterms (long[]) – The number of terms in each of the disjunctive constraints. (output)

Return
  • domidxlist (long[]) – The concatenation of index lists of domains appearing in all disjunctive constraints.

  • afeidxlist (long[]) – The concatenation of index lists of affine expressions appearing in all disjunctive constraints.

  • b (double[]) – The concatenation of vectors b appearing in all disjunctive constraints.

  • termsizelist (long[]) – The concatenation of lists of term sizes appearing in all disjunctive constraints.

  • numterms (long[]) – The number of terms in each of the disjunctive constraints.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdjctermsizelist
getdjctermsizelist(long djcidx,
                   long[] termsizelist)
getdjctermsizelist(long djcidx) -> long[] termsizelist

Obtains the list of term sizes in a disjunctive constraint.

Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • termsizelist (long[]) – List of term sizes. (output)

Return

termsizelist (long[]) – List of term sizes.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getdomainn
getdomainn(long domidx,
           out long n)
getdomainn(long domidx) -> long n

Obtains the dimension of the domain.

Parameters
  • domidx (long) – Index of the domain. (input)

  • n (long) – Dimension of the domain. (output)

Return

n (long) – Dimension of the domain.

Groups

Problem data - domain, Inspecting the task

Task.getdomainname
getdomainname(long domidx,
              StringBuilder name)
getdomainname(long domidx) -> string name

Obtains the name of a domain.

Parameters
  • domidx (long) – Index of a domain. (input)

  • name (StringBuilder) – Returns the required name. (output)

Return

name (string) – Returns the required name.

Groups

Names, Problem data - domain, Inspecting the task

Task.getdomainnamelen
getdomainnamelen(long domidx,
                 out int len)
getdomainnamelen(long domidx) -> int len

Obtains the length of the name of a domain.

Parameters
  • domidx (long) – Index of a domain. (input)

  • len (int) – Returns the length of the indicated name. (output)

Return

len (int) – Returns the length of the indicated name.

Groups

Names, Problem data - domain, Inspecting the task

Task.getdomaintype
getdomaintype(long domidx,
              out domaintype domtype)
getdomaintype(long domidx) -> domaintype domtype

Returns the type of the domain.

Parameters
  • domidx (long) – Index of the domain. (input)

  • domtype (mosek.domaintype) – The type of the domain. (output)

Return

domtype (mosek.domaintype) – The type of the domain.

Groups

Problem data - domain, Inspecting the task

Task.getdouinf
getdouinf(dinfitem whichdinf,
          out double dvalue)
getdouinf(dinfitem whichdinf) -> double dvalue

Obtains a double information item from the task information database.

Parameters
  • whichdinf (mosek.dinfitem) – Specifies a double information item. (input)

  • dvalue (double) – The value of the required double information item. (output)

Return

dvalue (double) – The value of the required double information item.

Groups

Information items and statistics

Task.getdouparam
getdouparam(dparam param,
            out double parvalue)
getdouparam(dparam param) -> double parvalue

Obtains the value of a double parameter.

Parameters
  • param (mosek.dparam) – Which parameter. (input)

  • parvalue (double) – Parameter value. (output)

Return

parvalue (double) – Parameter value.

Groups

Parameters

Task.getdualobj
getdualobj(soltype whichsol,
           out double dualobj)
getdualobj(soltype whichsol) -> double dualobj

Computes the dual objective value associated with the solution. Note that if the solution is a primal infeasibility certificate, then the fixed term in the objective value is not included.

Moreover, since there is no dual solution associated with an integer solution, an error will be reported if the dual objective value is requested for the integer solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • dualobj (double) – Objective value corresponding to the dual solution. (output)

Return

dualobj (double) – Objective value corresponding to the dual solution.

Groups

Solution information, Solution - dual

Task.getdualsolutionnorms
getdualsolutionnorms(soltype whichsol,
                     out double nrmy,
                     out double nrmslc,
                     out double nrmsuc,
                     out double nrmslx,
                     out double nrmsux,
                     out double nrmsnx,
                     out double nrmbars)
getdualsolutionnorms(soltype whichsol) ->
                    (double nrmy,
                     double nrmslc,
                     double nrmsuc,
                     double nrmslx,
                     double nrmsux,
                     double nrmsnx,
                     double nrmbars)

Compute norms of the dual solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • nrmy (double) – The norm of the \(y\) vector. (output)

  • nrmslc (double) – The norm of the \(s_l^c\) vector. (output)

  • nrmsuc (double) – The norm of the \(s_u^c\) vector. (output)

  • nrmslx (double) – The norm of the \(s_l^x\) vector. (output)

  • nrmsux (double) – The norm of the \(s_u^x\) vector. (output)

  • nrmsnx (double) – The norm of the \(s_n^x\) vector. (output)

  • nrmbars (double) – The norm of the \(\barS\) vector. (output)

Return
  • nrmy (double) – The norm of the \(y\) vector.

  • nrmslc (double) – The norm of the \(s_l^c\) vector.

  • nrmsuc (double) – The norm of the \(s_u^c\) vector.

  • nrmslx (double) – The norm of the \(s_l^x\) vector.

  • nrmsux (double) – The norm of the \(s_u^x\) vector.

  • nrmsnx (double) – The norm of the \(s_n^x\) vector.

  • nrmbars (double) – The norm of the \(\barS\) vector.

Groups

Solution information

Task.getdviolacc
getdviolacc(soltype whichsol,
            long[] accidxlist,
            double[] viol)
getdviolacc(soltype whichsol,
            long[] accidxlist) -> double[] viol

Let \((s_n^x)^*\) be the value of variable \((s_n^x)\) for the specified solution. For simplicity let us assume that \(s_n^x\) is a member of a quadratic cone, then the violation is computed as follows

\[\begin{split}\left\{ \begin{array}{ll} \max(0,(\|s_n^x\|_{2:n}^*-(s_n^x)_1^*) / \sqrt{2}, & (s_n^x)^* \geq -\|(s_n^x)_{2:n}^*\|, \\ \|(s_n^x)^*\|, & \mbox{otherwise.} \end{array} \right.\end{split}\]

Both when the solution is a certificate of primal infeasibility or when it is a dual feasible solution the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • accidxlist (long[]) – An array of indexes of conic constraints. (input)

  • viol (double[]) – viol[k] is the violation of the dual solution associated with the conic constraint sub[k]. (output)

Return

viol (double[]) – viol[k] is the violation of the dual solution associated with the conic constraint sub[k].

Groups

Solution information

Task.getdviolbarvar
getdviolbarvar(soltype whichsol,
               int[] sub,
               double[] viol)
getdviolbarvar(soltype whichsol,
               int[] sub) -> double[] viol

Let \((\barS_j)^*\) be the value of variable \(\barS_j\) for the specified solution. Then the dual violation of the solution associated with variable \(\barS_j\) is given by

\[\max(-\lambda_{\min}(\barS_j),\ 0.0).\]

Both when the solution is a certificate of primal infeasibility and when it is dual feasible solution the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sub (int[]) – An array of indexes of \(\barX\) variables. (input)

  • viol (double[]) – viol[k] is the violation of the solution for the constraint \(\barS_{\mathtt{sub}[k]} \in \PSD\). (output)

Return

viol (double[]) – viol[k] is the violation of the solution for the constraint \(\barS_{\mathtt{sub}[k]} \in \PSD\).

Groups

Solution information

Task.getdviolcon
getdviolcon(soltype whichsol,
            int[] sub,
            double[] viol)
getdviolcon(soltype whichsol,
            int[] sub) -> double[] viol

The violation of the dual solution associated with the \(i\)-th constraint is computed as follows

\[\max( \rho( (s_l^c)_i^*,(b_l^c)_i ),\ \rho( (s_u^c)_i^*, -(b_u^c)_i ),\ |-y_i+(s_l^c)_i^*-(s_u^c)_i^*| )\]

where

\[\begin{split}\rho(x,l) = \left\{ \begin{array}{ll} -x, & l > -\infty , \\ |x|, & \mbox{otherwise}.\\ \end{array} \right.\end{split}\]

Both when the solution is a certificate of primal infeasibility or it is a dual feasible solution the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sub (int[]) – An array of indexes of constraints. (input)

  • viol (double[]) – viol[k] is the violation of dual solution associated with the constraint sub[k]. (output)

Return

viol (double[]) – viol[k] is the violation of dual solution associated with the constraint sub[k].

Groups

Solution information

Task.getdviolcones Deprecated
getdviolcones(soltype whichsol,
              int[] sub,
              double[] viol)
getdviolcones(soltype whichsol,
              int[] sub) -> double[] viol

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Let \((s_n^x)^*\) be the value of variable \((s_n^x)\) for the specified solution. For simplicity let us assume that \(s_n^x\) is a member of a quadratic cone, then the violation is computed as follows

\[\begin{split}\left\{ \begin{array}{ll} \max(0,(\|s_n^x\|_{2:n}^*-(s_n^x)_1^*) / \sqrt{2}, & (s_n^x)^* \geq -\|(s_n^x)_{2:n}^*\|, \\ \|(s_n^x)^*\|, & \mbox{otherwise.} \end{array} \right.\end{split}\]

Both when the solution is a certificate of primal infeasibility or when it is a dual feasible solution the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sub (int[]) – An array of indexes of conic constraints. (input)

  • viol (double[]) – viol[k] is the violation of the dual solution associated with the conic constraint sub[k]. (output)

Return

viol (double[]) – viol[k] is the violation of the dual solution associated with the conic constraint sub[k].

Groups

Solution information

Task.getdviolvar
getdviolvar(soltype whichsol,
            int[] sub,
            double[] viol)
getdviolvar(soltype whichsol,
            int[] sub) -> double[] viol

The violation of the dual solution associated with the \(j\)-th variable is computed as follows

\[\max \left(\rho((s_l^x)_j^*,(b_l^x)_j),\ \rho((s_u^x)_j^*,-(b_u^x)_j),\ |\sum_{i=\idxbeg}^{\idxend{numcon}} a_{ij} y_i+(s_l^x)_j^*-(s_u^x)_j^* - \tau c_j| \right)\]

where

\[\begin{split}\rho(x,l) = \left\{ \begin{array}{ll} -x, & l > -\infty , \\ |x|, & \mbox{otherwise} \end{array} \right.\end{split}\]

and \(\tau=0\) if the solution is a certificate of primal infeasibility and \(\tau=1\) otherwise. The formula for computing the violation is only shown for the linear case but is generalized appropriately for the more general problems. Both when the solution is a certificate of primal infeasibility or when it is a dual feasible solution the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sub (int[]) – An array of indexes of \(x\) variables. (input)

  • viol (double[]) – viol[k] is the violation of dual solution associated with the variable sub[k]. (output)

Return

viol (double[]) – viol[k] is the violation of dual solution associated with the variable sub[k].

Groups

Solution information

Task.getinfeasiblesubproblem
getinfeasiblesubproblem(soltype whichsol,
                        out Task inftask)
getinfeasiblesubproblem(soltype whichsol) -> Task inftask

Given the solution is a certificate of primal or dual infeasibility then a primal or dual infeasible subproblem is obtained respectively. The subproblem tends to be much smaller than the original problem and hence it is easier to locate the infeasibility inspecting the subproblem than the original problem.

For the procedure to be useful it is important to assign meaningful names to constraints, variables etc. in the original task because those names will be duplicated in the subproblem.

The function is only applicable to linear and conic quadratic optimization problems.

For more information see Sec. 8.3 (Debugging infeasibility) and Sec. 14.2 (Automatic Repair of Infeasible Problems).

Parameters
  • whichsol (mosek.soltype) – Which solution to use when determining the infeasible subproblem. (input)

  • inftask (Task) – A new task containing the infeasible subproblem. (output)

Return

inftask (Task) – A new task containing the infeasible subproblem.

Groups

Infeasibility diagnostic

Task.getinfindex
getinfindex(inftype inftype,
            string infname,
            out int infindex)
getinfindex(inftype inftype,
            string infname) -> int infindex

Obtains the index of a named information item.

Parameters
  • inftype (mosek.inftype) – Type of the information item. (input)

  • infname (string) – Name of the information item. (input)

  • infindex (int) – The item index. (output)

Return

infindex (int) – The item index.

Groups

Information items and statistics

Task.getintinf
getintinf(iinfitem whichiinf,
          out int ivalue)
getintinf(iinfitem whichiinf) -> int ivalue

Obtains an integer information item from the task information database.

Parameters
  • whichiinf (mosek.iinfitem) – Specifies an integer information item. (input)

  • ivalue (int) – The value of the required integer information item. (output)

Return

ivalue (int) – The value of the required integer information item.

Groups

Information items and statistics

Task.getintparam
getintparam(iparam param,
            out int parvalue)
getintparam(iparam param) -> int parvalue

Obtains the value of an integer parameter.

Parameters
  • param (mosek.iparam) – Which parameter. (input)

  • parvalue (int) – Parameter value. (output)

Return

parvalue (int) – Parameter value.

Groups

Parameters

Task.getlenbarvarj
getlenbarvarj(int j,
              out long lenbarvarj)
getlenbarvarj(int j) -> long lenbarvarj

Obtains the length of the \(j\)-th semidefinite variable i.e. the number of elements in the lower triangular part.

Parameters
  • j (int) – Index of the semidefinite variable whose length if requested. (input)

  • lenbarvarj (long) – Number of scalar elements in the lower triangular part of the semidefinite variable. (output)

Return

lenbarvarj (long) – Number of scalar elements in the lower triangular part of the semidefinite variable.

Groups

Inspecting the task, Problem data - semidefinite

Task.getlintinf
getlintinf(liinfitem whichliinf,
           out long ivalue)
getlintinf(liinfitem whichliinf) -> long ivalue

Obtains a long integer information item from the task information database.

Parameters
  • whichliinf (mosek.liinfitem) – Specifies a long information item. (input)

  • ivalue (long) – The value of the required long integer information item. (output)

Return

ivalue (long) – The value of the required long integer information item.

Groups

Information items and statistics

Task.getmaxnumanz
getmaxnumanz(out long maxnumanz)
getmaxnumanz() -> long maxnumanz

Obtains number of preallocated non-zeros in \(A\). When this number of non-zeros is reached MOSEK will automatically allocate more space for \(A\).

Parameters

maxnumanz (long) – Number of preallocated non-zero linear matrix elements. (output)

Return

maxnumanz (long) – Number of preallocated non-zero linear matrix elements.

Groups

Inspecting the task, Problem data - linear part

Task.getmaxnumbarvar
getmaxnumbarvar(out int maxnumbarvar)
getmaxnumbarvar() -> int maxnumbarvar

Obtains maximum number of symmetric matrix variables for which space is currently preallocated.

Parameters

maxnumbarvar (int) – Maximum number of symmetric matrix variables for which space is currently preallocated. (output)

Return

maxnumbarvar (int) – Maximum number of symmetric matrix variables for which space is currently preallocated.

Groups

Inspecting the task, Problem data - semidefinite

Task.getmaxnumcon
getmaxnumcon(out int maxnumcon)
getmaxnumcon() -> int maxnumcon

Obtains the number of preallocated constraints in the optimization task. When this number of constraints is reached MOSEK will automatically allocate more space for constraints.

Parameters

maxnumcon (int) – Number of preallocated constraints in the optimization task. (output)

Return

maxnumcon (int) – Number of preallocated constraints in the optimization task.

Groups

Inspecting the task, Problem data - linear part, Problem data - constraints

Task.getmaxnumcone Deprecated
getmaxnumcone(out int maxnumcone)
getmaxnumcone() -> int maxnumcone

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Obtains the number of preallocated cones in the optimization task. When this number of cones is reached MOSEK will automatically allocate space for more cones.

Parameters

maxnumcone (int) – Number of preallocated conic constraints in the optimization task. (output)

Return

maxnumcone (int) – Number of preallocated conic constraints in the optimization task.

Groups

Inspecting the task, Problem data - cones (deprecated)

Task.getmaxnumqnz
getmaxnumqnz(out long maxnumqnz)
getmaxnumqnz() -> long maxnumqnz

Obtains the number of preallocated non-zeros for \(Q\) (both objective and constraints). When this number of non-zeros is reached MOSEK will automatically allocate more space for \(Q\).

Parameters

maxnumqnz (long) – Number of non-zero elements preallocated in quadratic coefficient matrices. (output)

Return

maxnumqnz (long) – Number of non-zero elements preallocated in quadratic coefficient matrices.

Groups

Inspecting the task, Problem data - quadratic part

Task.getmaxnumvar
getmaxnumvar(out int maxnumvar)
getmaxnumvar() -> int maxnumvar

Obtains the number of preallocated variables in the optimization task. When this number of variables is reached MOSEK will automatically allocate more space for variables.

Parameters

maxnumvar (int) – Number of preallocated variables in the optimization task. (output)

Return

maxnumvar (int) – Number of preallocated variables in the optimization task.

Groups

Inspecting the task, Problem data - linear part, Problem data - variables

Task.getmemusage
getmemusage(out long meminuse,
            out long maxmemuse)
getmemusage() ->
           (long meminuse,
            long maxmemuse)

Obtains information about the amount of memory used by a task.

Parameters
  • meminuse (long) – Amount of memory currently used by the task. (output)

  • maxmemuse (long) – Maximum amount of memory used by the task until now. (output)

Return
  • meminuse (long) – Amount of memory currently used by the task.

  • maxmemuse (long) – Maximum amount of memory used by the task until now.

Groups

System, memory and debugging

Task.getnumacc
getnumacc(out long num)
getnumacc() -> long num

Obtains the number of affine conic constraints.

Parameters

num (long) – The number of affine conic constraints. (output)

Return

num (long) – The number of affine conic constraints.

Groups

Problem data - affine conic constraints, Inspecting the task

Task.getnumafe
getnumafe(out long numafe)
getnumafe() -> long numafe

Obtains the number of affine expressions.

Parameters

numafe (long) – Number of affine expressions. (output)

Return

numafe (long) – Number of affine expressions.

Groups

Problem data - affine expressions, Inspecting the task

Task.getnumanz
getnumanz(out int numanz)
getnumanz() -> int numanz

Obtains the number of non-zeros in \(A\).

Parameters

numanz (int) – Number of non-zero elements in the linear constraint matrix. (output)

Return

numanz (int) – Number of non-zero elements in the linear constraint matrix.

Groups

Inspecting the task, Problem data - linear part

Task.getnumanz64
getnumanz64(out long numanz)
getnumanz64() -> long numanz

Obtains the number of non-zeros in \(A\).

Parameters

numanz (long) – Number of non-zero elements in the linear constraint matrix. (output)

Return

numanz (long) – Number of non-zero elements in the linear constraint matrix.

Groups

Inspecting the task, Problem data - linear part

Task.getnumbarablocktriplets
getnumbarablocktriplets(out long num)
getnumbarablocktriplets() -> long num

Obtains an upper bound on the number of elements in the block triplet form of \(\barA\).

Parameters

num (long) – An upper bound on the number of elements in the block triplet form of \(\barA.\) (output)

Return

num (long) – An upper bound on the number of elements in the block triplet form of \(\barA.\)

Groups

Problem data - semidefinite, Inspecting the task

Task.getnumbaranz
getnumbaranz(out long nz)
getnumbaranz() -> long nz

Get the number of nonzero elements in \(\barA\).

Parameters

nz (long) – The number of nonzero block elements in \(\barA\) i.e. the number of \(\barA_{ij}\) elements that are nonzero. (output)

Return

nz (long) – The number of nonzero block elements in \(\barA\) i.e. the number of \(\barA_{ij}\) elements that are nonzero.

Groups

Problem data - semidefinite, Inspecting the task

Task.getnumbarcblocktriplets
getnumbarcblocktriplets(out long num)
getnumbarcblocktriplets() -> long num

Obtains an upper bound on the number of elements in the block triplet form of \(\barC\).

Parameters

num (long) – An upper bound on the number of elements in the block triplet form of \(\barC.\) (output)

Return

num (long) – An upper bound on the number of elements in the block triplet form of \(\barC.\)

Groups

Problem data - semidefinite, Inspecting the task

Task.getnumbarcnz
getnumbarcnz(out long nz)
getnumbarcnz() -> long nz

Obtains the number of nonzero elements in \(\barC\).

Parameters

nz (long) – The number of nonzeros in \(\barC\) i.e. the number of elements \(\barC_j\) that are nonzero. (output)

Return

nz (long) – The number of nonzeros in \(\barC\) i.e. the number of elements \(\barC_j\) that are nonzero.

Groups

Problem data - semidefinite, Inspecting the task

Task.getnumbarvar
getnumbarvar(out int numbarvar)
getnumbarvar() -> int numbarvar

Obtains the number of semidefinite variables.

Parameters

numbarvar (int) – Number of semidefinite variables in the problem. (output)

Return

numbarvar (int) – Number of semidefinite variables in the problem.

Groups

Inspecting the task, Problem data - semidefinite

Task.getnumcon
getnumcon(out int numcon)
getnumcon() -> int numcon

Obtains the number of constraints.

Parameters

numcon (int) – Number of constraints. (output)

Return

numcon (int) – Number of constraints.

Groups

Problem data - linear part, Problem data - constraints, Inspecting the task

Task.getnumcone Deprecated
getnumcone(out int numcone)
getnumcone() -> int numcone

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Parameters

numcone (int) – Number of conic constraints. (output)

Return

numcone (int) – Number of conic constraints.

Groups

Problem data - cones (deprecated), Inspecting the task

Task.getnumconemem Deprecated
getnumconemem(int k,
              out int nummem)
getnumconemem(int k) -> int nummem

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Parameters
  • k (int) – Index of the cone. (input)

  • nummem (int) – Number of member variables in the cone. (output)

Return

nummem (int) – Number of member variables in the cone.

Groups

Problem data - cones (deprecated), Inspecting the task

Task.getnumdjc
getnumdjc(out long num)
getnumdjc() -> long num

Obtains the number of disjunctive constraints.

Parameters

num (long) – The number of disjunctive constraints. (output)

Return

num (long) – The number of disjunctive constraints.

Groups

Problem data - disjunctive constraints, Inspecting the task

Task.getnumdomain
getnumdomain(out long numdomain)
getnumdomain() -> long numdomain

Obtain the number of domains defined.

Parameters

numdomain (long) – Number of domains in the task. (output)

Return

numdomain (long) – Number of domains in the task.

Groups

Inspecting the task, Problem data - domain

Task.getnumintvar
getnumintvar(out int numintvar)
getnumintvar() -> int numintvar

Obtains the number of integer-constrained variables.

Parameters

numintvar (int) – Number of integer variables. (output)

Return

numintvar (int) – Number of integer variables.

Groups

Inspecting the task, Problem data - variables

Task.getnumparam
getnumparam(parametertype partype,
            out int numparam)
getnumparam(parametertype partype) -> int numparam

Obtains the number of parameters of a given type.

Parameters
  • partype (mosek.parametertype) – Parameter type. (input)

  • numparam (int) – The number of parameters of type partype. (output)

Return

numparam (int) – The number of parameters of type partype.

Groups

Inspecting the task, Parameters

Task.getnumqconknz
getnumqconknz(int k,
              out long numqcnz)
getnumqconknz(int k) -> long numqcnz

Obtains the number of non-zero quadratic terms in a constraint.

Parameters
  • k (int) – Index of the constraint for which the number quadratic terms should be obtained. (input)

  • numqcnz (long) – Number of quadratic terms. (output)

Return

numqcnz (long) – Number of quadratic terms.

Groups

Inspecting the task, Problem data - constraints, Problem data - quadratic part

Task.getnumqobjnz
getnumqobjnz(out long numqonz)
getnumqobjnz() -> long numqonz

Obtains the number of non-zero quadratic terms in the objective.

Parameters

numqonz (long) – Number of non-zero elements in the quadratic objective terms. (output)

Return

numqonz (long) – Number of non-zero elements in the quadratic objective terms.

Groups

Inspecting the task, Problem data - quadratic part

Task.getnumsymmat
getnumsymmat(out long num)
getnumsymmat() -> long num

Obtains the number of symmetric matrices stored in the vector \(E\).

Parameters

num (long) – The number of symmetric sparse matrices. (output)

Return

num (long) – The number of symmetric sparse matrices.

Groups

Problem data - semidefinite, Inspecting the task

Task.getnumvar
getnumvar(out int numvar)
getnumvar() -> int numvar

Obtains the number of variables.

Parameters

numvar (int) – Number of variables. (output)

Return

numvar (int) – Number of variables.

Groups

Inspecting the task, Problem data - variables

Task.getobjname
getobjname(StringBuilder objname)
getobjname() -> string objname

Obtains the name assigned to the objective function.

Parameters

objname (StringBuilder) – Assigned the objective name. (output)

Return

objname (string) – Assigned the objective name.

Groups

Inspecting the task, Names

Task.getobjnamelen
getobjnamelen(out int len)
getobjnamelen() -> int len

Obtains the length of the name assigned to the objective function.

Parameters

len (int) – Assigned the length of the objective name. (output)

Return

len (int) – Assigned the length of the objective name.

Groups

Inspecting the task, Names

Task.getobjsense
getobjsense(out objsense sense)
getobjsense() -> objsense sense

Gets the objective sense of the task.

Parameters

sense (mosek.objsense) – The returned objective sense. (output)

Return

sense (mosek.objsense) – The returned objective sense.

Groups

Problem data - linear part

Task.getpowerdomainalpha
getpowerdomainalpha(long domidx,
                    double[] alpha)
getpowerdomainalpha(long domidx) -> double[] alpha

Obtains the exponent vector \(\alpha\) of a primal or dual power cone domain.

Parameters
  • domidx (long) – Index of the domain. (input)

  • alpha (double[]) – The vector \(\alpha\). (output)

Return

alpha (double[]) – The vector \(\alpha\).

Groups

Problem data - domain, Inspecting the task

Task.getpowerdomaininfo
getpowerdomaininfo(long domidx,
                   out long n,
                   out long nleft)
getpowerdomaininfo(long domidx) ->
                  (long n,
                   long nleft)

Obtains structural information about a primal or dual power cone domain.

Parameters
  • domidx (long) – Index of the domain. (input)

  • n (long) – Dimension of the domain. (output)

  • nleft (long) – Number of variables on the left hand side. (output)

Return
  • n (long) – Dimension of the domain.

  • nleft (long) – Number of variables on the left hand side.

Groups

Problem data - domain, Inspecting the task

Task.getprimalobj
getprimalobj(soltype whichsol,
             out double primalobj)
getprimalobj(soltype whichsol) -> double primalobj

Computes the primal objective value for the desired solution. Note that if the solution is an infeasibility certificate, then the fixed term in the objective is not included.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • primalobj (double) – Objective value corresponding to the primal solution. (output)

Return

primalobj (double) – Objective value corresponding to the primal solution.

Groups

Solution information, Solution - primal

Task.getprimalsolutionnorms
getprimalsolutionnorms(soltype whichsol,
                       out double nrmxc,
                       out double nrmxx,
                       out double nrmbarx)
getprimalsolutionnorms(soltype whichsol) ->
                      (double nrmxc,
                       double nrmxx,
                       double nrmbarx)

Compute norms of the primal solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • nrmxc (double) – The norm of the \(x^c\) vector. (output)

  • nrmxx (double) – The norm of the \(x\) vector. (output)

  • nrmbarx (double) – The norm of the \(\barX\) vector. (output)

Return
  • nrmxc (double) – The norm of the \(x^c\) vector.

  • nrmxx (double) – The norm of the \(x\) vector.

  • nrmbarx (double) – The norm of the \(\barX\) vector.

Groups

Solution information

Task.getprobtype
getprobtype(out problemtype probtype)
getprobtype() -> problemtype probtype

Obtains the problem type.

Parameters

probtype (mosek.problemtype) – The problem type. (output)

Return

probtype (mosek.problemtype) – The problem type.

Groups

Inspecting the task

Task.getprosta
getprosta(soltype whichsol,
          out prosta problemsta)
getprosta(soltype whichsol) -> prosta problemsta

Obtains the problem status.

Parameters
Return

problemsta (mosek.prosta) – Problem status.

Groups

Solution information

Task.getpviolacc
getpviolacc(soltype whichsol,
            long[] accidxlist,
            double[] viol)
getpviolacc(soltype whichsol,
            long[] accidxlist) -> double[] viol

Computes the primal solution violation for a set of affine conic constraints. Let \(x^*\) be the value of the variable \(x\) for the specified solution. For simplicity let us assume that \(x\) is a member of a quadratic cone, then the violation is computed as follows

\[\begin{split}\left\{ \begin{array}{ll} \max(0,\|x_{2:n}\|-x_1) / \sqrt{2}, & x_1 \geq -\|x_{2:n}\|, \\ \|x\|, & \mbox{otherwise.} \end{array} \right.\end{split}\]

Both when the solution is a certificate of dual infeasibility or when it is primal feasible the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • accidxlist (long[]) – An array of indexes of conic constraints. (input)

  • viol (double[]) – viol[k] is the violation of the solution associated with the affine conic constraint number accidxlist[k]. (output)

Return

viol (double[]) – viol[k] is the violation of the solution associated with the affine conic constraint number accidxlist[k].

Groups

Solution information

Task.getpviolbarvar
getpviolbarvar(soltype whichsol,
               int[] sub,
               double[] viol)
getpviolbarvar(soltype whichsol,
               int[] sub) -> double[] viol

Computes the primal solution violation for a set of semidefinite variables. Let \((\barX_j)^*\) be the value of the variable \(\barX_j\) for the specified solution. Then the primal violation of the solution associated with variable \(\barX_j\) is given by

\[\max(-\lambda_{\min}(\barX_j),\ 0.0).\]

Both when the solution is a certificate of dual infeasibility or when it is primal feasible the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sub (int[]) – An array of indexes of \(\barX\) variables. (input)

  • viol (double[]) – viol[k] is how much the solution violates the constraint \(\barX_{\mathtt{sub}[k]} \in \PSD\). (output)

Return

viol (double[]) – viol[k] is how much the solution violates the constraint \(\barX_{\mathtt{sub}[k]} \in \PSD\).

Groups

Solution information

Task.getpviolcon
getpviolcon(soltype whichsol,
            int[] sub,
            double[] viol)
getpviolcon(soltype whichsol,
            int[] sub) -> double[] viol

Computes the primal solution violation for a set of constraints. The primal violation of the solution associated with the \(i\)-th constraint is given by

\[\max(\tau l_i^c - (x_i^c)^*,\ (x_i^c)^* - \tau u_i^c),\ |\sum_{j=\idxbeg}^{\idxend{numvar}} a_{ij} x_j^* - x_i^c|)\]

where \(\tau=0\) if the solution is a certificate of dual infeasibility and \(\tau=1\) otherwise. Both when the solution is a certificate of dual infeasibility and when it is primal feasible the violation should be small. The above formula applies for the linear case but is appropriately generalized in other cases.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sub (int[]) – An array of indexes of constraints. (input)

  • viol (double[]) – viol[k] is the violation associated with the solution for the constraint sub[k]. (output)

Return

viol (double[]) – viol[k] is the violation associated with the solution for the constraint sub[k].

Groups

Solution information

Task.getpviolcones Deprecated
getpviolcones(soltype whichsol,
              int[] sub,
              double[] viol)
getpviolcones(soltype whichsol,
              int[] sub) -> double[] viol

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Computes the primal solution violation for a set of conic constraints. Let \(x^*\) be the value of the variable \(x\) for the specified solution. For simplicity let us assume that \(x\) is a member of a quadratic cone, then the violation is computed as follows

\[\begin{split}\left\{ \begin{array}{ll} \max(0,\|x_{2:n}\|-x_1) / \sqrt{2}, & x_1 \geq -\|x_{2:n}\|, \\ \|x\|, & \mbox{otherwise.} \end{array} \right.\end{split}\]

Both when the solution is a certificate of dual infeasibility or when it is primal feasible the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sub (int[]) – An array of indexes of conic constraints. (input)

  • viol (double[]) – viol[k] is the violation of the solution associated with the conic constraint number sub[k]. (output)

Return

viol (double[]) – viol[k] is the violation of the solution associated with the conic constraint number sub[k].

Groups

Solution information

Task.getpvioldjc
getpvioldjc(soltype whichsol,
            long[] djcidxlist,
            double[] viol)
getpvioldjc(soltype whichsol,
            long[] djcidxlist) -> double[] viol

Computes the primal solution violation for a set of disjunctive constraints. For a single DJC the violation is defined as

\[\mathrm{viol}\left(\bigvee_{i=1}^t \bigwedge_{j=1}^{s_i} T_{i,j}\right) = \min_{i=1,\ldots,t}\left(\max_{j=1,\ldots,s_j}(\mathrm{viol}(T_{i,j}))\right)\]

where the violation of each simple term \(T_{i,j}\) is defined as for an ordinary linear constraint.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • djcidxlist (long[]) – An array of indexes of disjunctive constraints. (input)

  • viol (double[]) – viol[k] is the violation of the solution associated with the disjunctive constraint number djcidxlist[k]. (output)

Return

viol (double[]) – viol[k] is the violation of the solution associated with the disjunctive constraint number djcidxlist[k].

Groups

Solution information

Task.getpviolvar
getpviolvar(soltype whichsol,
            int[] sub,
            double[] viol)
getpviolvar(soltype whichsol,
            int[] sub) -> double[] viol

Computes the primal solution violation associated to a set of variables. Let \(x_j^*\) be the value of \(x_j\) for the specified solution. Then the primal violation of the solution associated with variable \(x_j\) is given by

\[\max( \tau l_j^x - x_j^*,\ x_j^* - \tau u_j^x,\ 0).\]

where \(\tau=0\) if the solution is a certificate of dual infeasibility and \(\tau=1\) otherwise. Both when the solution is a certificate of dual infeasibility and when it is primal feasible the violation should be small.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sub (int[]) – An array of indexes of \(x\) variables. (input)

  • viol (double[]) – viol[k] is the violation associated with the solution for the variable \(x_\mathtt{sub[k]}\). (output)

Return

viol (double[]) – viol[k] is the violation associated with the solution for the variable \(x_\mathtt{sub[k]}\).

Groups

Solution information

Task.getqconk
getqconk(int k,
         out long numqcnz,
         int[] qcsubi,
         int[] qcsubj,
         double[] qcval)
getqconk(int k,
         int[] qcsubi,
         int[] qcsubj,
         double[] qcval) -> long numqcnz
getqconk(int k) ->
        (long numqcnz,
         int[] qcsubi,
         int[] qcsubj,
         double[] qcval)

Obtains all the quadratic terms in a constraint. The quadratic terms are stored sequentially in qcsubi, qcsubj, and qcval.

Parameters
  • k (int) – Which constraint. (input)

  • numqcnz (long) – Number of quadratic terms. (output)

  • qcsubi (int[]) – Row subscripts for quadratic constraint matrix. (output)

  • qcsubj (int[]) – Column subscripts for quadratic constraint matrix. (output)

  • qcval (double[]) – Quadratic constraint coefficient values. (output)

Return
  • numqcnz (long) – Number of quadratic terms.

  • qcsubi (int[]) – Row subscripts for quadratic constraint matrix.

  • qcsubj (int[]) – Column subscripts for quadratic constraint matrix.

  • qcval (double[]) – Quadratic constraint coefficient values.

Groups

Inspecting the task, Problem data - quadratic part, Problem data - constraints

Task.getqobj
getqobj(out long numqonz,
        int[] qosubi,
        int[] qosubj,
        double[] qoval)
getqobj() ->
       (long numqonz,
        int[] qosubi,
        int[] qosubj,
        double[] qoval)

Obtains the quadratic terms in the objective. The required quadratic terms are stored sequentially in qosubi, qosubj, and qoval.

Parameters
  • numqonz (long) – Number of non-zero elements in the quadratic objective terms. (output)

  • qosubi (int[]) – Row subscripts for quadratic objective coefficients. (output)

  • qosubj (int[]) – Column subscripts for quadratic objective coefficients. (output)

  • qoval (double[]) – Quadratic objective coefficient values. (output)

Return
  • numqonz (long) – Number of non-zero elements in the quadratic objective terms.

  • qosubi (int[]) – Row subscripts for quadratic objective coefficients.

  • qosubj (int[]) – Column subscripts for quadratic objective coefficients.

  • qoval (double[]) – Quadratic objective coefficient values.

Groups

Inspecting the task, Problem data - quadratic part

Task.getqobjij
getqobjij(int i,
          int j,
          out double qoij)
getqobjij(int i,
          int j) -> double qoij

Obtains one coefficient \(q_{ij}^o\) in the quadratic term of the objective.

Parameters
  • i (int) – Row index of the coefficient. (input)

  • j (int) – Column index of coefficient. (input)

  • qoij (double) – The required coefficient. (output)

Return

qoij (double) – The required coefficient.

Groups

Inspecting the task, Problem data - quadratic part

Task.getreducedcosts
getreducedcosts(soltype whichsol,
                int first,
                int last,
                double[] redcosts)
getreducedcosts(soltype whichsol,
                int first,
                int last) -> double[] redcosts

Computes the reduced costs for a slice of variables and returns them in the array redcosts i.e.

(15.2)\[\mathtt{redcosts}[j-\mathtt{first}] = (s_l^x)_j-(s_u^x)_j, ~j=\mathtt{first},\ldots,\mathtt{last}-1\]
Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – The index of the first variable in the sequence. (input)

  • last (int) – The index of the last variable in the sequence plus 1. (input)

  • redcosts (double[]) – The reduced costs for the required slice of variables. (output)

Return

redcosts (double[]) – The reduced costs for the required slice of variables.

Groups

Solution - dual

Task.getskc
getskc(soltype whichsol,
       stakey[] skc)
getskc(soltype whichsol) -> stakey[] skc

Obtains the status keys for the constraints.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • skc (mosek.stakey[]) – Status keys for the constraints. (output)

Return

skc (mosek.stakey[]) – Status keys for the constraints.

Groups

Solution information

Task.getskcslice
getskcslice(soltype whichsol,
            int first,
            int last,
            stakey[] skc)
getskcslice(soltype whichsol,
            int first,
            int last) -> stakey[] skc

Obtains the status keys for a slice of the constraints.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • skc (mosek.stakey[]) – Status keys for the constraints. (output)

Return

skc (mosek.stakey[]) – Status keys for the constraints.

Groups

Solution information

Task.getskn
getskn(soltype whichsol,
       stakey[] skn)
getskn(soltype whichsol) -> stakey[] skn

Obtains the status keys for the conic constraints.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • skn (mosek.stakey[]) – Status keys for the conic constraints. (output)

Return

skn (mosek.stakey[]) – Status keys for the conic constraints.

Groups

Solution information

Task.getskx
getskx(soltype whichsol,
       stakey[] skx)
getskx(soltype whichsol) -> stakey[] skx

Obtains the status keys for the scalar variables.

Parameters
Return

skx (mosek.stakey[]) – Status keys for the variables.

Groups

Solution information

Task.getskxslice
getskxslice(soltype whichsol,
            int first,
            int last,
            stakey[] skx)
getskxslice(soltype whichsol,
            int first,
            int last) -> stakey[] skx

Obtains the status keys for a slice of the scalar variables.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • skx (mosek.stakey[]) – Status keys for the variables. (output)

Return

skx (mosek.stakey[]) – Status keys for the variables.

Groups

Solution information

Task.getslc
getslc(soltype whichsol,
       double[] slc)
getslc(soltype whichsol) -> double[] slc

Obtains the \(s_l^c\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • slc (double[]) – Dual variables corresponding to the lower bounds on the constraints. (output)

Return

slc (double[]) – Dual variables corresponding to the lower bounds on the constraints.

Groups

Solution - dual

Task.getslcslice
getslcslice(soltype whichsol,
            int first,
            int last,
            double[] slc)
getslcslice(soltype whichsol,
            int first,
            int last) -> double[] slc

Obtains a slice of the \(s_l^c\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • slc (double[]) – Dual variables corresponding to the lower bounds on the constraints. (output)

Return

slc (double[]) – Dual variables corresponding to the lower bounds on the constraints.

Groups

Solution - dual

Task.getslx
getslx(soltype whichsol,
       double[] slx)
getslx(soltype whichsol) -> double[] slx

Obtains the \(s_l^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • slx (double[]) – Dual variables corresponding to the lower bounds on the variables. (output)

Return

slx (double[]) – Dual variables corresponding to the lower bounds on the variables.

Groups

Solution - dual

Task.getslxslice
getslxslice(soltype whichsol,
            int first,
            int last,
            double[] slx)
getslxslice(soltype whichsol,
            int first,
            int last) -> double[] slx

Obtains a slice of the \(s_l^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • slx (double[]) – Dual variables corresponding to the lower bounds on the variables. (output)

Return

slx (double[]) – Dual variables corresponding to the lower bounds on the variables.

Groups

Solution - dual

Task.getsnx
getsnx(soltype whichsol,
       double[] snx)
getsnx(soltype whichsol) -> double[] snx

Obtains the \(s_n^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • snx (double[]) – Dual variables corresponding to the conic constraints on the variables. (output)

Return

snx (double[]) – Dual variables corresponding to the conic constraints on the variables.

Groups

Solution - dual

Task.getsnxslice
getsnxslice(soltype whichsol,
            int first,
            int last,
            double[] snx)
getsnxslice(soltype whichsol,
            int first,
            int last) -> double[] snx

Obtains a slice of the \(s_n^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • snx (double[]) – Dual variables corresponding to the conic constraints on the variables. (output)

Return

snx (double[]) – Dual variables corresponding to the conic constraints on the variables.

Groups

Solution - dual

Task.getsolsta
getsolsta(soltype whichsol,
          out solsta solutionsta)
getsolsta(soltype whichsol) -> solsta solutionsta

Obtains the solution status.

Parameters
Return

solutionsta (mosek.solsta) – Solution status.

Groups

Solution information

Task.getsolution
getsolution(soltype whichsol,
            out prosta problemsta,
            out solsta solutionsta,
            stakey[] skc,
            stakey[] skx,
            stakey[] skn,
            double[] xc,
            double[] xx,
            double[] y,
            double[] slc,
            double[] suc,
            double[] slx,
            double[] sux,
            double[] snx)
getsolution(soltype whichsol) ->
           (prosta problemsta,
            solsta solutionsta,
            stakey[] skc,
            stakey[] skx,
            stakey[] skn,
            double[] xc,
            double[] xx,
            double[] y,
            double[] slc,
            double[] suc,
            double[] slx,
            double[] sux,
            double[] snx)

Obtains the complete solution.

Consider the case of linear programming. The primal problem is given by

\[\begin{split}\begin{array}{lccccl} \mbox{minimize} & & & c^T x+c^f & & \\ \mbox{subject to} & l^c & \leq & A x & \leq & u^c, \\ & l^x & \leq & x & \leq & u^x. \\ \end{array}\end{split}\]

and the corresponding dual problem is

\[\begin{split}\begin{array}{lccl} \mbox{maximize} & (l^c)^T s_l^c - (u^c)^T s_u^c & \\ & + (l^x)^T s_l^x - (u^x)^T s_u^x + c^f & \\ \mbox{subject to} & A^T y + s_l^x - s_u^x & = & c, \\ & -y + s_l^c - s_u^c & = & 0, \\ & s_l^c,s_u^c,s_l^x,s_u^x \geq 0. & & \\ \end{array}\end{split}\]

A conic optimization problem has the same primal variables as in the linear case. Recall that the dual of a conic optimization problem is given by:

\[\begin{split}\begin{array}{lccccc} \mbox{maximize} & (l^c)^T s_l^c - (u^c)^T s_u^c & & \\ & +(l^x)^T s_l^x - (u^x)^T s_u^x + c^f & & \\ \mbox{subject to} & A^T y + s_l^x - s_u^x + s_n^x & = & c, \\ & -y + s_l^c - s_u^c & = & 0, \\ & s_l^c,s_u^c,s_l^x,s_u^x & \geq & 0, \\ & s_n^x \in \K^* & & \\ \end{array}\end{split}\]

The mapping between variables and arguments to the function is as follows:

  • xx : Corresponds to variable \(x\) (also denoted \(x^x\)).

  • xc : Corresponds to \(x^c:=Ax\).

  • y : Corresponds to variable \(y\).

  • slc: Corresponds to variable \(s_l^c\).

  • suc: Corresponds to variable \(s_u^c\).

  • slx: Corresponds to variable \(s_l^x\).

  • sux: Corresponds to variable \(s_u^x\).

  • snx: Corresponds to variable \(s_n^x\).

The meaning of the values returned by this function depend on the solution status returned in the argument solsta. The most important possible values of solsta are:

In order to retrieve the primal and dual values of semidefinite variables see Task.getbarxj and Task.getbarsj.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • problemsta (mosek.prosta) – Problem status. (output)

  • solutionsta (mosek.solsta) – Solution status. (output)

  • skc (mosek.stakey[]) – Status keys for the constraints. (output)

  • skx (mosek.stakey[]) – Status keys for the variables. (output)

  • skn (mosek.stakey[]) – Status keys for the conic constraints. (output)

  • xc (double[]) – Primal constraint solution. (output)

  • xx (double[]) – Primal variable solution. (output)

  • y (double[]) – Vector of dual variables corresponding to the constraints. (output)

  • slc (double[]) – Dual variables corresponding to the lower bounds on the constraints. (output)

  • suc (double[]) – Dual variables corresponding to the upper bounds on the constraints. (output)

  • slx (double[]) – Dual variables corresponding to the lower bounds on the variables. (output)

  • sux (double[]) – Dual variables corresponding to the upper bounds on the variables. (output)

  • snx (double[]) – Dual variables corresponding to the conic constraints on the variables. (output)

Return
  • problemsta (mosek.prosta) – Problem status.

  • solutionsta (mosek.solsta) – Solution status.

  • skc (mosek.stakey[]) – Status keys for the constraints.

  • skx (mosek.stakey[]) – Status keys for the variables.

  • skn (mosek.stakey[]) – Status keys for the conic constraints.

  • xc (double[]) – Primal constraint solution.

  • xx (double[]) – Primal variable solution.

  • y (double[]) – Vector of dual variables corresponding to the constraints.

  • slc (double[]) – Dual variables corresponding to the lower bounds on the constraints.

  • suc (double[]) – Dual variables corresponding to the upper bounds on the constraints.

  • slx (double[]) – Dual variables corresponding to the lower bounds on the variables.

  • sux (double[]) – Dual variables corresponding to the upper bounds on the variables.

  • snx (double[]) – Dual variables corresponding to the conic constraints on the variables.

Groups

Solution information, Solution - primal, Solution - dual

Task.getsolutioninfo
getsolutioninfo(soltype whichsol,
                out double pobj,
                out double pviolcon,
                out double pviolvar,
                out double pviolbarvar,
                out double pviolcone,
                out double pviolitg,
                out double dobj,
                out double dviolcon,
                out double dviolvar,
                out double dviolbarvar,
                out double dviolcone)
getsolutioninfo(soltype whichsol) ->
               (double pobj,
                double pviolcon,
                double pviolvar,
                double pviolbarvar,
                double pviolcone,
                double pviolitg,
                double dobj,
                double dviolcon,
                double dviolvar,
                double dviolbarvar,
                double dviolcone)

Obtains information about a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • pobj (double) – The primal objective value as computed by Task.getprimalobj. (output)

  • pviolcon (double) – Maximal primal violation of the solution associated with the \(x^c\) variables where the violations are computed by Task.getpviolcon. (output)

  • pviolvar (double) – Maximal primal violation of the solution for the \(x\) variables where the violations are computed by Task.getpviolvar. (output)

  • pviolbarvar (double) – Maximal primal violation of solution for the \(\barX\) variables where the violations are computed by Task.getpviolbarvar. (output)

  • pviolcone (double) – Maximal primal violation of solution for the conic constraints where the violations are computed by Task.getpviolcones. (output)

  • pviolitg (double) – Maximal violation in the integer constraints. The violation for an integer variable \(x_j\) is given by \(\min(x_j-\lfloor x_j \rfloor,\lceil x_j \rceil - x_j)\). This number is always zero for the interior-point and basic solutions. (output)

  • dobj (double) – Dual objective value as computed by Task.getdualobj. (output)

  • dviolcon (double) – Maximal violation of the dual solution associated with the \(x^c\) variable as computed by Task.getdviolcon. (output)

  • dviolvar (double) – Maximal violation of the dual solution associated with the \(x\) variable as computed by Task.getdviolvar. (output)

  • dviolbarvar (double) – Maximal violation of the dual solution associated with the \(\barS\) variable as computed by Task.getdviolbarvar. (output)

  • dviolcone (double) – Maximal violation of the dual solution associated with the dual conic constraints as computed by Task.getdviolcones. (output)

Return
  • pobj (double) – The primal objective value as computed by Task.getprimalobj.

  • pviolcon (double) – Maximal primal violation of the solution associated with the \(x^c\) variables where the violations are computed by Task.getpviolcon.

  • pviolvar (double) – Maximal primal violation of the solution for the \(x\) variables where the violations are computed by Task.getpviolvar.

  • pviolbarvar (double) – Maximal primal violation of solution for the \(\barX\) variables where the violations are computed by Task.getpviolbarvar.

  • pviolcone (double) – Maximal primal violation of solution for the conic constraints where the violations are computed by Task.getpviolcones.

  • pviolitg (double) – Maximal violation in the integer constraints. The violation for an integer variable \(x_j\) is given by \(\min(x_j-\lfloor x_j \rfloor,\lceil x_j \rceil - x_j)\). This number is always zero for the interior-point and basic solutions.

  • dobj (double) – Dual objective value as computed by Task.getdualobj.

  • dviolcon (double) – Maximal violation of the dual solution associated with the \(x^c\) variable as computed by Task.getdviolcon.

  • dviolvar (double) – Maximal violation of the dual solution associated with the \(x\) variable as computed by Task.getdviolvar.

  • dviolbarvar (double) – Maximal violation of the dual solution associated with the \(\barS\) variable as computed by Task.getdviolbarvar.

  • dviolcone (double) – Maximal violation of the dual solution associated with the dual conic constraints as computed by Task.getdviolcones.

Groups

Solution information

Task.getsolutioninfonew
getsolutioninfonew(soltype whichsol,
                   out double pobj,
                   out double pviolcon,
                   out double pviolvar,
                   out double pviolbarvar,
                   out double pviolcone,
                   out double pviolacc,
                   out double pvioldjc,
                   out double pviolitg,
                   out double dobj,
                   out double dviolcon,
                   out double dviolvar,
                   out double dviolbarvar,
                   out double dviolcone,
                   out double dviolacc)
getsolutioninfonew(soltype whichsol) ->
                  (double pobj,
                   double pviolcon,
                   double pviolvar,
                   double pviolbarvar,
                   double pviolcone,
                   double pviolacc,
                   double pvioldjc,
                   double pviolitg,
                   double dobj,
                   double dviolcon,
                   double dviolvar,
                   double dviolbarvar,
                   double dviolcone,
                   double dviolacc)

Obtains information about a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • pobj (double) – The primal objective value as computed by Task.getprimalobj. (output)

  • pviolcon (double) – Maximal primal violation of the solution associated with the \(x^c\) variables where the violations are computed by Task.getpviolcon. (output)

  • pviolvar (double) – Maximal primal violation of the solution for the \(x\) variables where the violations are computed by Task.getpviolvar. (output)

  • pviolbarvar (double) – Maximal primal violation of solution for the \(\barX\) variables where the violations are computed by Task.getpviolbarvar. (output)

  • pviolcone (double) – Maximal primal violation of solution for the conic constraints where the violations are computed by Task.getpviolcones. (output)

  • pviolacc (double) – Maximal primal violation of solution for the affine conic constraints where the violations are computed by Task.getpviolacc. (output)

  • pvioldjc (double) – Maximal primal violation of solution for the disjunctive constraints where the violations are computed by Task.getpvioldjc. (output)

  • pviolitg (double) – Maximal violation in the integer constraints. The violation for an integer variable \(x_j\) is given by \(\min(x_j-\lfloor x_j \rfloor,\lceil x_j \rceil - x_j)\). This number is always zero for the interior-point and basic solutions. (output)

  • dobj (double) – Dual objective value as computed by Task.getdualobj. (output)

  • dviolcon (double) – Maximal violation of the dual solution associated with the \(x^c\) variable as computed by Task.getdviolcon. (output)

  • dviolvar (double) – Maximal violation of the dual solution associated with the \(x\) variable as computed by Task.getdviolvar. (output)

  • dviolbarvar (double) – Maximal violation of the dual solution associated with the \(\barS\) variable as computed by Task.getdviolbarvar. (output)

  • dviolcone (double) – Maximal violation of the dual solution associated with the dual conic constraints as computed by Task.getdviolcones. (output)

  • dviolacc (double) – Maximal violation of the dual solution associated with the affine conic constraints as computed by Task.getdviolacc. (output)

Return
  • pobj (double) – The primal objective value as computed by Task.getprimalobj.

  • pviolcon (double) – Maximal primal violation of the solution associated with the \(x^c\) variables where the violations are computed by Task.getpviolcon.

  • pviolvar (double) – Maximal primal violation of the solution for the \(x\) variables where the violations are computed by Task.getpviolvar.

  • pviolbarvar (double) – Maximal primal violation of solution for the \(\barX\) variables where the violations are computed by Task.getpviolbarvar.

  • pviolcone (double) – Maximal primal violation of solution for the conic constraints where the violations are computed by Task.getpviolcones.

  • pviolacc (double) – Maximal primal violation of solution for the affine conic constraints where the violations are computed by Task.getpviolacc.

  • pvioldjc (double) – Maximal primal violation of solution for the disjunctive constraints where the violations are computed by Task.getpvioldjc.

  • pviolitg (double) – Maximal violation in the integer constraints. The violation for an integer variable \(x_j\) is given by \(\min(x_j-\lfloor x_j \rfloor,\lceil x_j \rceil - x_j)\). This number is always zero for the interior-point and basic solutions.

  • dobj (double) – Dual objective value as computed by Task.getdualobj.

  • dviolcon (double) – Maximal violation of the dual solution associated with the \(x^c\) variable as computed by Task.getdviolcon.

  • dviolvar (double) – Maximal violation of the dual solution associated with the \(x\) variable as computed by Task.getdviolvar.

  • dviolbarvar (double) – Maximal violation of the dual solution associated with the \(\barS\) variable as computed by Task.getdviolbarvar.

  • dviolcone (double) – Maximal violation of the dual solution associated with the dual conic constraints as computed by Task.getdviolcones.

  • dviolacc (double) – Maximal violation of the dual solution associated with the affine conic constraints as computed by Task.getdviolacc.

Groups

Solution information

Task.getsolutionnew
getsolutionnew(soltype whichsol,
               out prosta problemsta,
               out solsta solutionsta,
               stakey[] skc,
               stakey[] skx,
               stakey[] skn,
               double[] xc,
               double[] xx,
               double[] y,
               double[] slc,
               double[] suc,
               double[] slx,
               double[] sux,
               double[] snx,
               double[] doty)
getsolutionnew(soltype whichsol) ->
              (prosta problemsta,
               solsta solutionsta,
               stakey[] skc,
               stakey[] skx,
               stakey[] skn,
               double[] xc,
               double[] xx,
               double[] y,
               double[] slc,
               double[] suc,
               double[] slx,
               double[] sux,
               double[] snx,
               double[] doty)

Obtains the complete solution. See Task.getsolution for further information.

In order to retrieve the primal and dual values of semidefinite variables see Task.getbarxj and Task.getbarsj.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • problemsta (mosek.prosta) – Problem status. (output)

  • solutionsta (mosek.solsta) – Solution status. (output)

  • skc (mosek.stakey[]) – Status keys for the constraints. (output)

  • skx (mosek.stakey[]) – Status keys for the variables. (output)

  • skn (mosek.stakey[]) – Status keys for the conic constraints. (output)

  • xc (double[]) – Primal constraint solution. (output)

  • xx (double[]) – Primal variable solution. (output)

  • y (double[]) – Vector of dual variables corresponding to the constraints. (output)

  • slc (double[]) – Dual variables corresponding to the lower bounds on the constraints. (output)

  • suc (double[]) – Dual variables corresponding to the upper bounds on the constraints. (output)

  • slx (double[]) – Dual variables corresponding to the lower bounds on the variables. (output)

  • sux (double[]) – Dual variables corresponding to the upper bounds on the variables. (output)

  • snx (double[]) – Dual variables corresponding to the conic constraints on the variables. (output)

  • doty (double[]) – Dual variables corresponding to affine conic constraints. (output)

Return
  • problemsta (mosek.prosta) – Problem status.

  • solutionsta (mosek.solsta) – Solution status.

  • skc (mosek.stakey[]) – Status keys for the constraints.

  • skx (mosek.stakey[]) – Status keys for the variables.

  • skn (mosek.stakey[]) – Status keys for the conic constraints.

  • xc (double[]) – Primal constraint solution.

  • xx (double[]) – Primal variable solution.

  • y (double[]) – Vector of dual variables corresponding to the constraints.

  • slc (double[]) – Dual variables corresponding to the lower bounds on the constraints.

  • suc (double[]) – Dual variables corresponding to the upper bounds on the constraints.

  • slx (double[]) – Dual variables corresponding to the lower bounds on the variables.

  • sux (double[]) – Dual variables corresponding to the upper bounds on the variables.

  • snx (double[]) – Dual variables corresponding to the conic constraints on the variables.

  • doty (double[]) – Dual variables corresponding to affine conic constraints.

Groups

Solution information, Solution - primal, Solution - dual

Task.getsolutionslice
getsolutionslice(soltype whichsol,
                 solitem solitem,
                 int first,
                 int last,
                 double[] values)
getsolutionslice(soltype whichsol,
                 solitem solitem,
                 int first,
                 int last) -> double[] values

Obtains a slice of one item from the solution. The format of the solution is exactly as in Task.getsolution. The parameter solitem determines which of the solution vectors should be returned.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • solitem (mosek.solitem) – Which part of the solution is required. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • values (double[]) – The values in the required sequence are stored sequentially in values. (output)

Return

values (double[]) – The values in the required sequence are stored sequentially in values.

Groups

Solution - primal, Solution - dual, Solution information

Task.getsparsesymmat
getsparsesymmat(long idx,
                int[] subi,
                int[] subj,
                double[] valij)
getsparsesymmat(long idx) ->
               (int[] subi,
                int[] subj,
                double[] valij)

Get a single symmetric matrix from the matrix store.

Parameters
  • idx (long) – Index of the matrix to retrieve. (input)

  • subi (int[]) – Row subscripts of the matrix non-zero elements. (output)

  • subj (int[]) – Column subscripts of the matrix non-zero elements. (output)

  • valij (double[]) – Coefficients of the matrix non-zero elements. (output)

Return
  • subi (int[]) – Row subscripts of the matrix non-zero elements.

  • subj (int[]) – Column subscripts of the matrix non-zero elements.

  • valij (double[]) – Coefficients of the matrix non-zero elements.

Groups

Problem data - semidefinite, Inspecting the task

Task.getstrparam
getstrparam(sparam param,
            out int len,
            StringBuilder parvalue)
getstrparam(sparam param,
            out int len) -> string parvalue
getstrparam(sparam param) ->
           (int len,
            string parvalue)

Obtains the value of a string parameter.

Parameters
  • param (mosek.sparam) – Which parameter. (input)

  • len (int) – The length of the parameter value. (output)

  • parvalue (StringBuilder) – Parameter value. (output)

Return
  • parvalue (string) – Parameter value.

  • len (int) – The length of the parameter value.

Groups

Names, Parameters

Task.getstrparamlen
getstrparamlen(sparam param,
               out int len)
getstrparamlen(sparam param) -> int len

Obtains the length of a string parameter.

Parameters
  • param (mosek.sparam) – Which parameter. (input)

  • len (int) – The length of the parameter value. (output)

Return

len (int) – The length of the parameter value.

Groups

Names, Parameters

Task.getsuc
getsuc(soltype whichsol,
       double[] suc)
getsuc(soltype whichsol) -> double[] suc

Obtains the \(s_u^c\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • suc (double[]) – Dual variables corresponding to the upper bounds on the constraints. (output)

Return

suc (double[]) – Dual variables corresponding to the upper bounds on the constraints.

Groups

Solution - dual

Task.getsucslice
getsucslice(soltype whichsol,
            int first,
            int last,
            double[] suc)
getsucslice(soltype whichsol,
            int first,
            int last) -> double[] suc

Obtains a slice of the \(s_u^c\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • suc (double[]) – Dual variables corresponding to the upper bounds on the constraints. (output)

Return

suc (double[]) – Dual variables corresponding to the upper bounds on the constraints.

Groups

Solution - dual

Task.getsux
getsux(soltype whichsol,
       double[] sux)
getsux(soltype whichsol) -> double[] sux

Obtains the \(s_u^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sux (double[]) – Dual variables corresponding to the upper bounds on the variables. (output)

Return

sux (double[]) – Dual variables corresponding to the upper bounds on the variables.

Groups

Solution - dual

Task.getsuxslice
getsuxslice(soltype whichsol,
            int first,
            int last,
            double[] sux)
getsuxslice(soltype whichsol,
            int first,
            int last) -> double[] sux

Obtains a slice of the \(s_u^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • sux (double[]) – Dual variables corresponding to the upper bounds on the variables. (output)

Return

sux (double[]) – Dual variables corresponding to the upper bounds on the variables.

Groups

Solution - dual

Task.getsymmatinfo
getsymmatinfo(long idx,
              out int dim,
              out long nz,
              out symmattype mattype)
getsymmatinfo(long idx) ->
             (int dim,
              long nz,
              symmattype mattype)

MOSEK maintains a vector denoted by \(E\) of symmetric data matrices. This function makes it possible to obtain important information about a single matrix in \(E\).

Parameters
  • idx (long) – Index of the matrix for which information is requested. (input)

  • dim (int) – Returns the dimension of the requested matrix. (output)

  • nz (long) – Returns the number of non-zeros in the requested matrix. (output)

  • mattype (mosek.symmattype) – Returns the type of the requested matrix. (output)

Return
  • dim (int) – Returns the dimension of the requested matrix.

  • nz (long) – Returns the number of non-zeros in the requested matrix.

  • mattype (mosek.symmattype) – Returns the type of the requested matrix.

Groups

Problem data - semidefinite, Inspecting the task

Task.gettaskname
gettaskname(StringBuilder taskname)
gettaskname() -> string taskname

Obtains the name assigned to the task.

Parameters

taskname (StringBuilder) – Returns the task name. (output)

Return

taskname (string) – Returns the task name.

Groups

Names, Inspecting the task

Task.gettasknamelen
gettasknamelen(out int len)
gettasknamelen() -> int len

Obtains the length the task name.

Parameters

len (int) – Returns the length of the task name. (output)

Return

len (int) – Returns the length of the task name.

Groups

Names, Inspecting the task

Task.getvarbound
getvarbound(int i,
            out boundkey bk,
            out double bl,
            out double bu)
getvarbound(int i) ->
           (boundkey bk,
            double bl,
            double bu)

Obtains bound information for one variable.

Parameters
  • i (int) – Index of the variable for which the bound information should be obtained. (input)

  • bk (mosek.boundkey) – Bound keys. (output)

  • bl (double) – Values for lower bounds. (output)

  • bu (double) – Values for upper bounds. (output)

Return
  • bk (mosek.boundkey) – Bound keys.

  • bl (double) – Values for lower bounds.

  • bu (double) – Values for upper bounds.

Groups

Problem data - linear part, Inspecting the task, Problem data - bounds, Problem data - variables

Task.getvarboundslice
getvarboundslice(int first,
                 int last,
                 boundkey[] bk,
                 double[] bl,
                 double[] bu)
getvarboundslice(int first,
                 int last) ->
                (boundkey[] bk,
                 double[] bl,
                 double[] bu)

Obtains bounds information for a slice of the variables.

Parameters
  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • bk (mosek.boundkey[]) – Bound keys. (output)

  • bl (double[]) – Values for lower bounds. (output)

  • bu (double[]) – Values for upper bounds. (output)

Return
  • bk (mosek.boundkey[]) – Bound keys.

  • bl (double[]) – Values for lower bounds.

  • bu (double[]) – Values for upper bounds.

Groups

Problem data - linear part, Inspecting the task, Problem data - bounds, Problem data - variables

Task.getvarname
getvarname(int j,
           StringBuilder name)
getvarname(int j) -> string name

Obtains the name of a variable.

Parameters
  • j (int) – Index of a variable. (input)

  • name (StringBuilder) – Returns the required name. (output)

Return

name (string) – Returns the required name.

Groups

Names, Problem data - linear part, Problem data - variables, Inspecting the task

Task.getvarnameindex
getvarnameindex(string somename,
                out int asgn,
                out int index)
getvarnameindex(string somename,
                out int asgn) -> int index
getvarnameindex(string somename) ->
               (int asgn,
                int index)

Checks whether the name somename has been assigned to any variable. If so, the index of the variable is reported.

Parameters
  • somename (string) – The name which should be checked. (input)

  • asgn (int) – Is non-zero if the name somename is assigned to a variable. (output)

  • index (int) – If the name somename is assigned to a variable, then index is the index of the variable. (output)

Return
  • index (int) – If the name somename is assigned to a variable, then index is the index of the variable.

  • asgn (int) – Is non-zero if the name somename is assigned to a variable.

Groups

Names, Problem data - linear part, Problem data - variables, Inspecting the task

Task.getvarnamelen
getvarnamelen(int i,
              out int len)
getvarnamelen(int i) -> int len

Obtains the length of the name of a variable.

Parameters
  • i (int) – Index of a variable. (input)

  • len (int) – Returns the length of the indicated name. (output)

Return

len (int) – Returns the length of the indicated name.

Groups

Names, Problem data - linear part, Problem data - variables, Inspecting the task

Task.getvartype
getvartype(int j,
           out variabletype vartype)
getvartype(int j) -> variabletype vartype

Gets the variable type of one variable.

Parameters
  • j (int) – Index of the variable. (input)

  • vartype (mosek.variabletype) – Variable type of the \(j\)-th variable. (output)

Return

vartype (mosek.variabletype) – Variable type of the \(j\)-th variable.

Groups

Inspecting the task, Problem data - variables

Task.getvartypelist
getvartypelist(int[] subj,
               variabletype[] vartype)
getvartypelist(int[] subj) -> variabletype[] vartype

Obtains the variable type of one or more variables. Upon return vartype[k] is the variable type of variable subj[k].

Parameters
  • subj (int[]) – A list of variable indexes. (input)

  • vartype (mosek.variabletype[]) – The variables types corresponding to the variables specified by subj. (output)

Return

vartype (mosek.variabletype[]) – The variables types corresponding to the variables specified by subj.

Groups

Inspecting the task, Problem data - variables

Task.getxc
getxc(soltype whichsol,
      double[] xc)
getxc(soltype whichsol) -> double[] xc

Obtains the \(x^c\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • xc (double[]) – Primal constraint solution. (output)

Return

xc (double[]) – Primal constraint solution.

Groups

Solution - primal

Task.getxcslice
getxcslice(soltype whichsol,
           int first,
           int last,
           double[] xc)
getxcslice(soltype whichsol,
           int first,
           int last) -> double[] xc

Obtains a slice of the \(x^c\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • xc (double[]) – Primal constraint solution. (output)

Return

xc (double[]) – Primal constraint solution.

Groups

Solution - primal

Task.getxx
getxx(soltype whichsol,
      double[] xx)
getxx(soltype whichsol) -> double[] xx

Obtains the \(x^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • xx (double[]) – Primal variable solution. (output)

Return

xx (double[]) – Primal variable solution.

Groups

Solution - primal

Task.getxxslice
getxxslice(soltype whichsol,
           int first,
           int last,
           double[] xx)
getxxslice(soltype whichsol,
           int first,
           int last) -> double[] xx

Obtains a slice of the \(x^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • xx (double[]) – Primal variable solution. (output)

Return

xx (double[]) – Primal variable solution.

Groups

Solution - primal

Task.gety
gety(soltype whichsol,
     double[] y)
gety(soltype whichsol) -> double[] y

Obtains the \(y\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • y (double[]) – Vector of dual variables corresponding to the constraints. (output)

Return

y (double[]) – Vector of dual variables corresponding to the constraints.

Groups

Solution - dual

Task.getyslice
getyslice(soltype whichsol,
          int first,
          int last,
          double[] y)
getyslice(soltype whichsol,
          int first,
          int last) -> double[] y

Obtains a slice of the \(y\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • y (double[]) – Vector of dual variables corresponding to the constraints. (output)

Return

y (double[]) – Vector of dual variables corresponding to the constraints.

Groups

Solution - dual

Task.infeasibilityreport
infeasibilityreport(streamtype whichstream,
                    soltype whichsol)

Prints the infeasibility report to an output stream.

Parameters
Groups

Infeasibility diagnostic

Task.initbasissolve
initbasissolve(int[] basis)
initbasissolve() -> int[] basis

Prepare a task for use with the Task.solvewithbasis function.

This function should be called

If the basis is singular i.e. not invertible, then the error rescode.err_basis_singular is reported.

Parameters

basis (int[]) – The array of basis indexes to use. The array is interpreted as follows: If \(\mathtt{basis}[i] \leq \idxend{numcon}\), then \(x_{\mathtt{basis}[i]}^c\) is in the basis at position \(i\), otherwise \(x_{\mathtt{basis}[i]-\mathtt{numcon}}\) is in the basis at position \(i\). (output)

Return

basis (int[]) – The array of basis indexes to use. The array is interpreted as follows: If \(\mathtt{basis}[i] \leq \idxend{numcon}\), then \(x_{\mathtt{basis}[i]}^c\) is in the basis at position \(i\), otherwise \(x_{\mathtt{basis}[i]-\mathtt{numcon}}\) is in the basis at position \(i\).

Groups

Solving systems with basis matrix

Task.inputdata
inputdata(int maxnumcon,
          int maxnumvar,
          double[] c,
          double cfix,
          int[] aptrb,
          int[] aptre,
          int[] asub,
          double[] aval,
          boundkey[] bkc,
          double[] blc,
          double[] buc,
          boundkey[] bkx,
          double[] blx,
          double[] bux)
inputdata(int maxnumcon,
          int maxnumvar,
          double[] c,
          double cfix,
          long[] aptrb,
          long[] aptre,
          int[] asub,
          double[] aval,
          boundkey[] bkc,
          double[] blc,
          double[] buc,
          boundkey[] bkx,
          double[] blx,
          double[] bux)

Input the linear part of an optimization task in one function call.

Parameters
  • maxnumcon (int) – Number of preallocated constraints in the optimization task. (input)

  • maxnumvar (int) – Number of preallocated variables in the optimization task. (input)

  • c (double[]) – Linear terms of the objective as a dense vector. The length is the number of variables. (input)

  • cfix (double) – Fixed term in the objective. (input)

  • aptrb (int[]) – Row or column start pointers. (input)

  • aptrb (long[]) – Row or column start pointers. (input)

  • aptre (int[]) – Row or column end pointers. (input)

  • aptre (long[]) – Row or column end pointers. (input)

  • asub (int[]) – Coefficient subscripts. (input)

  • aval (double[]) – Coefficient values. (input)

  • bkc (mosek.boundkey[]) – Bound keys for the constraints. (input)

  • blc (double[]) – Lower bounds for the constraints. (input)

  • buc (double[]) – Upper bounds for the constraints. (input)

  • bkx (mosek.boundkey[]) – Bound keys for the variables. (input)

  • blx (double[]) – Lower bounds for the variables. (input)

  • bux (double[]) – Upper bounds for the variables. (input)

Groups

Problem data - linear part, Problem data - bounds, Problem data - constraints

Task.isdouparname
isdouparname(string parname,
             out dparam param)
isdouparname(string parname) -> dparam param

Checks whether parname is a valid double parameter name.

Parameters
  • parname (string) – Parameter name. (input)

  • param (mosek.dparam) – Returns the parameter corresponding to the name, if one exists. (output)

Return

param (mosek.dparam) – Returns the parameter corresponding to the name, if one exists.

Groups

Parameters, Names

Task.isintparname
isintparname(string parname,
             out iparam param)
isintparname(string parname) -> iparam param

Checks whether parname is a valid integer parameter name.

Parameters
  • parname (string) – Parameter name. (input)

  • param (mosek.iparam) – Returns the parameter corresponding to the name, if one exists. (output)

Return

param (mosek.iparam) – Returns the parameter corresponding to the name, if one exists.

Groups

Parameters, Names

Task.isstrparname
isstrparname(string parname,
             out sparam param)
isstrparname(string parname) -> sparam param

Checks whether parname is a valid string parameter name.

Parameters
  • parname (string) – Parameter name. (input)

  • param (mosek.sparam) – Returns the parameter corresponding to the name, if one exists. (output)

Return

param (mosek.sparam) – Returns the parameter corresponding to the name, if one exists.

Groups

Parameters, Names

Task.linkfiletostream
linkfiletostream(streamtype whichstream,
                 string filename,
                 int append)

Directs all output from a task stream whichstream to a file filename.

Parameters
  • whichstream (mosek.streamtype) – Index of the stream. (input)

  • filename (string) – A valid file name. (input)

  • append (int) – If this argument is 0 the output file will be overwritten, otherwise it will be appended to. (input)

Groups

Logging

Task.onesolutionsummary
onesolutionsummary(streamtype whichstream,
                   soltype whichsol)

Prints a short summary of a specified solution.

Parameters
Groups

Logging, Solution information

Task.optimize
optimize(out rescode trmcode)
optimize() -> rescode trmcode

Calls the optimizer. Depending on the problem type and the selected optimizer this will call one of the optimizers in MOSEK. By default the interior point optimizer will be selected for continuous problems. The optimizer may be selected manually by setting the parameter iparam.optimizer.

Parameters

trmcode (mosek.rescode) – Is either rescode.ok or a termination response code. (output)

Return

trmcode (mosek.rescode) – Is either rescode.ok or a termination response code.

Groups

Optimization

Task.optimizermt
optimizermt(string address,
            string accesstoken,
            out rescode trmcode)
optimizermt(string address,
            string accesstoken) -> rescode trmcode

Offload the optimization task to an instance of OptServer specified by addr, which should be a valid URL, for example http://server:port or https://server:port. The call will block until a result is available or the connection closes.

If the server requires authentication, the authentication token can be passed in the accesstoken argument.

If the server requires encryption, the keys can be passed using one of the solver parameters sparam.remote_tls_cert or sparam.remote_tls_cert_path.

Parameters
  • address (string) – Address of the OptServer. (input)

  • accesstoken (string) – Access token. (input)

  • trmcode (mosek.rescode) – Is either rescode.ok or a termination response code. (output)

Return

trmcode (mosek.rescode) – Is either rescode.ok or a termination response code.

Groups

Remote optimization

Task.optimizersummary
optimizersummary(streamtype whichstream)

Prints a short summary with optimizer statistics from last optimization.

Parameters

whichstream (mosek.streamtype) – Index of the stream. (input)

Groups

Logging

Task.primalrepair
primalrepair(double[] wlc,
             double[] wuc,
             double[] wlx,
             double[] wux)

The function repairs a primal infeasible optimization problem by adjusting the bounds on the constraints and variables where the adjustment is computed as the minimal weighted sum of relaxations to the bounds on the constraints and variables. Observe the function only repairs the problem but does not solve it. If an optimal solution is required the problem should be optimized after the repair.

The function is applicable to linear and conic problems possibly with integer variables.

Observe that when computing the minimal weighted relaxation the termination tolerance specified by the parameters of the task is employed. For instance the parameter iparam.mio_mode can be used to make MOSEK ignore the integer constraints during the repair which usually leads to a much faster repair. However, the drawback is of course that the repaired problem may not have an integer feasible solution.

Note the function modifies the task in place. If this is not desired, then apply the function to a cloned task.

Parameters
  • wlc (double[]) – \((w_l^c)_i\) is the weight associated with relaxing the lower bound on constraint \(i\). If the weight is negative, then the lower bound is not relaxed. Moreover, if the argument is NULL, then all the weights are assumed to be \(1\). (input)

  • wuc (double[]) – \((w_u^c)_i\) is the weight associated with relaxing the upper bound on constraint \(i\). If the weight is negative, then the upper bound is not relaxed. Moreover, if the argument is NULL, then all the weights are assumed to be \(1\). (input)

  • wlx (double[]) – \((w_l^x)_j\) is the weight associated with relaxing the lower bound on variable \(j\). If the weight is negative, then the lower bound is not relaxed. Moreover, if the argument is NULL, then all the weights are assumed to be \(1\). (input)

  • wux (double[]) – \((w_l^x)_i\) is the weight associated with relaxing the upper bound on variable \(j\). If the weight is negative, then the upper bound is not relaxed. Moreover, if the argument is NULL, then all the weights are assumed to be \(1\). (input)

Groups

Infeasibility diagnostic

Task.primalsensitivity
primalsensitivity(int[] subi,
                  mark[] marki,
                  int[] subj,
                  mark[] markj,
                  double[] leftpricei,
                  double[] rightpricei,
                  double[] leftrangei,
                  double[] rightrangei,
                  double[] leftpricej,
                  double[] rightpricej,
                  double[] leftrangej,
                  double[] rightrangej)
primalsensitivity(int[] subi,
                  mark[] marki,
                  int[] subj,
                  mark[] markj) ->
                 (double[] leftpricei,
                  double[] rightpricei,
                  double[] leftrangei,
                  double[] rightrangei,
                  double[] leftpricej,
                  double[] rightpricej,
                  double[] leftrangej,
                  double[] rightrangej)

Calculates sensitivity information for bounds on variables and constraints. For details on sensitivity analysis, the definitions of shadow price and linearity interval and an example see Section Sensitivity Analysis.

The type of sensitivity analysis to be performed (basis or optimal partition) is controlled by the parameter iparam.sensitivity_type.

Parameters
  • subi (int[]) – Indexes of constraints to analyze. (input)

  • marki (mosek.mark[]) – The value of marki[i] indicates for which bound of constraint subi[i] sensitivity analysis is performed. If marki[i] = mark.up the upper bound of constraint subi[i] is analyzed, and if marki[i] = mark.lo the lower bound is analyzed. If subi[i] is an equality constraint, either mark.lo or mark.up can be used to select the constraint for sensitivity analysis. (input)

  • subj (int[]) – Indexes of variables to analyze. (input)

  • markj (mosek.mark[]) – The value of markj[j] indicates for which bound of variable subj[j] sensitivity analysis is performed. If markj[j] = mark.up the upper bound of variable subj[j] is analyzed, and if markj[j] = mark.lo the lower bound is analyzed. If subj[j] is a fixed variable, either mark.lo or mark.up can be used to select the bound for sensitivity analysis. (input)

  • leftpricei (double[]) – leftpricei[i] is the left shadow price for the bound marki[i] of constraint subi[i]. (output)

  • rightpricei (double[]) – rightpricei[i] is the right shadow price for the bound marki[i] of constraint subi[i]. (output)

  • leftrangei (double[]) – leftrangei[i] is the left range \(\beta_1\) for the bound marki[i] of constraint subi[i]. (output)

  • rightrangei (double[]) – rightrangei[i] is the right range \(\beta_2\) for the bound marki[i] of constraint subi[i]. (output)

  • leftpricej (double[]) – leftpricej[j] is the left shadow price for the bound markj[j] of variable subj[j]. (output)

  • rightpricej (double[]) – rightpricej[j] is the right shadow price for the bound markj[j] of variable subj[j]. (output)

  • leftrangej (double[]) – leftrangej[j] is the left range \(\beta_1\) for the bound markj[j] of variable subj[j]. (output)

  • rightrangej (double[]) – rightrangej[j] is the right range \(\beta_2\) for the bound markj[j] of variable subj[j]. (output)

Return
  • leftpricei (double[]) – leftpricei[i] is the left shadow price for the bound marki[i] of constraint subi[i].

  • rightpricei (double[]) – rightpricei[i] is the right shadow price for the bound marki[i] of constraint subi[i].

  • leftrangei (double[]) – leftrangei[i] is the left range \(\beta_1\) for the bound marki[i] of constraint subi[i].

  • rightrangei (double[]) – rightrangei[i] is the right range \(\beta_2\) for the bound marki[i] of constraint subi[i].

  • leftpricej (double[]) – leftpricej[j] is the left shadow price for the bound markj[j] of variable subj[j].

  • rightpricej (double[]) – rightpricej[j] is the right shadow price for the bound markj[j] of variable subj[j].

  • leftrangej (double[]) – leftrangej[j] is the left range \(\beta_1\) for the bound markj[j] of variable subj[j].

  • rightrangej (double[]) – rightrangej[j] is the right range \(\beta_2\) for the bound markj[j] of variable subj[j].

Groups

Sensitivity analysis

Task.putacc
putacc(long accidx,
       long domidx,
       long[] afeidxlist,
       double[] b)

Puts an affine conic constraint. This method overwrites an existing affine conic constraint number accidx with new data specified in the same format as in Task.appendacc.

Parameters
  • accidx (long) – Affine conic constraint index. (input)

  • domidx (long) – Domain index. (input)

  • afeidxlist (long[]) – List of affine expression indexes. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. Optional, can be NULL. (input)

Groups

Problem data - affine conic constraints

Task.putaccb
putaccb(long accidx,
        double[] b)

Updates an existing affine conic constraint number accidx by putting a new vector \(b\).

Parameters
  • accidx (long) – Affine conic constraint index. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. Optional, can be NULL. (input)

Groups

Problem data - affine conic constraints

Task.putaccbj
putaccbj(long accidx,
         long j,
         double bj)

Sets one value \(b[j]\) in the \(b\) vector for the affine conic constraint number accidx.

Parameters
  • accidx (long) – Affine conic constraint index. (input)

  • j (long) – The index of an element in b to change. (input)

  • bj (double) – The new value of \(b[j]\). (input)

Groups

Problem data - affine conic constraints

Task.putaccdoty
putaccdoty(soltype whichsol,
           long accidx,
           double[] doty)
putaccdoty(soltype whichsol,
           long accidx) -> double[] doty

Puts the \(\dot{y}\) vector for a solution (the dual values of an affine conic constraint).

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • accidx (long) – The index of the affine conic constraint. (input)

  • doty (double[]) – The dual values for this affine conic constraint. The array should have length equal to the dimension of the constraint. (output)

Return

doty (double[]) – The dual values for this affine conic constraint. The array should have length equal to the dimension of the constraint.

Groups

Solution - dual, Problem data - affine conic constraints

Task.putacclist
putacclist(long[] accidxs,
           long[] domidxs,
           long[] afeidxlist,
           double[] b)

Puts affine conic constraints. This method overwrites existing affine conic constraints whose numbers are provided in the list accidxs with new data which is a concatenation of individual constraint descriptions in the same format as in Task.appendacc (see also Task.appendaccs).

Parameters
  • accidxs (long[]) – Affine conic constraint indices. (input)

  • domidxs (long[]) – Domain indices. (input)

  • afeidxlist (long[]) – List of affine expression indexes. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. Optional, can be NULL. (input)

Groups

Problem data - affine conic constraints

Task.putaccname
putaccname(long accidx,
           string name)

Sets the name of an affine conic constraint.

Parameters
  • accidx (long) – Index of the affine conic constraint. (input)

  • name (string) – The name of the affine conic constraint. (input)

Groups

Names, Problem data - affine conic constraints

Task.putacol
putacol(int j,
        int[] subj,
        double[] valj)

Change one column of the linear constraint matrix \(A\). Resets all the elements in column \(j\) to zero and then sets

\[a_{\mathtt{subj}[k],\mathtt{j}} = \mathtt{valj}[k], \quad k=0,\ldots,\mathtt{nzj}-1.\]
Parameters
  • j (int) – Index of a column in \(A\). (input)

  • subj (int[]) – Row indexes of non-zero values in column \(j\) of \(A\). (input)

  • valj (double[]) – New non-zero values of column \(j\) in \(A\). (input)

Groups

Problem data - linear part

Task.putacollist
putacollist(int[] sub,
            long[] ptrb,
            long[] ptre,
            int[] asub,
            double[] aval)

Change a set of columns in the linear constraint matrix \(A\) with data in sparse triplet format. The requested columns are set to zero and then updated with:

\[\begin{split}\begin{array}{rl} \mathtt{for} & i=\idxbeg,\ldots,\idxend{num}\\ & a_{\mathtt{asub}[k],\mathtt{sub}[i]} = \mathtt{aval}[k],\quad k=\mathtt{ptrb}[i],\ldots,\mathtt{ptre}[i]-1. \end{array}\end{split}\]
Parameters
  • sub (int[]) – Indexes of columns that should be replaced, no duplicates. (input)

  • ptrb (long[]) – Array of pointers to the first element in each column. (input)

  • ptre (long[]) – Array of pointers to the last element plus one in each column. (input)

  • asub (int[]) – Row indexes of new elements. (input)

  • aval (double[]) – Coefficient values. (input)

Groups

Problem data - linear part

Task.putafebarfblocktriplet
putafebarfblocktriplet(long[] afeidx,
                       int[] barvaridx,
                       int[] subk,
                       int[] subl,
                       double[] valkl)

Inputs the \(\barF\) matrix data in block triplet form.

Parameters
  • afeidx (long[]) – Constraint index. (input)

  • barvaridx (int[]) – Symmetric matrix variable index. (input)

  • subk (int[]) – Block row index. (input)

  • subl (int[]) – Block column index. (input)

  • valkl (double[]) – The numerical value associated with each block triplet. (input)

Groups

Problem data - affine expressions, Problem data - semidefinite

Task.putafebarfentry
putafebarfentry(long afeidx,
                int barvaridx,
                long[] termidx,
                double[] termweight)

This function sets one entry \(\barF_{ij}\) where \(i=\mathrm{afeidx}\) is the row index in the store of affine expressions and \(j=\mathrm{barvaridx}\) is the index of a symmetric variable. That is, the expression

\[\langle \barF_{ij}, \barX_j\rangle\]

will be added to the \(i\)-th affine expression.

The matrix \(\barF_{ij}\) is specified as a weighted sum of symmetric matrices from the symmetric matrix storage \(E\), so \(\barF_{ij}\) is a symmetric matrix, precisely:

\[\barF_{\mathrm{afeidx},\mathrm{barvaridx}} = \sum_{k} \mathrm{termweight}[k] \cdot E_{\mathrm{termidx}[k]}.\]

By default all elements in \(\barF\) are 0, so only non-zero elements need be added. Setting the same entry again will overwrite the earlier entry.

The symmetric matrices from \(E\) are defined separately using the function Task.appendsparsesymmat.

Parameters
  • afeidx (long) – Row index of \(\barF\). (input)

  • barvaridx (int) – Semidefinite variable index. (input)

  • termidx (long[]) – Indices in \(E\) of the matrices appearing in the weighted sum for the \(\barF\) entry being specified. (input)

  • termweight (double[]) – termweight[k] is the coefficient of the termidx[k]-th element of \(E\) in the weighted sum the \(\barF\) entry being specified. (input)

Groups

Problem data - affine expressions, Problem data - semidefinite

Task.putafebarfentrylist
putafebarfentrylist(long[] afeidx,
                    int[] barvaridx,
                    long[] numterm,
                    long[] ptrterm,
                    long[] termidx,
                    double[] termweight)

This function sets a list of entries in \(\barF\). Each entry should be described as in Task.putafebarfentry and all those descriptions should be combined (for example concatenated) in the input to this method. That means the \(k\)-th entry set will have row index afeidx[k], symmetric variable index barvaridx[k] and the description of this term consists of indices in \(E\) and weights appearing in positions

\[\mathrm{ptrterm}[k],\ldots,\mathrm{ptrterm}[k] + \mathrm{lenterm}[k] - 1\]

in the corresponding arrays termidx and termweight. See Task.putafebarfentry for details.

Parameters
  • afeidx (long[]) – Row indexes of \(\barF\). (input)

  • barvaridx (int[]) – Semidefinite variable indexes. (input)

  • numterm (long[]) – The number of terms in the weighted sums that form each entry. (input)

  • ptrterm (long[]) – The pointer to the beginning of the description of each entry. (input)

  • termidx (long[]) – Concatenated lists of indices in \(E\) of the matrices appearing in the weighted sums for the \(\barF\) being specified. (input)

  • termweight (double[]) – Concatenated lists of weights appearing in the weighted sums forming the \(\barF\) elements being specified. (input)

Groups

Problem data - affine expressions, Problem data - semidefinite

Task.putafebarfrow
putafebarfrow(long afeidx,
              int[] barvaridx,
              long[] numterm,
              long[] ptrterm,
              long[] termidx,
              double[] termweight)

This function inputs one row in \(\barF\). It first clears the row, i.e. sets \(\barF_{\mathrm{afeidx},*}=0\) and then sets the new entries. Each entry should be described as in Task.putafebarfentry and all those descriptions should be combined (for example concatenated) in the input to this method. That means the \(k\)-th entry set will have row index afeidx, symmetric variable index barvaridx[k] and the description of this term consists of indices in \(E\) and weights appearing in positions

\[\mathrm{ptrterm}[k],\ldots,\mathrm{ptrterm}[k] + \mathrm{numterm}[k] - 1\]

in the corresponding arrays termidx and termweight. See Task.putafebarfentry for details.

Parameters
  • afeidx (long) – Row index of \(\barF\). (input)

  • barvaridx (int[]) – Semidefinite variable indexes. (input)

  • numterm (long[]) – The number of terms in the weighted sums that form each entry. (input)

  • ptrterm (long[]) – The pointer to the beginning of the description of each entry. (input)

  • termidx (long[]) – Concatenated lists of indices in \(E\) of the matrices appearing in the weighted sums for the \(\barF\) entries in the row. (input)

  • termweight (double[]) – Concatenated lists of weights appearing in the weighted sums forming the \(\barF\) entries in the row. (input)

Groups

Problem data - affine expressions, Problem data - semidefinite

Task.putafefcol
putafefcol(int varidx,
           long[] afeidx,
           double[] val)

Change one column of the matrix \(F\) of affine expressions. Resets all the elements in column varidx to zero and then sets

\[F_{\mathtt{afeidx}[k],\mathtt{varidx}} = \mathtt{val}[k], \quad k=0,\ldots,\mathtt{numnz}-1.\]
Parameters
  • varidx (int) – Index of a column in \(F\). (input)

  • afeidx (long[]) – Row indexes of non-zero values in the column of \(F\). (input)

  • val (double[]) – New non-zero values in the column of \(F\). (input)

Groups

Problem data - affine expressions

Task.putafefentry
putafefentry(long afeidx,
             int varidx,
             double value)

Replaces one entry in the affine expression store \(F\), that is it sets:

\[F_{\mathrm{afeidx}, \mathrm{varidx}} = \mathrm{value}.\]
Parameters
  • afeidx (long) – Row index in \(F\). (input)

  • varidx (int) – Column index in \(F\). (input)

  • value (double) – Value of \(F_{\mathrm{afeidx},\mathrm{varidx}}\). (input)

Groups

Problem data - affine expressions

Task.putafefentrylist
putafefentrylist(long[] afeidx,
                 int[] varidx,
                 double[] val)

Replaces a number of entries in the affine expression store \(F\), that is it sets:

\[F_{\mathrm{afeidxs}[k], \mathrm{varidx}[k]} = \mathrm{val}[k]\]

for all \(k\).

Parameters
  • afeidx (long[]) – Row indices in \(F\). (input)

  • varidx (int[]) – Column indices in \(F\). (input)

  • val (double[]) – Values of the entries in \(F\). (input)

Groups

Problem data - affine expressions

Task.putafefrow
putafefrow(long afeidx,
           int[] varidx,
           double[] val)

Change one row of the matrix \(F\) of affine expressions. Resets all the elements in row afeidx to zero and then sets

\[F_{\mathtt{afeidx},\mathtt{varidx}[k]} = \mathtt{val}[k], \quad k=0,\ldots,\mathtt{numnz}-1.\]
Parameters
  • afeidx (long) – Index of a row in \(F\). (input)

  • varidx (int[]) – Column indexes of non-zero values in the row of \(F\). (input)

  • val (double[]) – New non-zero values in the row of \(F\). (input)

Groups

Problem data - affine expressions

Task.putafefrowlist
putafefrowlist(long[] afeidx,
               int[] numnzrow,
               long[] ptrrow,
               int[] varidx,
               double[] val)

Clears and then changes a number of rows of the matrix \(F\) of affine expressions. The \(k\)-th of the rows to be changed has index \(i = \mathrm{afeidx}[k]\), contains \(\mathrm{numnzrow}[k]\) nonzeros and its description as in Task.putafefrow starts in position \(\mathrm{ptrrow}[k]\) of the arrays varidx and val. Formally, the row with index \(i\) is cleared and then set as:

\[F_{i,\mathrm{varidx}[\mathrm{ptrrow}[k]+j]} = \mathrm{val}[\mathrm{ptrrow}[k] + j], \quad j=0,\ldots,\mathrm{numnzrow}[k]-1.\]
Parameters
  • afeidx (long[]) – Indices of rows in \(F\). (input)

  • numnzrow (int[]) – Number of non-zeros in each of the modified rows of \(F\). (input)

  • ptrrow (long[]) – Pointer to the first nonzero in each row of \(F\). (input)

  • varidx (int[]) – Column indexes of non-zero values. (input)

  • val (double[]) – New non-zero values in the rows of \(F\). (input)

Groups

Problem data - affine expressions

Task.putafeg
putafeg(long afeidx,
        double g)

Change one element of the vector \(g\) in affine expressions i.e.

\[g_{\mathtt{afeidx}} = \mathtt{gi}.\]
Parameters
  • afeidx (long) – Index of an entry in \(g\). (input)

  • g (double) – New value for \(g_{\mathrm{afeidx}}\). (input)

Groups

Problem data - affine expressions

Task.putafeglist
putafeglist(long[] afeidx,
            double[] g)

Changes a list of elements of the vector \(g\) in affine expressions i.e. for all \(k\) it sets

\[g_{\mathrm{afeidx}[k]} = \mathrm{glist}[k].\]
Parameters
  • afeidx (long[]) – Indices of entries in \(g\). (input)

  • g (double[]) – New values for \(g\). (input)

Groups

Problem data - affine expressions

Task.putafegslice
putafegslice(long first,
             long last,
             double[] slice)

Modifies a slice in the vector \(g\) of constant terms in affine expressions using the principle

\[g_{\mathtt{j}} = \mathtt{slice[j-first]}, \quad j=\mathrm{first},..,\idxend{\mathrm{last}}\]
Parameters
  • first (long) – First index in the sequence. (input)

  • last (long) – Last index plus 1 in the sequence. (input)

  • slice (double[]) – The slice of \(g\) as a dense vector. The length is last-first. (input)

Groups

Problem data - affine expressions

Task.putaij
putaij(int i,
       int j,
       double aij)

Changes a coefficient in the linear coefficient matrix \(A\) using the method

\[a_{i,j} = \mathtt{aij}.\]
Parameters
  • i (int) – Constraint (row) index. (input)

  • j (int) – Variable (column) index. (input)

  • aij (double) – New coefficient for \(a_{i,j}\). (input)

Groups

Problem data - linear part

Task.putaijlist
putaijlist(int[] subi,
           int[] subj,
           double[] valij)

Changes one or more coefficients in \(A\) using the method

\[a_{\mathtt{subi[k]},\mathtt{subj[k]}} = \mathtt{valij[k]}, \quad k=\idxbeg,\ldots,\idxend{num}.\]

Duplicates are not allowed.

Parameters
  • subi (int[]) – Constraint (row) indices. (input)

  • subj (int[]) – Variable (column) indices. (input)

  • valij (double[]) – New coefficient values for \(a_{i,j}\). (input)

Groups

Problem data - linear part

Task.putarow
putarow(int i,
        int[] subi,
        double[] vali)

Change one row of the linear constraint matrix \(A\). Resets all the elements in row \(i\) to zero and then sets

\[a_{\mathtt{i},\mathtt{subi}[k]} = \mathtt{vali}[k], \quad k=0,\ldots,\mathtt{nzi}-1.\]
Parameters
  • i (int) – Index of a row in \(A\). (input)

  • subi (int[]) – Column indexes of non-zero values in row \(i\) of \(A\). (input)

  • vali (double[]) – New non-zero values of row \(i\) in \(A\). (input)

Groups

Problem data - linear part

Task.putarowlist
putarowlist(int[] sub,
            long[] ptrb,
            long[] ptre,
            int[] asub,
            double[] aval)

Change a set of rows in the linear constraint matrix \(A\) with data in sparse triplet format. The requested rows are set to zero and then updated with:

\[\begin{split}\begin{array}{rl} \mathtt{for} & i=\idxbeg,\ldots,\idxend{num} \\ & a_{\mathtt{sub}[i],\mathtt{asub}[k]} = \mathtt{aval}[k],\quad k=\mathtt{ptrb}[i],\ldots,\mathtt{ptre}[i]-1. \end{array}\end{split}\]
Parameters
  • sub (int[]) – Indexes of rows that should be replaced, no duplicates. (input)

  • ptrb (long[]) – Array of pointers to the first element in each row. (input)

  • ptre (long[]) – Array of pointers to the last element plus one in each row. (input)

  • asub (int[]) – Column indexes of new elements. (input)

  • aval (double[]) – Coefficient values. (input)

Groups

Problem data - linear part

Task.putatruncatetol
putatruncatetol(double tolzero)

Truncates (sets to zero) all elements in \(A\) that satisfy

\[|a_{i,j}| \leq \mathtt{tolzero}.\]
Parameters

tolzero (double) – Truncation tolerance. (input)

Groups

Problem data - linear part

Task.putbarablocktriplet
putbarablocktriplet(int[] subi,
                    int[] subj,
                    int[] subk,
                    int[] subl,
                    double[] valijkl)

Inputs the \(\barA\) matrix in block triplet form.

Parameters
  • subi (int[]) – Constraint index. (input)

  • subj (int[]) – Symmetric matrix variable index. (input)

  • subk (int[]) – Block row index. (input)

  • subl (int[]) – Block column index. (input)

  • valijkl (double[]) – The numerical value associated with each block triplet. (input)

Groups

Problem data - semidefinite

Task.putbaraij
putbaraij(int i,
          int j,
          long[] sub,
          double[] weights)

This function sets one element in the \(\barA\) matrix.

Each element in the \(\barA\) matrix is a weighted sum of symmetric matrices from the symmetric matrix storage \(E\), so \(\barA_{ij}\) is a symmetric matrix. By default all elements in \(\barA\) are 0, so only non-zero elements need be added. Setting the same element again will overwrite the earlier entry.

The symmetric matrices from \(E\) are defined separately using the function Task.appendsparsesymmat.

Parameters
  • i (int) – Row index of \(\barA\). (input)

  • j (int) – Column index of \(\barA\). (input)

  • sub (long[]) – Indices in \(E\) of the matrices appearing in the weighted sum for \(\barA_{ij}\). (input)

  • weights (double[]) – weights[k] is the coefficient of the sub[k]-th element of \(E\) in the weighted sum forming \(\barA_{ij}\). (input)

Groups

Problem data - semidefinite

Task.putbaraijlist
putbaraijlist(int[] subi,
              int[] subj,
              long[] alphaptrb,
              long[] alphaptre,
              long[] matidx,
              double[] weights)

This function sets a list of elements in the \(\barA\) matrix.

Each element in the \(\barA\) matrix is a weighted sum of symmetric matrices from the symmetric matrix storage \(E\), so \(\barA_{ij}\) is a symmetric matrix. By default all elements in \(\barA\) are 0, so only non-zero elements need be added. Setting the same element again will overwrite the earlier entry.

The symmetric matrices from \(E\) are defined separately using the function Task.appendsparsesymmat.

Parameters
  • subi (int[]) – Row index of \(\barA\). (input)

  • subj (int[]) – Column index of \(\barA\). (input)

  • alphaptrb (long[]) – Start entries for terms in the weighted sum that forms \(\barA_{ij}\). (input)

  • alphaptre (long[]) – End entries for terms in the weighted sum that forms \(\barA_{ij}\). (input)

  • matidx (long[]) – Indices in \(E\) of the matrices appearing in the weighted sum for \(\barA_{ij}\). (input)

  • weights (double[]) – weights[k] is the coefficient of the sub[k]-th element of \(E\) in the weighted sum forming \(\barA_{ij}\). (input)

Groups

Problem data - semidefinite

Task.putbararowlist
putbararowlist(int[] subi,
               long[] ptrb,
               long[] ptre,
               int[] subj,
               long[] nummat,
               long[] matidx,
               double[] weights)

This function replaces a list of rows in the \(\barA\) matrix.

Parameters
  • subi (int[]) – Row indexes of \(\barA\). (input)

  • ptrb (long[]) – Start of rows in \(\barA\). (input)

  • ptre (long[]) – End of rows in \(\barA\). (input)

  • subj (int[]) – Column index of \(\barA\). (input)

  • nummat (long[]) – Number of entries in weighted sum of matrixes. (input)

  • matidx (long[]) – Matrix indexes for weighted sum of matrixes. (input)

  • weights (double[]) – Weights for weighted sum of matrixes. (input)

Groups

Problem data - semidefinite

Task.putbarcblocktriplet
putbarcblocktriplet(int[] subj,
                    int[] subk,
                    int[] subl,
                    double[] valjkl)

Inputs the \(\barC\) matrix in block triplet form.

Parameters
  • subj (int[]) – Symmetric matrix variable index. (input)

  • subk (int[]) – Block row index. (input)

  • subl (int[]) – Block column index. (input)

  • valjkl (double[]) – The numerical value associated with each block triplet. (input)

Groups

Problem data - semidefinite

Task.putbarcj
putbarcj(int j,
         long[] sub,
         double[] weights)

This function sets one entry in the \(\barC\) vector.

Each element in the \(\barC\) vector is a weighted sum of symmetric matrices from the symmetric matrix storage \(E\), so \(\barC_{j}\) is a symmetric matrix. By default all elements in \(\barC\) are 0, so only non-zero elements need be added. Setting the same element again will overwrite the earlier entry.

The symmetric matrices from \(E\) are defined separately using the function Task.appendsparsesymmat.

Parameters
  • j (int) – Index of the element in \(\barC\) that should be changed. (input)

  • sub (long[]) – Indices in \(E\) of matrices appearing in the weighted sum for \(\barC_j\) (input)

  • weights (double[]) – weights[k] is the coefficient of the sub[k]-th element of \(E\) in the weighted sum forming \(\barC_j\). (input)

Groups

Problem data - semidefinite, Problem data - objective

Task.putbarsj
putbarsj(soltype whichsol,
         int j,
         double[] barsj)

Sets the dual solution for a semidefinite variable.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • j (int) – Index of the semidefinite variable. (input)

  • barsj (double[]) – Value of \(\barS_j\). Format as in Task.getbarsj. (input)

Groups

Solution - semidefinite

Task.putbarvarname
putbarvarname(int j,
              string name)

Sets the name of a semidefinite variable.

Parameters
  • j (int) – Index of the variable. (input)

  • name (string) – The variable name. (input)

Groups

Names, Problem data - semidefinite

Task.putbarxj
putbarxj(soltype whichsol,
         int j,
         double[] barxj)

Sets the primal solution for a semidefinite variable.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • j (int) – Index of the semidefinite variable. (input)

  • barxj (double[]) – Value of \(\barX_j\). Format as in Task.getbarxj. (input)

Groups

Solution - semidefinite

Task.putcfix
putcfix(double cfix)

Replaces the fixed term in the objective by a new one.

Parameters

cfix (double) – Fixed term in the objective. (input)

Groups

Problem data - linear part, Problem data - objective

Task.putcj
putcj(int j,
      double cj)

Modifies one coefficient in the linear objective vector \(c\), i.e.

\[c_{\mathtt{j}} = \mathtt{cj}.\]

If the absolute value exceeds dparam.data_tol_c_huge an error is generated. If the absolute value exceeds dparam.data_tol_cj_large, a warning is generated, but the coefficient is inputted as specified.

Parameters
  • j (int) – Index of the variable for which \(c\) should be changed. (input)

  • cj (double) – New value of \(c_j\). (input)

Groups

Problem data - linear part, Problem data - objective

Task.putclist
putclist(int[] subj,
         double[] val)

Modifies the coefficients in the linear term \(c\) in the objective using the principle

\[c_{\mathtt{subj[t]}} = \mathtt{val[t]}, \quad t=\idxbeg,\ldots,\idxend{num}.\]

If a variable index is specified multiple times in subj only the last entry is used. Data checks are performed as in Task.putcj.

Parameters
  • subj (int[]) – Indices of variables for which the coefficient in \(c\) should be changed. (input)

  • val (double[]) – New numerical values for coefficients in \(c\) that should be modified. (input)

Groups

Problem data - linear part, Problem data - variables, Problem data - objective

Task.putconbound
putconbound(int i,
            boundkey bkc,
            double blc,
            double buc)

Changes the bounds for one constraint.

If the bound value specified is numerically larger than dparam.data_tol_bound_inf it is considered infinite and the bound key is changed accordingly. If a bound value is numerically larger than dparam.data_tol_bound_wrn, a warning will be displayed, but the bound is inputted as specified.

Parameters
  • i (int) – Index of the constraint. (input)

  • bkc (mosek.boundkey) – New bound key. (input)

  • blc (double) – New lower bound. (input)

  • buc (double) – New upper bound. (input)

Groups

Problem data - linear part, Problem data - constraints, Problem data - bounds

Task.putconboundlist
putconboundlist(int[] sub,
                boundkey[] bkc,
                double[] blc,
                double[] buc)

Changes the bounds for a list of constraints. If multiple bound changes are specified for a constraint, then only the last change takes effect. Data checks are performed as in Task.putconbound.

Parameters
  • sub (int[]) – List of constraint indexes. (input)

  • bkc (mosek.boundkey[]) – Bound keys for the constraints. (input)

  • blc (double[]) – Lower bounds for the constraints. (input)

  • buc (double[]) – Upper bounds for the constraints. (input)

Groups

Problem data - linear part, Problem data - constraints, Problem data - bounds

Task.putconboundlistconst
putconboundlistconst(int[] sub,
                     boundkey bkc,
                     double blc,
                     double buc)

Changes the bounds for one or more constraints. Data checks are performed as in Task.putconbound.

Parameters
  • sub (int[]) – List of constraint indexes. (input)

  • bkc (mosek.boundkey) – New bound key for all constraints in the list. (input)

  • blc (double) – New lower bound for all constraints in the list. (input)

  • buc (double) – New upper bound for all constraints in the list. (input)

Groups

Problem data - linear part, Problem data - constraints, Problem data - bounds

Task.putconboundslice
putconboundslice(int first,
                 int last,
                 boundkey[] bkc,
                 double[] blc,
                 double[] buc)

Changes the bounds for a slice of the constraints. Data checks are performed as in Task.putconbound.

Parameters
  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • bkc (mosek.boundkey[]) – Bound keys for the constraints. (input)

  • blc (double[]) – Lower bounds for the constraints. (input)

  • buc (double[]) – Upper bounds for the constraints. (input)

Groups

Problem data - linear part, Problem data - constraints, Problem data - bounds

Task.putconboundsliceconst
putconboundsliceconst(int first,
                      int last,
                      boundkey bkc,
                      double blc,
                      double buc)

Changes the bounds for a slice of the constraints. Data checks are performed as in Task.putconbound.

Parameters
  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • bkc (mosek.boundkey) – New bound key for all constraints in the slice. (input)

  • blc (double) – New lower bound for all constraints in the slice. (input)

  • buc (double) – New upper bound for all constraints in the slice. (input)

Groups

Problem data - linear part, Problem data - constraints, Problem data - bounds

Task.putcone Deprecated
putcone(int k,
        conetype ct,
        double conepar,
        int[] submem)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Parameters
  • k (int) – Index of the cone. (input)

  • ct (mosek.conetype) – Specifies the type of the cone. (input)

  • conepar (double) – For the power cone it denotes the exponent alpha. For other cone types it is unused and can be set to 0. (input)

  • submem (int[]) – Variable subscripts of the members in the cone. (input)

Groups

Problem data - cones (deprecated)

Task.putconename Deprecated
putconename(int j,
            string name)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Parameters
  • j (int) – Index of the cone. (input)

  • name (string) – The name of the cone. (input)

Groups

Names, Problem data - cones (deprecated)

Task.putconname
putconname(int i,
           string name)

Sets the name of a constraint.

Parameters
  • i (int) – Index of the constraint. (input)

  • name (string) – The name of the constraint. (input)

Groups

Names, Problem data - constraints, Problem data - linear part

Task.putconsolutioni
putconsolutioni(int i,
                soltype whichsol,
                stakey sk,
                double x,
                double sl,
                double su)

Sets the primal and dual solution information for a single constraint.

Parameters
  • i (int) – Index of the constraint. (input)

  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sk (mosek.stakey) – Status key of the constraint. (input)

  • x (double) – Primal solution value of the constraint. (input)

  • sl (double) – Solution value of the dual variable associated with the lower bound. (input)

  • su (double) – Solution value of the dual variable associated with the upper bound. (input)

Groups

Solution information, Solution - primal, Solution - dual

Task.putcslice
putcslice(int first,
          int last,
          double[] slice)

Modifies a slice in the linear term \(c\) in the objective using the principle

\[c_{\mathtt{j}} = \mathtt{slice[j-first]}, \quad j=first,..,\idxend{last}\]

Data checks are performed as in Task.putcj.

Parameters
  • first (int) – First element in the slice of \(c\). (input)

  • last (int) – Last element plus 1 of the slice in \(c\) to be changed. (input)

  • slice (double[]) – New numerical values for coefficients in \(c\) that should be modified. (input)

Groups

Problem data - linear part, Problem data - objective

Task.putdjc
putdjc(long djcidx,
       long[] domidxlist,
       long[] afeidxlist,
       double[] b,
       long[] termsizelist)

Inputs a disjunctive constraint. The constraint has the form

\[T_1\ \mathrm{or}\ T_2\ \mathrm{or}\ \cdots\ \mathrm{or}\ T_{\mathrm{numterms}}\]

For each \(i=1,\ldots\mathrm{numterms}\) the \(i\)-th clause (term) \(T_i\) has the form a sequence of affine expressions belongs to a product of domains, where the number of domains is \(\mathrm{termsizelist}[i]\) and the number of affine expressions is equal to the sum of dimensions of all domains appearing in \(T_i\).

All the domains and all the affine expressions appearing in the above description are arranged sequentially in the lists domidxlist and afeidxlist, respectively. In particular, the length of domidxlist must be equal to the sum of elements of termsizelist, and the length of afeidxlist must be equal to the sum of dimensions of all the domains appearing in domidxlist.

The elements of domidxlist are indexes of domains previously defined with one of the append...domain functions.

The elements of afeidxlist are indexes to the store of affine expressions, i.e. the \(k\)-th affine expression appearing in the disjunctive constraint is going to be

\[F_{\mathrm{afeidxlist}[k],:}x + g_{\mathrm{afeidxlist}[k]}\]

If an optional vector b of the same length as afeidxlist is specified then the \(k\)-th affine expression appearing in the disjunctive constraint will be taken as

\[F_{\mathrm{afeidxlist}[k],:}x + g_{\mathrm{afeidxlist}[k]} - b_k\]
Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • domidxlist (long[]) – List of domain indexes. (input)

  • afeidxlist (long[]) – List of affine expression indexes. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. (input)

  • termsizelist (long[]) – List of term sizes. (input)

Groups

Problem data - disjunctive constraints

Task.putdjcname
putdjcname(long djcidx,
           string name)

Sets the name of a disjunctive constraint.

Parameters
  • djcidx (long) – Index of the disjunctive constraint. (input)

  • name (string) – The name of the disjunctive constraint. (input)

Groups

Names, Problem data - disjunctive constraints

Task.putdjcslice
putdjcslice(long idxfirst,
            long idxlast,
            long[] domidxlist,
            long[] afeidxlist,
            double[] b,
            long[] termsizelist,
            long[] termsindjc)

Inputs a slice of disjunctive constraints.

The array termsindjc should have length \(\mathrm{idxlast}-\mathrm{idxfirst}\) and contain the number of terms in consecutive constraints forming the slice.

The rest of the input consists of concatenated descriptions of individual constraints, where each constraint is described as in Task.putdjc.

Parameters
  • idxfirst (long) – Index of the first disjunctive constraint in the slice. (input)

  • idxlast (long) – Index of the last disjunctive constraint in the slice plus 1. (input)

  • domidxlist (long[]) – List of domain indexes. (input)

  • afeidxlist (long[]) – List of affine expression indexes. (input)

  • b (double[]) – The vector of constant terms added to affine expressions. Optional, may be NULL. (input)

  • termsizelist (long[]) – List of term sizes. (input)

  • termsindjc (long[]) – Number of terms in each of the disjunctive constraints in the slice. (input)

Groups

Problem data - disjunctive constraints

Task.putdomainname
putdomainname(long domidx,
              string name)

Sets the name of a domain.

Parameters
  • domidx (long) – Index of the domain. (input)

  • name (string) – The name of the domain. (input)

Groups

Names, Problem data - domain

Task.putdouparam
putdouparam(dparam param,
            double parvalue)

Sets the value of a double parameter.

Parameters
  • param (mosek.dparam) – Which parameter. (input)

  • parvalue (double) – Parameter value. (input)

Groups

Parameters

Task.putintparam
putintparam(iparam param,
            int parvalue)

Sets the value of an integer parameter.

Parameters
  • param (mosek.iparam) – Which parameter. (input)

  • parvalue (int) – Parameter value. (input)

Groups

Parameters

Task.putmaxnumacc
putmaxnumacc(long maxnumacc)

Sets the number of preallocated affine conic constraints in the optimization task. When this number is reached MOSEK will automatically allocate more space. It is never mandatory to call this function, since MOSEK will reallocate any internal structures whenever it is required.

Parameters

maxnumacc (long) – Number of preallocated affine conic constraints. (input)

Groups

Environment and task management, Problem data - affine conic constraints

Task.putmaxnumafe
putmaxnumafe(long maxnumafe)

Sets the number of preallocated affine expressions in the optimization task. When this number is reached MOSEK will automatically allocate more space for affine expressions. It is never mandatory to call this function, since MOSEK will reallocate any internal structures whenever it is required.

Parameters

maxnumafe (long) – Number of preallocated affine expressions. (input)

Groups

Environment and task management, Problem data - affine expressions

Task.putmaxnumanz
putmaxnumanz(long maxnumanz)

Sets the number of preallocated non-zero entries in \(A\).

MOSEK stores only the non-zero elements in the linear coefficient matrix \(A\) and it cannot predict how much storage is required to store \(A\). Using this function it is possible to specify the number of non-zeros to preallocate for storing \(A\).

If the number of non-zeros in the problem is known, it is a good idea to set maxnumanz slightly larger than this number, otherwise a rough estimate can be used. In general, if \(A\) is inputted in many small chunks, setting this value may speed up the data input phase.

It is not mandatory to call this function, since MOSEK will reallocate internal structures whenever it is necessary.

The function call has no effect if both maxnumcon and maxnumvar are zero.

Parameters

maxnumanz (long) – Number of preallocated non-zeros in \(A\). (input)

Groups

Environment and task management, Problem data - linear part

Task.putmaxnumbarvar
putmaxnumbarvar(int maxnumbarvar)

Sets the number of preallocated symmetric matrix variables in the optimization task. When this number of variables is reached MOSEK will automatically allocate more space for variables.

It is not mandatory to call this function. It only gives a hint about the amount of data to preallocate for efficiency reasons.

Please note that maxnumbarvar must be larger than the current number of symmetric matrix variables in the task.

Parameters

maxnumbarvar (int) – Number of preallocated symmetric matrix variables. (input)

Groups

Environment and task management, Problem data - semidefinite

Task.putmaxnumcon
putmaxnumcon(int maxnumcon)

Sets the number of preallocated constraints in the optimization task. When this number of constraints is reached MOSEK will automatically allocate more space for constraints.

It is never mandatory to call this function, since MOSEK will reallocate any internal structures whenever it is required.

Please note that maxnumcon must be larger than the current number of constraints in the task.

Parameters

maxnumcon (int) – Number of preallocated constraints in the optimization task. (input)

Groups

Environment and task management, Problem data - constraints

Task.putmaxnumcone Deprecated
putmaxnumcone(int maxnumcone)

NOTE: This interface to conic optimization is deprecated and will be removed in a future major release. Conic problems should be specified using the affine conic constraints interface (ACC), see Sec. 6.2 (From Linear to Conic Optimization) for details.

Sets the number of preallocated conic constraints in the optimization task. When this number of conic constraints is reached MOSEK will automatically allocate more space for conic constraints.

It is not mandatory to call this function, since MOSEK will reallocate any internal structures whenever it is required.

Please note that maxnumcon must be larger than the current number of conic constraints in the task.

Parameters

maxnumcone (int) – Number of preallocated conic constraints in the optimization task. (input)

Groups

Environment and task management, Problem data - cones (deprecated)

Task.putmaxnumdjc
putmaxnumdjc(long maxnumdjc)

Sets the number of preallocated disjunctive constraints in the optimization task. When this number is reached MOSEK will automatically allocate more space. It is never mandatory to call this function, since MOSEK will reallocate any internal structures whenever it is required.

Parameters

maxnumdjc (long) – Number of preallocated disjunctive constraints in the task. (input)

Groups

Environment and task management, Problem data - disjunctive constraints

Task.putmaxnumdomain
putmaxnumdomain(long maxnumdomain)

Sets the number of preallocated domains in the optimization task. When this number is reached MOSEK will automatically allocate more space. It is never mandatory to call this function, since MOSEK will reallocate any internal structures whenever it is required.

Parameters

maxnumdomain (long) – Number of preallocated domains. (input)

Groups

Environment and task management, Problem data - domain

Task.putmaxnumqnz
putmaxnumqnz(long maxnumqnz)

Sets the number of preallocated non-zero entries in quadratic terms.

MOSEK stores only the non-zero elements in \(Q\). Therefore, MOSEK cannot predict how much storage is required to store \(Q\). Using this function it is possible to specify the number non-zeros to preallocate for storing \(Q\) (both objective and constraints).

It may be advantageous to reserve more non-zeros for \(Q\) than actually needed since it may improve the internal efficiency of MOSEK, however, it is never worthwhile to specify more than the double of the anticipated number of non-zeros in \(Q\).

It is not mandatory to call this function, since MOSEK will reallocate internal structures whenever it is necessary.

Parameters

maxnumqnz (long) – Number of non-zero elements preallocated in quadratic coefficient matrices. (input)

Groups

Environment and task management, Problem data - quadratic part

Task.putmaxnumvar
putmaxnumvar(int maxnumvar)

Sets the number of preallocated variables in the optimization task. When this number of variables is reached MOSEK will automatically allocate more space for variables.

It is not mandatory to call this function. It only gives a hint about the amount of data to preallocate for efficiency reasons.

Please note that maxnumvar must be larger than the current number of variables in the task.

Parameters

maxnumvar (int) – Number of preallocated variables in the optimization task. (input)

Groups

Environment and task management, Problem data - variables

Task.putnadouparam
putnadouparam(string paramname,
              double parvalue)

Sets the value of a named double parameter.

Parameters
  • paramname (string) – Name of a parameter. (input)

  • parvalue (double) – Parameter value. (input)

Groups

Parameters

Task.putnaintparam
putnaintparam(string paramname,
              int parvalue)

Sets the value of a named integer parameter.

Parameters
  • paramname (string) – Name of a parameter. (input)

  • parvalue (int) – Parameter value. (input)

Groups

Parameters

Task.putnastrparam
putnastrparam(string paramname,
              string parvalue)

Sets the value of a named string parameter.

Parameters
  • paramname (string) – Name of a parameter. (input)

  • parvalue (string) – Parameter value. (input)

Groups

Parameters

Task.putobjname
putobjname(string objname)

Assigns a new name to the objective.

Parameters

objname (string) – Name of the objective. (input)

Groups

Problem data - linear part, Names, Problem data - objective

Task.putobjsense
putobjsense(objsense sense)

Sets the objective sense of the task.

Parameters

sense (mosek.objsense) – The objective sense of the task. The values objsense.maximize and objsense.minimize mean that the problem is maximized or minimized respectively. (input)

Groups

Problem data - linear part, Problem data - objective

Task.putoptserverhost
putoptserverhost(string host)

Specify an OptServer URL for remote calls. The URL should contain protocol, host and port in the form http://server:port or https://server:port. If the URL is set using this function, all subsequent calls to any MOSEK function that involves synchronous optimization will be sent to the specified OptServer instead of being executed locally. Passing NULL deactivates this redirection.

Has the same effect as setting the parameter sparam.remote_optserver_host.

Parameters

host (string) – A URL specifying the optimization server to be used. (input)

Groups

Remote optimization

Task.putparam
putparam(string parname,
         string parvalue)

Checks if parname is valid parameter name. If it is, the parameter is assigned the value specified by parvalue.

Parameters
  • parname (string) – Parameter name. (input)

  • parvalue (string) – Parameter value. (input)

Groups

Parameters

Task.putqcon
putqcon(int[] qcsubk,
        int[] qcsubi,
        int[] qcsubj,
        double[] qcval)

Replace all quadratic entries in the constraints. The list of constraints has the form

\[l_k^c \leq \half \sum_{i=0}^{\idxend{numvar}} \sum_{j=0}^{\idxend{numvar}} q_{ij}^k x_i x_j + \sum_{j=0}^{\idxend{numvar}} a_{kj} x_j \leq u_k^c, ~\ k=0,\ldots,m-1.\]

This function sets all the quadratic terms to zero and then performs the update:

\[q_{\mathtt{qcsubi[t]},\mathtt{qcsubj[t]}}^{\mathtt{qcsubk[t]}} = q_{\mathtt{\mathtt{qcsubj[t]},qcsubi[t]}}^{\mathtt{qcsubk[t]}} = q_{\mathtt{\mathtt{qcsubj[t]},qcsubi[t]}}^{\mathtt{qcsubk[t]}} + \mathtt{qcval[t]},\]

for \(t=\idxbeg,\ldots,\idxend{numqcnz}\).

Please note that:

  • For large problems it is essential for the efficiency that the function Task.putmaxnumqnz is employed to pre-allocate space.

  • Only the lower triangular parts should be specified because the \(Q\) matrices are symmetric. Specifying entries where \(i < j\) will result in an error.

  • Only non-zero elements should be specified.

  • The order in which the non-zero elements are specified is insignificant.

  • Duplicate elements are added together as shown above. Hence, it is usually not recommended to specify the same entry multiple times.

For a code example see Section Quadratic Optimization

Parameters
  • qcsubk (int[]) – Constraint subscripts for quadratic coefficients. (input)

  • qcsubi (int[]) – Row subscripts for quadratic constraint matrix. (input)

  • qcsubj (int[]) – Column subscripts for quadratic constraint matrix. (input)

  • qcval (double[]) – Quadratic constraint coefficient values. (input)

Groups

Problem data - quadratic part

Task.putqconk
putqconk(int k,
         int[] qcsubi,
         int[] qcsubj,
         double[] qcval)

Replaces all the quadratic entries in one constraint. This function performs the same operations as Task.putqcon but only with respect to constraint number k and it does not modify the other constraints. See the description of Task.putqcon for definitions and important remarks.

Parameters
  • k (int) – The constraint in which the new \(Q\) elements are inserted. (input)

  • qcsubi (int[]) – Row subscripts for quadratic constraint matrix. (input)

  • qcsubj (int[]) – Column subscripts for quadratic constraint matrix. (input)

  • qcval (double[]) – Quadratic constraint coefficient values. (input)

Groups

Problem data - quadratic part

Task.putqobj
putqobj(int[] qosubi,
        int[] qosubj,
        double[] qoval)

Replace all quadratic terms in the objective. If the objective has the form

\[\half \sum_{i=0}^{\idxend{numvar}} \sum_{j=0}^{\idxend{numvar}} q_{ij}^o x_i x_j + \sum_{j=0}^{\idxend{numvar}} c_{j} x_j + c^f\]

then this function sets all the quadratic terms to zero and then performs the update:

\[q_{\mathtt{qosubi[t]},\mathtt{qosubj[t]}}^{o} = q_{\mathtt{\mathtt{qosubj[t]},qosubi[t]}}^{o} = q_{\mathtt{\mathtt{qosubj[t]},qosubi[t]}}^{o} + \mathtt{qoval[t]},\]

for \(t=\idxbeg,\ldots,\idxend{numqonz}\).

See the description of Task.putqcon for important remarks and example.

Parameters
  • qosubi (int[]) – Row subscripts for quadratic objective coefficients. (input)

  • qosubj (int[]) – Column subscripts for quadratic objective coefficients. (input)

  • qoval (double[]) – Quadratic objective coefficient values. (input)

Groups

Problem data - quadratic part, Problem data - objective

Task.putqobjij
putqobjij(int i,
          int j,
          double qoij)

Replaces one coefficient in the quadratic term in the objective. The function performs the assignment

\[q_{ij}^o = q_{ji}^o = \mathtt{qoij}.\]

Only the elements in the lower triangular part are accepted. Setting \(q_{ij}\) with \(j>i\) will cause an error.

Please note that replacing all quadratic elements one by one is more computationally expensive than replacing them all at once. Use Task.putqobj instead whenever possible.

Parameters
  • i (int) – Row index for the coefficient to be replaced. (input)

  • j (int) – Column index for the coefficient to be replaced. (input)

  • qoij (double) – The new value for \(q_{ij}^o\). (input)

Groups

Problem data - quadratic part, Problem data - objective

Task.putskc
putskc(soltype whichsol,
       stakey[] skc)

Sets the status keys for the constraints.

Parameters
Groups

Solution information

Task.putskcslice
putskcslice(soltype whichsol,
            int first,
            int last,
            stakey[] skc)

Sets the status keys for a slice of the constraints.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • skc (mosek.stakey[]) – Status keys for the constraints. (input)

Groups

Solution information

Task.putskx
putskx(soltype whichsol,
       stakey[] skx)

Sets the status keys for the scalar variables.

Parameters
Groups

Solution information

Task.putskxslice
putskxslice(soltype whichsol,
            int first,
            int last,
            stakey[] skx)

Sets the status keys for a slice of the variables.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • skx (mosek.stakey[]) – Status keys for the variables. (input)

Groups

Solution information

Task.putslc
putslc(soltype whichsol,
       double[] slc)

Sets the \(s_l^c\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • slc (double[]) – Dual variables corresponding to the lower bounds on the constraints. (input)

Groups

Solution - dual

Task.putslcslice
putslcslice(soltype whichsol,
            int first,
            int last,
            double[] slc)

Sets a slice of the \(s_l^c\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • slc (double[]) – Dual variables corresponding to the lower bounds on the constraints. (input)

Groups

Solution - dual

Task.putslx
putslx(soltype whichsol,
       double[] slx)

Sets the \(s_l^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • slx (double[]) – Dual variables corresponding to the lower bounds on the variables. (input)

Groups

Solution - dual

Task.putslxslice
putslxslice(soltype whichsol,
            int first,
            int last,
            double[] slx)

Sets a slice of the \(s_l^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • slx (double[]) – Dual variables corresponding to the lower bounds on the variables. (input)

Groups

Solution - dual

Task.putsnx
putsnx(soltype whichsol,
       double[] sux)

Sets the \(s_n^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • sux (double[]) – Dual variables corresponding to the upper bounds on the variables. (input)

Groups

Solution - dual

Task.putsnxslice
putsnxslice(soltype whichsol,
            int first,
            int last,
            double[] snx)

Sets a slice of the \(s_n^x\) vector for a solution.

Parameters
  • whichsol (mosek.soltype) – Selects a solution. (input)

  • first (int) – First index in the sequence. (input)

  • last (int) – Last index plus 1 in the sequence. (input)

  • snx (double[]) – Dual variables co