13. API reference


This chapter lists all functionality in the MOSEK Python API.

13.1. API Functionality

Functions in the interface grouped by functionality.

13.1.1. Reading and writing data files.

Reading and writing data files.

mosek.Task.readbranchpriorities
Reads branching priority data from a file.

mosek.Task.readdata
Reads problem data from a file.

mosek.Task.readparamfile
Reads a parameter file.

mosek.Task.readsolution
Reads a solution from a file.

mosek.Task.readsummary
Prints information about last file read.

mosek.Task.writebranchpriorities
Writes branching priority data to a file.

mosek.Task.writeparamfile
Writes all the parameters to a parameter file.

mosek.Task.writesolution
Write a solution to a file.

13.1.2. Solutions.

Obtain or define a solution.

mosek.Task.deletesolution
Undefines a solution and frees the memory it uses.

mosek.Task.getdualobj
Obtains the dual objective value.

mosek.Task.getprimalobj
Obtains the primal objective value.

mosek.Task.getreducedcosts
Obtains the difference of slx-sux for a sequence of variables.

mosek.Task.getsolution
Obtains the complete solution.

mosek.Task.getsolutioni
Obtains the solution for a single constraint or variable.

mosek.Task.getsolutioninf
Obtains information about a solution.

mosek.Task.getsolutionslice
Obtains a slice of the solution.

mosek.Task.getsolutionstatus
Obtains information about the problem and solution statuses.

mosek.Task.getsolutionstatuskeyslice
Obtains a slice of the solution status keys.

mosek.Task.makesolutionstatusunknown
Sets the solution status to unknown.

mosek.Task.putsolution
Inserts a solution.

mosek.Task.putsolutioni
Sets the primal and dual solution information for a single constraint or variable.

mosek.Task.readsolution
Reads a solution from a file.

mosek.Task.solutiondef
Checks whether a solution is defined.

mosek.Task.solutionsummary
Prints a short summary of a solution.

mosek.Task.undefsolution
Undefines a solution.

mosek.Task.writedata
Writes problem data to a file.

13.1.3. Memory allocation and deallocation.

Memory allocation and deallocation.

mosek.Task.checkmemtask
Checks the memory allocated by the task.

mosek.Task.getmemusagetask
Obtains information about the amount of memory used by a task.

13.1.4. Changing problem specification.

Input or change problem specification

mosek.Task.append
Appends a number of variables or constraints to the optimization task.

mosek.Task.appendcone
Appends a new cone constraint to the problem.

mosek.Task.appendcons
Appends one or more constraints and specifies bounds and A coefficients.

mosek.Task.appendvars
Appends one or more variables and specifies bounds on variables, c coefficients and A coefficients.

mosek.Task.chgbound
Changes the bounds for one constraint or variable.

mosek.Task.clonetask
Creates a clone of an existing task.

mosek.Task.commitchanges
Commits all cached problem changes.

mosek.Task.inputdata
Input the linear part of an optimization task in one function call.

mosek.Task.putaij
Changes a single value in the linear coefficient matrix.

mosek.Task.putaijlist
Changes one or more coefficients in A.

mosek.Task.putavec
Replaces all elements in one row or column of A.

mosek.Task.putaveclist
Replaces all elements in one or more rows or columns in A by new values.

mosek.Task.putbound
Changes the bound for either one constraint or one variable.

mosek.Task.putboundlist
Changes the bounds of constraints or variables.

mosek.Task.putboundslice
Modifies bounds.

mosek.Task.putcfix
Replaces the fixed term in the objective.

mosek.Task.putcj
Modifies one linear coefficient in the objective.

mosek.Task.putclist
Modifies a part of c.

mosek.Task.putcone
Replaces a conic constraint.

mosek.Task.putobjsense
Sets the objective sense.

mosek.Task.putqcon
Replaces all quadratic terms in constraints.

mosek.Task.putqconk
Replaces all quadratic terms in a single constraint.

mosek.Task.putqobj
Replaces all quadratic terms in the objective.

mosek.Task.putqobjij
Replaces one of the coefficients in the quadratic term in the objective.

mosek.Task.putvartype
Sets the variable type of one variable.

mosek.Task.putvartypelist
Sets the variable type for one or more variables.

13.1.5. Delete problem elements (variables,constraints,cones).

Functionality for deleting problem elements such as variables, constraints or cones.

mosek.Task.remove
The function removes a number of constraints or variables.

mosek.Task.removecone
Removes a conic constraint from the problem.

13.1.6. Add problem elements (variables,constraints,cones).

Functionality for adding problem elements such as variables, constraints or cones.

mosek.Task.append
Appends a number of variables or constraints to the optimization task.

mosek.Task.appendcone
Appends a new cone constraint to the problem.

13.1.7. Inspect problem specification.

Functionality for inspecting the problem specification (A,Q, bounds, objective e.t.c).

mosek.Task.getaij
Obtains a single coefficient in A.

mosek.Task.getaslice
Obtains a sequence of rows or columns from A.

mosek.Task.getaslicetrip
Obtains a sequence of rows or columns from A in triplet format.

mosek.Task.getavec
Obtains one row or column of A.

mosek.Task.getavecnumnz
Obtains the number of non-zero elements in one row or column of A.

mosek.Task.getbound
Obtains bound information for one constraint or variable.

mosek.Task.getboundslice
Obtains bounds information for a sequence of variables or constraints.

mosek.Task.getc
Obtains all objective coefficients c.

mosek.Task.getcfix
Obtains the fixed term in the objective.

mosek.Task.getcone
Obtains a conic constraint.

mosek.Task.getconeinfo
Obtains information about a conic constraint.

mosek.Task.getcslice
Obtains a part of c.

mosek.Task.getnumanz
Obtains the number of non-zeros in A.

mosek.Task.getnumcon
Obtains the number of constraints.

mosek.Task.getnumcone
Obtains the number of cones.

mosek.Task.getnumconemem
Obtains the number of members in a cone.

mosek.Task.getnumintvar
Obtains the number of integer constrained variables.

mosek.Task.getnumqconnz
Obtains the number of non-zero quadratic terms in a constraint.

mosek.Task.getnumqobjnz
Obtains the number of non-zero quadratic terms in the objective.

mosek.Task.getnumvar
Obtains the number of variables.

mosek.Task.getobjsense
Gets the objective sense.

mosek.Task.getprobtype
Obtains the problem type.

mosek.Task.getqconk
Obtains all the quadratic terms in a constraint.

mosek.Task.getqobj
Obtains all the quadratic terms in the objective.

mosek.Task.getqobjij
Obtains one coefficient from the quadratic term of the objective

mosek.Task.getvartype
Gets the variable type of one variable.

mosek.Task.getvartypelist
Obtains the variable type for one or more variables.

13.1.8. Conic constraints.

Functionality related to conic terms in the problem.

mosek.Task.appendcone
Appends a new cone constraint to the problem.

mosek.Task.getcone
Obtains a conic constraint.

mosek.Task.getconeinfo
Obtains information about a conic constraint.

mosek.Task.getnumcone
Obtains the number of cones.

mosek.Task.putcone
Replaces a conic constraint.

mosek.Task.removecone
Removes a conic constraint from the problem.

13.1.9. Bounds.

Functionality related to changing or inspecting bounds on variables or constraints.

mosek.Task.chgbound
Changes the bounds for one constraint or variable.

mosek.Task.getbound
Obtains bound information for one constraint or variable.

mosek.Task.getboundslice
Obtains bounds information for a sequence of variables or constraints.

mosek.Task.putbound
Changes the bound for either one constraint or one variable.

mosek.Task.putboundlist
Changes the bounds of constraints or variables.

mosek.Task.putboundslice
Modifies bounds.

13.1.10. Output stream functions.

Output stream functions.

mosek.Env.echointro
Prints an intro to message stream.

mosek.Env.linkfiletoenvstream
Directs all output from a stream to a file.

mosek.Task.linkfiletotaskstream
Directs all output from a task stream to a file.

mosek.Task.printdata
Prints a part of the problem data to a stream.

mosek.Task.printparam
Prints the current parameter settings.

mosek.Task.readsummary
Prints information about last file read.

mosek.Task.solutionsummary
Prints a short summary of a solution.

13.1.11. Objective function.

Change or inspect objective function.

mosek.Task.getc
Obtains all objective coefficients c.

mosek.Task.getcfix
Obtains the fixed term in the objective.

mosek.Task.getcslice
Obtains a part of c.

mosek.Task.getdualobj
Obtains the dual objective value.

mosek.Task.getnumqobjnz
Obtains the number of non-zero quadratic terms in the objective.

mosek.Task.getobjname
Obtains the name assigned to the objective function.

mosek.Task.getobjsense
Gets the objective sense.

mosek.Task.getprimalobj
Obtains the primal objective value.

mosek.Task.getqobj
Obtains all the quadratic terms in the objective.

mosek.Task.getqobjij
Obtains one coefficient from the quadratic term of the objective

mosek.Task.putcfix
Replaces the fixed term in the objective.

mosek.Task.putcj
Modifies one linear coefficient in the objective.

mosek.Task.putclist
Modifies a part of c.

mosek.Task.putobjsense
Sets the objective sense.

mosek.Task.putqobj
Replaces all quadratic terms in the objective.

mosek.Task.putqobjij
Replaces one of the coefficients in the quadratic term in the objective.

13.1.12. Inspect statistics from the optimizer.

Inspect statistics from the optimizer.

mosek.Task.appendstat
Appends a record the statistics file.

mosek.Task.getdouinf
Obtains a double information item.

mosek.Task.getintinf
Obtains an integer information item.

mosek.Task.startstat
Starts the statistics file.

mosek.Task.stopstat
Stops the statistics file.

13.1.13. Parameters (set/get).

Setting and inspecting solver parameters.

mosek.Task.getdouparam
Obtains a double parameter.

mosek.Task.getintparam
Obtains an integer parameter.

mosek.Task.getnumparam
Obtains the number of parameters of a given type.

mosek.Task.getstrparam
Obtains the value of a string parameter.

mosek.Env.getsymbcondim
Obtains dimensional information for the defined symbolic constants.

mosek.Task.isdouparname
Checks a double parameter name.

mosek.Task.isintparname
Checks an integer parameter name.

mosek.Task.isstrparname
Checks a string parameter name.

mosek.Task.putdouparam
Sets a double parameter.

mosek.Task.putintparam
Sets an integer parameter.

mosek.Task.putnadouparam
Sets a double parameter.

mosek.Task.putnaintparam
Sets an integer parameter.

mosek.Task.putnastrparam
Sets a string parameter.

mosek.Task.putparam
Modifies the value of parameter.

mosek.Task.putstrparam
Sets a string parameter.

mosek.Task.setdefaults
Resets all parameters values.

13.1.14. Naming.

Functionality related to naming.

mosek.Task.getconname
Obtains a name of a constraint.

mosek.Task.getmaxnamelen
Obtains the maximum length of any objective, constraint, variable or cone name.

mosek.Task.getname
Obtains the name of a cone, a variable or a constraint.

mosek.Task.getnameindex
Checks whether a name has been assigned and returns the index corresponding to the name.

mosek.Task.getobjname
Obtains the name assigned to the objective function.

mosek.Task.gettaskname
Obtains the task name.

mosek.Task.getvarname
Obtains a name of a variable.

mosek.Task.putname
Assigns the name name to a problem item such as a constraint.

mosek.Task.putobjname
Assigns a new name to the objective.

mosek.Task.puttaskname
Assigns a new name to the task.

13.1.15. Preallocating space for problem data.

Functionality related to preallocating space for problem data.

mosek.Task.getmaxnumanz
Obtains number of preallocated non-zeros for A.

mosek.Task.getmaxnumcon
Obtains the number of preallocated constraints in the optimization task.

mosek.Task.getmaxnumcone
Obtains the number of preallocated cones in the optimization task.

mosek.Task.getmaxnumqnz
Obtains the number of preallocated non-zeros for Q (both objective and constraints).

mosek.Task.getmaxnumvar
Obtains the maximum number variables allowed.

mosek.Task.putmaxnumanz
The function changes the size of the preallocated storage for linear coefficients.

mosek.Task.putmaxnumcon
Sets the number of preallocated constraints in the optimization task.

mosek.Task.putmaxnumcone
Sets the number of preallocated conic constraints in the optimization task.

mosek.Task.putmaxnumqnz
Changes the size of the preallocated storage for Q.

mosek.Task.putmaxnumvar
Sets the number of preallocated variables in the optimization task.

13.1.16. Integer variables.

Functionality related to integer variables.

mosek.Task.getnumintvar
Obtains the number of integer constrained variables.

mosek.Task.getvarbranchdir
Obtains the branching direction for a variable.

mosek.Task.getvarbranchpri
Obtains the branching priority for a variable.

mosek.Task.getvartype
Gets the variable type of one variable.

mosek.Task.getvartypelist
Obtains the variable type for one or more variables.

mosek.Task.putvarbranchorder
Assigns a branching priority and direction to a variable.

mosek.Task.putvartype
Sets the variable type of one variable.

mosek.Task.putvartypelist
Sets the variable type for one or more variables.

13.1.17. Quadratic terms.

Functionality related to quadratic terms.

mosek.Task.getqconk
Obtains all the quadratic terms in a constraint.

mosek.Task.getqobj
Obtains all the quadratic terms in the objective.

mosek.Task.getqobjij
Obtains one coefficient from the quadratic term of the objective

mosek.Task.putqcon
Replaces all quadratic terms in constraints.

mosek.Task.putqconk
Replaces all quadratic terms in a single constraint.

mosek.Task.putqobj
Replaces all quadratic terms in the objective.

mosek.Task.putqobjij
Replaces one of the coefficients in the quadratic term in the objective.

13.1.18. Diagnosing infeasibility.

Functions for diagnosing infeasibility.

mosek.Task.getinfeasiblesubproblem
Obtains an infeasible sub problem.

mosek.Task.relaxprimal
Creates a problem that finds the minimal change to the bounds that makes an infeasible problem feasible.

13.1.19. Optimization.

Functions for optimization.

mosek.Task.checkdata
Checks data of the task.

mosek.Task.optimize
Optimizes the problem.

mosek.Task.optimizeconcurrent
Optimize a given task with several optimizers concurrently.

mosek.Task.optimizetrm
Optimizes the problem.

13.1.20. Sensitivity analysis.

Functions for sensitivity analysis.

mosek.Task.dualsensitivity
Performs sensitivity analysis on objective coefficients.

mosek.Task.primalsensitivity
Perform sensitivity analysis on bounds.

mosek.Task.sensitivityreport
Creates a sensitivity report.

13.1.21. Testing data validity.

Functions for testing data validity.

mosek.Task.checkconvexity
Checks if a quadratic optimization problem is convex.

13.1.22. Solving with the basis.

Functions for solving linear systems with the basis matrix.

mosek.Task.initbasissolve
Prepare a task for use with the Task.solvewithbasis function.

mosek.Task.solvewithbasis
Solve a linear equation system involving a basis matrix.

13.1.23. Initialization of environment.

Creation and initialization of environment.

mosek.Env.initenv
Initialize a MOSEK environment.

mosek.Env.putlicensedefaults
Set defaults used by the license manager.

13.1.24. Change A.

Change elements in the coefficient (A) matrix.

mosek.Task.appendcons
Appends one or more constraints and specifies bounds and A coefficients.

mosek.Task.appendvars
Appends one or more variables and specifies bounds on variables, c coefficients and A coefficients.

mosek.Task.commitchanges
Commits all cached problem changes.

mosek.Task.putaij
Changes a single value in the linear coefficient matrix.

mosek.Task.putaijlist
Changes one or more coefficients in A.

mosek.Task.putavec
Replaces all elements in one row or column of A.

mosek.Task.putaveclist
Replaces all elements in one or more rows or columns in A by new values.

13.2. Class mosek.ArrayLengthException

Derived from:

__builtin__.Exception

Description:

This exception is raised is an input or output array was shorter than required.

13.3. Class mosek.Env

Description:

A Mosek Environment

13.3.1. Constructors

  • mosek.Env

    Syntax: 

    Env ()
    
    Description:Create a MOSEK environment object.
  • mosek.Env

    Syntax: 

    Env (str dbgfile)
    
    Description:Create a MOSEK environment object.

    Arguments: 

    dbgfile
    A file which will be used to log memory debugging information from MOSEK

13.3.2. Attributes

  • mosek.CtrlC CtrlC (write only) Control-c call-back object.
  • mosek.Exit Exit (write only) Exit handler call-back object.

13.3.3. Methods

  • mosek.Env.echointro

    Syntax:

     

    echointro (int longver)
    
    Arguments:

     

    longver (input)
    If non-zero, then the intro is slightly longer.
    Description:
    Prints an intro to message stream.
  • mosek.Env.getsymbcondim

    Syntax:

     

    getsymbcondim (
        List|None num,
        List|None maxlen)
    
    Arguments:

     

    num (output)
    Number of symbolic constants defined by MOSEK.
    maxlen (output)
    Maximum length of the name of any symbolic constants.
    Description:
    Obtains the number of symbolic constants defined by MOSEK and the maximum length of the name of any symbolic constant.
  • mosek.Env.getversion

    Syntax:

     

    getversion (
        List|None major,
        List|None minor,
        List|None build,
        List|None revision)
    
    Arguments:

     

    major (output)
    Major version number. Modified only if a non-null pointer.
    minor (output)
    Minor version number. Modified only if a non-null pointer.
    build (output)
    Build number. Modified only if a non-null pointer.
    revision (output)
    Revision number. Modified only if a non-null pointer.
    Description:
    Obtains MOSEK version information.
  • mosek.Env.initenv

    Syntax:

     

    initenv ()
    
    Description:
    This function initializes the MOSEK environment. Among other things the license server will be contacted. Error messages from the license manager can be captured by linking to the environment message stream before calling this function.
  • mosek.Env.isinfinity

    Syntax:

     

    isinfinity (double value)
    
    Arguments:

     

    value
    Description:
    Return true if value considered infinity by MOSEK
  • mosek.Env.linkfiletoenvstream

    Syntax:

     

    linkfiletoenvstream (
        mosek.streamtype whichstream,
        str filename,
        int append)
    
    Arguments:

     

    whichstream (input)
    Index of the stream.
    filename (input)
    Sends all output from the stream defined by whichstream to the file given by filename.
    append (input)
    If this argument is non-zero, the output is appended to the file.
    Description:
    Directs all output from a stream to a file.
  • mosek.Env.putcpudefaults

    Syntax:

     

    putcpudefaults (
        mosek.cputype cputype,
        int sizel1,
        int sizel2)
    
    Arguments:

     

    cputype (input)
    The CPU ID.
    sizel1 (input)
    Size of the L1 cache.
    sizel2 (input)
    Size of the L2 cache.
    Description:
    Sets default CPU type and cache sizes. This function should be called before Env.initenv.
  • mosek.Env.putdllpath

    Syntax:

     

    putdllpath (str dllpath)
    
    Arguments:

     

    dllpath (input)
    A path to where the MOSEK dynamic link/shared libraries are located. If dllpath is NULL, then MOSEK assumes that the operating system can locate the libraries.
    Description:
    Sets the path to the DLL/shared libraries that MOSEK are loading. If needed, then it should normally be called before Env.initenv.
  • mosek.Env.putkeepdlls

    Syntax:

     

    putkeepdlls (int keepdlls)
    
    Arguments:

     

    keepdlls (input)
    Controls whether explicitly loaded DLLs should be kept.
    Description:
    Controls whether explicitly loaded DLLs should be kept when they no longer are in use.
  • mosek.Env.putlicensedefaults

    Syntax:

     

    putlicensedefaults (
        str licensefile,
        array(int) licensebuf,
        int licwait,
        int licdebug)
    
    Arguments:

     

    licensefile (input)
    Either NULL or the path to a valid MOSEK license file.
    licensebuf (input)
    This is the license string authorizing the use of MOSEK in the runtime version of MOSEK. Therefore, most frequently this string is a NULL pointer.
    licwait (input)
    If this argument is non-zero, then MOSEK will wait for a license if no license is available. Moreover, licwait-1 is used as the default value for mosek.iparam.license_pause_time.
    licdebug (input)
    If this argument is non-zero, then MOSEK will print debug info regarding the license checkout.
    Description:
    Sets default values for the license manager. This function should be called before Env.initenv.
  • mosek.Env.set_Stream

    Syntax:

     

    set_Stream (mosek.streamtype whichstream)
    
    Arguments:

     

    whichstream
    Index of the stream.
    Description:
    Attach a stream call-back handler.

13.4. Class mosek.Error

Derived from:

mosek.Exception

Description:

This is an exception class representing MOSEK errors.

13.4.1. Constructors

  • mosek.Error

    Syntax: 

    Error (mosek.rescode code)
    
    Description:Construct an error from a MOSEK error code.

    Arguments: 

    code
    The MOSEK response code to create the exception from.
  • mosek.Error

    Syntax: 

    Error (
        mosek.rescode code,
        str msg)
    
    Description:Construct an error from a MOSEK error code and a message.

    Arguments: 

    code
    The MOSEK response code to create the exception from.
    msg
    A message describing the error situation.

13.5. Class mosek.Exception

Derived from:

__builtin__.Exception

Description:

This is the base class for exceptions based on MOSEK response codes.

13.5.1. Constructors

  • mosek.Exception

    Syntax: 

    Exception (mosek.rescode code)
    
    Description:Construct an exception from a MOSEK error code.

    Arguments: 

    code
    The MOSEK response code to create the exception from.

13.6. Class mosek.Task

Description:

A Mosek Optimization task

13.6.1. Constructors

  • mosek.Task

    Syntax: 

    Task (
        int maxnumcon,
        int maxnumvar)
    
    Description:Create a new MOSEK task and reserve space for constraints and variables. Please note that it is perfectly legal to specify 0 constraint or 0 variables: The values may be specified later with Task.putmaxnumcon and Task.putmaxnumvar. Even without doing so, the task will automatically resize when exceeding the maximum, but if this happens often, there will be some overhead when resizing.

    Arguments: 

    maxnumcon
    Initially reserve space for this many constraints.
    maxnumvar
    Initially reserve space for this many variables.

13.6.2. Attributes

  • mosek.ErrorHandler ErrorHandler (write only) Error handler call-back object
  • mosek.Nonlinear Nonlinear (write only) Nonlinear sparsity and value computation call-back object.
  • mosek.Progress Progress (write only) Progress call-back object

13.6.3. Methods

  • mosek.Task.append

    Syntax:

     

    append (
        mosek.accmode accmode,
        int num)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    num (input)
    Number of constraints or variables which should be appended.
    Description:
    Appends a number of constraints or variables to the model. Appended constraints will be declared free and appended variables will be fixed at the level zero. Please note that MOSEK will automatically expand the problem dimension to accommodate the additional constraints and variables.
    See also:

     

    Task.remove

    The function removes a number of constraints or variables.

  • mosek.Task.appendcone

    Syntax:

     

    appendcone (
        mosek.conetype conetype,
        double conepar,
        array(int) submem)
    
    Arguments:

     

    conetype (input)
    Specifies the type of the cone.
    conepar (input)
    This argument is currently not used. Can be set to 0.0.
    submem (input)
    Variable subscripts of the members in the cone.
    Description:

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

    \begin{displaymath}\nonumber{}x^{t}\in{}\mathcal{C}\end{displaymath}

    to the problem where [[MathCmd 51]] is a convex cone. [[MathCmd 517]] is a subset of the variables which will be specified by the argument submem. Please note that the sets of variables appearing in different conic constraints must be disjoint.

    For an explained code example see section 5.4.

  • mosek.Task.appendcons

    Syntax:

     

    appendcons (
        array(int) aptrb,
        array(int) aptre,
        array(int) asub,
        array(double) aval,
        array(int) bkc,
        array(double) blc,
        array(double) buc)
    
    Arguments:

     

    aptrb (input)
    See (13.6.2).
    aptre (input)
    See (13.6.2).
    asub (input)
    Variable subscripts of the new A coefficients. See (13.6.2).
    aval (input)
    A coefficients of the new constraints. See (13.6.2).
    bkc (input)
    Bound keys for constraints to be appended. See (13.6.1).
    blc (input)
    Lower bounds on constraints to be appended. See (13.6.1).
    buc (input)
    Upper bounds on constraints to be appended. See (13.6.1).
    Description:

    The function appends one or more constraints to the optimization task. The bounds and A are modified as follows

    \begin{math}\nonumber{}\begin{array}{lcll}\nonumber{}l_{{\mathtt{numcon+k}}}^{c} & = & \mathtt{blc[k]}, & \mathtt{k}=0,\ldots ,\mathtt{num}-1,\\\nonumber{}u_{{\mathtt{numcon+k}}}^{c} & = & \mathtt{buc[k]}, & \mathtt{k}=0,\ldots ,\mathtt{num}-1,\end{array}\end{math} (13.6.1)

    and

    \begin{math}\nonumber{}\begin{array}{lclll}\nonumber{}a_{{\mathtt{numcon+k,\mathtt{asub[l]}}}} & = & \mathtt{aval[l]}, & k=0,\ldots ,\mathtt{num}-1, & l=\mathtt{aptrb[k]},\ldots ,\mathtt{aptre[k]-1}.\end{array}\end{math} (13.6.2)
    See also:

     

    Task.putmaxnumcon

    Sets the number of preallocated constraints in the optimization task.

  • mosek.Task.appendstat

    Syntax:

     

    appendstat ()
    
    Description:
    Appends a record to the statistics file.
  • mosek.Task.appendvars

    Syntax:

     

    appendvars (
        array(double) cval,
        array(int) aptrb,
        array(int) aptre,
        array(int) asub,
        array(double) aval,
        array(int) bkx,
        array(double) blx,
        array(double) bux)
    
    Arguments:

     

    cval (input)
    Values of c for the variables to be appended. See (13.6.3).
    aptrb (input)
    See (13.6.4).
    aptre (input)
    See (13.6.4).
    asub (input)
    Constraint subscripts of the A coefficients to be added. See (13.6.4).
    aval (input)
    The A coefficients corresponding to the appended variables. See (13.6.4).
    bkx (input)
    Bound keys on variables to be appended. See (13.6.3).
    blx (input)
    Lower bounds on variables to be appended. See (13.6.3).
    bux (input)
    Upper bounds on variables to be appended. See (13.6.3).
    Description:

    The function appends one or more variables to the optimization problem. Moreover, the function initializes c, A and the bounds corresponding to the appended variables as follows

    \begin{math}\nonumber{}\begin{array}{lcll}\nonumber{}c_{{\mathtt{numvar+k}}} & = & \mathtt{cval[k]}, & \mathtt{k}=0,\ldots ,\mathtt{num}-1,\\\nonumber{}l_{{\mathtt{numvar+k}}}^{x} & = & \mathtt{blx[k]}, & \mathtt{k}=0,\ldots ,\mathtt{num}-1,\\\nonumber{}u_{{\mathtt{numvar+k}}}^{x} & = & \mathtt{bux[k]}, & \mathtt{k}=0,\ldots ,\mathtt{num}-1,\end{array}\end{math} (13.6.3)

    and

    \begin{math}\nonumber{}\begin{array}{lclll}\nonumber{}a_{{\mathtt{asub[l]},\mathtt{numvar+k}}} & = & \mathtt{aval[l]}, & k=0,\ldots ,\mathtt{num}-1, & l=\mathtt{aptrb[k]},\ldots ,\mathtt{aptre[k]-1}\end{array}\end{math} (13.6.4)

    where numvar is the number variables before the new variables are appended.

    See also:

     

    Task.putmaxnumvar

    Sets the number of preallocated variables in the optimization task.

  • mosek.Task.checkconvexity

    Syntax:

     

    checkconvexity ()
    
    Description:
    This function checks if a quadratic optimization problem is convex. The amount of checking is controlled by mosek.iparam.check_convexity. The function returns mosek.rescode.err_nonconvex if the problem is not convex.
    See also:

     

    mosek.iparam.check_convexity
  • mosek.Task.checkdata

    Syntax:

     

    checkdata ()
    
    Description:
    Checks the data of the optimization task.
  • mosek.Task.checkmemtask

    Syntax:

     

    checkmemtask (
        str file,
        int line)
    
    Arguments:

     

    file (input)
    File from which the function is called.
    line (input)
    Line in the file from which the function is called.
    Description:
    Checks the memory allocated by the task.
  • mosek.Task.chgbound

    Syntax:

     

    chgbound (
        mosek.accmode accmode,
        int i,
        int lower,
        int finite,
        double value)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    i (input)
    Index of the constraint or variable for which the bounds should be changed.
    lower (input)
    If non-zero, then the lower bound is changed, otherwise the upper bound is changed.
    finite (input)
    If non-zero, then value is assumed to be finite.
    value (input)
    New value for the bound.
    Description:

    Changes a bound for one constraint or variable. If accmode equals mosek.accmode.con, a constraint bound is changed, otherwise a variable bound is changed.

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

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

    Otherwise if lower is zero, then

    \begin{displaymath}\nonumber{}\mbox{new upper bound}=\left\lbrace{}\begin{array}{ll}\nonumber{}\infty , & \mathtt{finite}=0,\\\nonumber{}\mathtt{value} & \mbox{otherwise}.\end{array}\right.\end{displaymath}

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

    See also:

     

    Task.putbound

    Changes the bound for either one constraint or one variable.

    mosek.dparam.data_tol_bound_inf
    mosek.dparam.data_tol_bound_wrn
  • mosek.Task.clonetask

    Syntax:

     

    Task clonetask ()
    
    Returns:
     
    Description:
    Creates a clone of an existing task copying all problem data and parameter settings to a new task. Call-back functions are not copied, so a task containing nonlinear functions cannot be cloned.
  • mosek.Task.commitchanges

    Syntax:

     

    commitchanges ()
    
    Description:
    Commits all cached problem changes to the task. It is usually not necessary explicitly to call this function since changes will be committed automatically when required.
  • mosek.Task.deletesolution

    Syntax:

     

    deletesolution (mosek.soltype whichsol)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    Description:
    Undefines a solution and frees the memory it uses.
  • mosek.Task.dualsensitivity

    Syntax:

     

    dualsensitivity (
        array(int) subj,
        array(double) leftpricej,
        array(double) rightpricej,
        array(double) leftrangej,
        array(double) rightrangej)
    
    Arguments:

     

    subj (input)
    Index of objective coefficients to analyze.
    leftpricej (output)
    [[MathCmd 524]] is the left shadow price for the coefficients with index [[MathCmd 525]].
    rightpricej (output)
    [[MathCmd 526]] is the right shadow price for the coefficients with index [[MathCmd 525]].
    leftrangej (output)
    [[MathCmd 528]] is the left range [[MathCmd 457]] for the coefficient with index [[MathCmd 525]].
    rightrangej (output)
    [[MathCmd 531]] is the right range [[MathCmd 458]] for the coefficient with index [[MathCmd 525]].
    Description:

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

    \begin{displaymath}\nonumber{}\lbrace{}\mathtt{subj}[i]|i\in{}0,\ldots ,\mathtt{numj}-1\rbrace{}\end{displaymath}

    The results are returned so that e.g [[MathCmd 535]] is the left shadow price of the objective coefficient with index [[MathCmd 536]].

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

    For an example, please see section 11.5.

    See also:

     

    Task.primalsensitivity

    Perform sensitivity analysis on bounds.

    Task.sensitivityreport

    Creates a sensitivity report.

    mosek.iparam.sensitivity_type
    mosek.iparam.log_sensitivity
    mosek.iparam.log_sensitivity_opt
  • mosek.Task.getaij

    Syntax:

     

    double getaij (
        int i,
        int j)
    
    Arguments:

     

    i (input)
    Row index of the coefficient to be returned.
    j (input)
    Column index of the coefficient to be returned.
    Returns:
     
    Description:
    Obtains a single coefficient in A.
  • mosek.Task.getapiecenumnz

    Syntax:

     

    int getapiecenumnz (
        int firsti,
        int lasti,
        int firstj,
        int lastj)
    
    Arguments:

     

    firsti (input)
    Index of the first row in the rectangular piece.
    lasti (input)
    Index of the last row plus one in the rectangular piece.
    firstj (input)
    Index of the first column in the rectangular piece.
    lastj (input)
    Index of the last column plus one in the rectangular piece.
    Returns:
     
    Description:

    Obtains the number non-zeros in a rectangular piece of A, i.e. the number

    \begin{displaymath}\nonumber{}\left|\lbrace{}(i,j):~a_{{i,j}}\not=0,~\mathtt{firsti}\leq{}i\leq{}\mathtt{lasti}-1,~\mathtt{firstj}\leq{}j\leq{}\mathtt{lastj}-1\rbrace{}\right|\end{displaymath}

    where [[MathCmd 538]] means the number of elements in the set [[MathCmd 539]].

    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.getavecnumnz.

    See also:

     

    Task.getavecnumnz

    Obtains the number of non-zero elements in one row or column of A.

    Task.getaslicenumnz

    Obtains the number of non-zeros in a row or column slice of A.

  • mosek.Task.getaslice

    Syntax:

     

    getaslice (
        mosek.accmode accmode,
        int first,
        int last,
        List|None surp,
        array(int) ptrb,
        array(int) ptre,
        array(int) sub,
        array(double) val)
    
    Arguments:

     

    accmode (input)
    Defines whether a column-slice or a row-slice is requested.
    first (input)
    Index of the first row or variable in the sequence.
    last (input)
    Index of the last row or variable plus one in the sequence plus one.
    surp (input/output)
    The required rows and columns are stored sequentially in sub and val starting from position maxnumnz-surp[0]. Upon return surp has been decremented by the total number of non-zero elements in the rows and columns obtained.
    ptrb (output)
    ptrb[t] is an index pointing to the first element in the tth row or column obtained.
    ptre (output)
    ptre[t] is an index pointing to the last element plus one in the tth row or column obtained.
    sub (output)
    Contains the row or column subscripts.
    val (output)
    Contains the numerical elements.
    Description:
    Obtains a sequence of rows or columns from A in sparse format.
    See also:

     

    Task.getaslicenumnz

    Obtains the number of non-zeros in a row or column slice of A.

  • mosek.Task.getaslicenumnz

    Syntax:

     

    int getaslicenumnz (
        mosek.accmode accmode,
        int first,
        int last)
    
    Arguments:

     

    accmode (input)
    Defines whether non-zeros are counted in a column-slice or a row-slice.
    first (input)
    Index of the first row or variable in the sequence.
    last (input)
    Index of the last row or variable plus one in the sequence plus one.
    Returns:
     
    Description:
    Obtains the number of non-zeros in a row or column slice of A.
  • mosek.Task.getaslicetrip

    Syntax:

     

    getaslicetrip (
        mosek.accmode accmode,
        int first,
        int last,
        List|None surp,
        array(int) subi,
        array(int) subj,
        array(double) val)
    
    Arguments:

     

    accmode (input)
    Defines whether a column-slice or a row-slice is requested.
    first (input)
    Index of the first row or variable in the sequence.
    last (input)
    Index of the last row or variable in the sequence plus one.
    surp (input/output)
    The required rows and columns are stored sequentially in subi and val starting from position maxnumnz-surp[0]. On return surp has been decremented by the total number of non-zero elements in the rows and columns obtained.
    subi (output)
    Constraint subscripts.
    subj (output)
    Variable subscripts.
    val (output)
    Values.
    Description:
    Obtains a sequence of rows or columns from A in a sparse triplet format.
    See also:

     

    Task.getaslicenumnz

    Obtains the number of non-zeros in a row or column slice of A.

  • mosek.Task.getavec

    Syntax:

     

    getavec (
        mosek.accmode accmode,
        int i,
        List|None nzi,
        array(int) subi,
        array(double) vali)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    i (input)
    Index of the row or column.
    nzi (output)
    Number of non-zeros in the vector obtained.
    subi (output)
    Index of the non-zeros in the vector obtained.
    vali (output)
    Numerical values of the vector to be obtained.
    Description:

    Obtains one row or column of A in a sparse format. If accmode equals mosek.accmode.con a row is returned and hence:

    \begin{displaymath}\nonumber{}\mathtt{vali}[k]=a_{{i,\mathtt{subi}[k]}},\quad{}k=0,\ldots ,\mathtt{nzi[0]}-1\end{displaymath}

    If accmode equals mosek.accmode.var a column is returned, that is:

    \begin{displaymath}\nonumber{}\mathtt{vali}[k]=a_{{\mathtt{subi}[k],i}},\quad{}k=0,\ldots ,\mathtt{nzi[0]}-1.\end{displaymath}
  • mosek.Task.getavecnumnz

    Syntax:

     

    int getavecnumnz (
        mosek.accmode accmode,
        int i)
    
    Arguments:

     

    accmode (input)
    Defines whether non-zeros are counted by columns or by rows.
    i (input)
    Index of the row or column.
    Returns:
     
    Description:
    Obtains the number of non-zero elements in one row or column of A.
  • mosek.Task.getbound

    Syntax:

     

    getbound (
        mosek.accmode accmode,
        int i,
        List|None bk,
        List|None bl,
        List|None bu)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    i (input)
    Index of the constraint or variable for which the bound information should be obtained.
    bk (output)
    Bound keys.
    bl (output)
    Values for lower bounds.
    bu (output)
    Values for upper bounds.
    Description:
    Obtains bound information for one constraint or variable.
  • mosek.Task.getboundslice

    Syntax:

     

    getboundslice (
        mosek.accmode accmode,
        int first,
        int last,
        array(int) bk,
        array(double) bl,
        array(double) bu)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    first (input)
    First index in the sequence.
    last (input)
    Last index plus 1 in the sequence.
    bk (output)
    Bound keys.
    bl (output)
    Values for lower bounds.
    bu (output)
    Values for upper bounds.
    Description:
    Obtains bounds information for a sequence of variables or constraints.
  • mosek.Task.getc

    Syntax:

     

    getc (array(double) c)
    
    Arguments:

     

    c (output)
    Linear terms of the objective as a dense vector. The lengths is the number of variables.
    Description:
    Obtains all objective coefficients c.
  • mosek.Task.getcfix

    Syntax:

     

    double getcfix ()
    
    Returns:
     
    Description:
    Obtains the fixed term in the objective.
  • mosek.Task.getcone

    Syntax:

     

    getcone (
        int k,
        List|None conetype,
        List|None conepar,
        List|None nummem,
        array(int) submem)
    
    Arguments:

     

    k (input)
    Index of the cone constraint.
    conetype (output)
    Specifies the type of the cone.
    conepar (output)
    This argument is currently not used. Can be set to 0.0.
    nummem (output)
    Number of member variables in the cone.
    submem (output)
    Variable subscripts of the members in the cone.
    Description:
    Obtains a conic constraint.
  • mosek.Task.getconeinfo

    Syntax:

     

    getconeinfo (
        int k,
        List|None conetype,
        List|None conepar,
        List|None nummem)
    
    Arguments:

     

    k (input)
    Index of the conic constraint.
    conetype (output)
    Specifies the type of the cone.
    conepar (output)
    This argument is currently not used. Can be set to 0.0.
    nummem (output)
    Number of member variables in the cone.
    Description:
    Obtains information about a conic constraint.
  • mosek.Task.getconname

    Syntax:

     

    str getconname (int i)
    
    Arguments:

     

    i (input)
    Index.
    Returns:
     
    Description:
    Obtains a name of a constraint.
    See also:

     

    Task.getmaxnamelen

    Obtains the maximum length of any objective, constraint, variable or cone name.

  • mosek.Task.getcslice

    Syntax:

     

    getcslice (
        int first,
        int last,
        array(double) c)
    
    Arguments:

     

    first (input)
    First index in the sequence.
    last (input)
    Last index plus 1 in the sequence.
    c (output)
    Linear terms of the objective as a dense vector. The lengths is the number of variables.
    Description:
    Obtains a sequence of elements in c.
  • mosek.Task.getdouinf

    Syntax:

     

    double getdouinf (mosek.dinfitem whichdinf)
    
    Arguments:

     

    whichdinf (input)
    A double information item. See section 16.11 for the possible values.
    Returns:
     
    Description:
    Obtains a double information item from the task information database.
  • mosek.Task.getdouparam

    Syntax:

     

    double getdouparam (mosek.dparam param)
    
    Arguments:

     

    param (input)
    Which parameter.
    Returns:
     
    Description:
    Obtains the value of a double parameter.
  • mosek.Task.getdualobj

    Syntax:

     

    getdualobj (
        mosek.soltype whichsol,
        List|None dualobj)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    dualobj (output)
    Objective value corresponding to the dual solution.
    Description:
    Obtains the current objective value of the dual problem for whichsol.
  • mosek.Task.getinfeasiblesubproblem

    Syntax:

     

    Task getinfeasiblesubproblem (mosek.soltype whichsol)
    
    Arguments:

     

    whichsol (input)
    Which solution to use when determining the infeasible subproblem.
    Returns:
     
    Description:
    Obtains an infeasible subproblem. The infeasible subproblem is a problem consisting of a subset of the original constraints such that the problem is still infeasible. For more information see section 9.
    See also:

     

    mosek.iparam.infeas_prefer_primal
    Task.relaxprimal

    Creates a problem that finds the minimal change to the bounds that makes an infeasible problem feasible.

  • mosek.Task.getintinf

    Syntax:

     

    int getintinf (mosek.iinfitem whichiinf)
    
    Arguments:

     

    whichiinf (input)
    Specifies an information item.
    Returns:
     
    Description:
    Obtains an integer information item from the task information database.
  • mosek.Task.getintparam

    Syntax:

     

    int getintparam (mosek.iparam param)
    
    Arguments:

     

    param (input)
    Which parameter.
    Returns:
     
    Description:
    Obtains the value of an integer parameter.
  • mosek.Task.getmaxnamelen

    Syntax:

     

    getmaxnamelen (List|None maxlen)
    
    Arguments:

     

    maxlen (output)
    The maximum length of any name.
    Description:
    Obtains the maximum length of any objective, constraint, variable or cone name.
  • mosek.Task.getmaxnumanz

    Syntax:

     

    int getmaxnumanz ()
    
    Returns:
     
    Description:
    Obtains number of preallocated non-zeros for A. When this number of non-zeros is reached MOSEK will automatically allocate more space for A.
  • mosek.Task.getmaxnumcon

    Syntax:

     

    getmaxnumcon (List|None maxnumcon)
    
    Arguments:

     

    maxnumcon (output)
    Number of preallocated constraints in the optimization task.
    Description:
    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.
  • mosek.Task.getmaxnumcone

    Syntax:

     

    getmaxnumcone (List|None maxnumcone)
    
    Arguments:

     

    maxnumcone (output)
    Number of preallocated conic constraints in the optimization task.
    Description:
    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.
  • mosek.Task.getmaxnumqnz

    Syntax:

     

    getmaxnumqnz (List|None maxnumqnz)
    
    Arguments:

     

    maxnumqnz (output)
    Number of non-zero elements preallocated in quadratic coefficient matrices.
    Description:
    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.
  • mosek.Task.getmaxnumvar

    Syntax:

     

    getmaxnumvar (List|None maxnumvar)
    
    Arguments:

     

    maxnumvar (output)
    Number of preallocated variables in the optimization task.
    Description:
    Obtains the number of preallocated variables in the optimization task. When this number of variables is reached MOSEK will automatically allocate more space for constraints.
  • mosek.Task.getmemusagetask

    Syntax:

     

    getmemusagetask (
        List|None meminuse,
        List|None maxmemuse)
    
    Arguments:

     

    meminuse (output)
    Amount of memory currently used by the task.
    maxmemuse (output)
    Maximum amount of memory used by the task until now.
    Description:
    Obtains information about the amount of memory used by a task.
  • mosek.Task.getname

    Syntax:

     

    str getname (
        mosek.problemitem whichitem,
        int i,
        List|None len)
    
    Arguments:

     

    whichitem (input)
    Problem item, i.e. a cone, a variable or a constraint name..
    i (input)
    Index.
    len (output)
    Is assigned the length of the required name.
    Returns:
     
    Description:
    Obtains a name of a problem item, i.e. a cone, a variable or a constraint.
    See also:

     

    Task.getmaxnamelen

    Obtains the maximum length of any objective, constraint, variable or cone name.

  • mosek.Task.getnameindex

    Syntax:

     

    int getnameindex (
        mosek.problemitem whichitem,
        str name,
        List|None asgn)
    
    Arguments:

     

    whichitem (input)
    Problem item, i.e. a cone, a variable or a constraint name..
    name (input)
    The name which should be checked.
    asgn (output)
    Is non-zero if name is assigned.
    Returns:
     
    Description:
    Checks if a given name identifies a cone, a constraint or a variable in the task. If it does, the index of that item is assigned to index, and a non-zero value is assigned to asgn. If the name does not identify a problem item, asgn is assigned a zero.
  • mosek.Task.getnumanz

    Syntax:

     

    int getnumanz ()
    
    Returns:
     
    Description:
    Obtains the number of non-zeros in A.
  • mosek.Task.getnumcon

    Syntax:

     

    int getnumcon ()
    
    Returns:
     
    Description:
    Obtains the number of constraints.
  • mosek.Task.getnumcone

    Syntax:

     

    int getnumcone ()
    
    Returns:
     
    Description:
    Obtains the number of cones.
  • mosek.Task.getnumconemem

    Syntax:

     

    getnumconemem (
        int k,
        List|None nummem)
    
    Arguments:

     

    k (input)
    Index of the cone.
    nummem (output)
    Number of member variables in the cone.
    Description:
    Obtains the number of members in a cone.
  • mosek.Task.getnumintvar

    Syntax:

     

    getnumintvar (List|None numintvar)
    
    Arguments:

     

    numintvar (output)
    Number of integer variables.
    Description:
    Obtains the number of integer constrained variables.
  • mosek.Task.getnumparam

    Syntax:

     

    getnumparam (
        mosek.parametertype partype,
        List|None numparam)
    
    Arguments:

     

    partype (input)
    Parameter type.
    numparam (output)
    Identical to the number of parameters of the type partype.
    Description:
    Obtains the number of parameters of a given type.
  • mosek.Task.getnumqconnz

    Syntax:

     

    int getnumqconnz (int i)
    
    Arguments:

     

    i (input)
    Index of the constraint for which the quadratic terms should be obtained.
    Returns:
     
    Description:
    Obtains the number of non-zero quadratic terms in a constraint.
  • mosek.Task.getnumqobjnz

    Syntax:

     

    int getnumqobjnz ()
    
    Returns:
     
    Description:
    Obtains the number of non-zero quadratic terms in the objective.
  • mosek.Task.getnumvar

    Syntax:

     

    int getnumvar ()
    
    Returns:
     
    Description:
    Obtains the number of variables.
  • mosek.Task.getobjname

    Syntax:

     

    str getobjname (List|None len)
    
    Arguments:

     

    len (output)
    Assigned the length of the objective name.
    Returns:
     
    Description:
    Obtains the name assigned to the objective function.
  • mosek.Task.getobjsense

    Syntax:

     

    int getobjsense ()
    
    Returns:
     
    Description:
    Gets the objective sense of the task.
    See also:

     

    Task.putobjsense

    Sets the objective sense.

  • mosek.Task.getprimalobj

    Syntax:

     

    double getprimalobj (mosek.soltype whichsol)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    Returns:
     
    Description:
    Obtains the primal objective value for a solution.
  • mosek.Task.getprobtype

    Syntax:

     

    getprobtype (List|None probtype)
    
    Arguments:

     

    probtype (output)
    The problem type.
    Description:
    Obtains the problem type.
  • mosek.Task.getqconk

    Syntax:

     

    int getqconk (
        int k,
        List|None qcsurp,
        array(int) qcsubi,
        array(int) qcsubj,
        array(double) qcval)
    
    Arguments:

     

    k (input)
    Which constraint.
    qcsurp (input/output)
    When entering the function it is assumed that the last qcsurp[0] positions in qcsubi, qcsubj, and qcval are free. Hence, the quadratic terms are stored in this area, and upon return qcsurp is number of free positions left in qcsubi, qcsubj, and qcval.
    qcsubi (output)
    i subscripts for [[MathCmd 82]]. See (5.8.4).
    qcsubj (output)
    j subscripts for [[MathCmd 82]]. See (5.8.4).
    qcval (output)
    Numerical value for [[MathCmd 82]].
    Returns:
     
    Description:
    Obtains all the quadratic terms in a constraint. The quadratic terms are stored sequentially qcsubi, qcsubj, and qcval.
  • mosek.Task.getqobj

    Syntax:

     

    getqobj (
        List|None qosurp,
        List|None numqonz,
        array(int) qosubi,
        array(int) qosubj,
        array(double) qoval)
    
    Arguments:

     

    qosurp (input/output)
    When entering the function qosurp[0] is the number of free positions at the end of the arrays qosubi, qosubj, and qoval, and upon return qosurp is the updated number of free positions left in those arrays.
    numqonz (output)
    Number of non-zero elements in [[MathCmd 25]].
    qosubi (output)
    i subscript for [[MathCmd 77]].
    qosubj (output)
    j subscript for [[MathCmd 77]].
    qoval (output)
    Numerical value for [[MathCmd 77]].
    Description:
    Obtains the quadratic terms in the objective. The required quadratic terms are stored sequentially in qosubi, qosubj, and qoval.
  • mosek.Task.getqobjij

    Syntax:

     

    getqobjij (
        int i,
        int j,
        List|None qoij)
    
    Arguments:

     

    i (input)
    Row index of the coefficient.
    j (input)
    Column index of coefficient.
    qoij (output)
    The required coefficient.
    Description:
    Obtains one coefficient [[MathCmd 77]] in the quadratic term of the objective.
  • mosek.Task.getreducedcosts

    Syntax:

     

    getreducedcosts (
        mosek.soltype whichsol,
        int first,
        int last,
        array(double) redcosts)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    first (input)
    See formula (13.6.5) for the definition.
    last (input)
    See formula (13.6.5) for the definition.
    redcosts (output)
    The reduced costs in the required sequence of variables are stored sequentially in redcosts starting at redcosts[0].
    Description:

    Computes the reduced costs for a sequence of variables and return them in the variable redcosts i.e.

    \begin{math}\nonumber{}\mathtt{redcosts}[j-\mathtt{first}+0]=(s_{l}^{x})_{j}-(s_{u}^{x})_{j},~j=\mathtt{first},\ldots ,\mathtt{last}-1.\end{math} (13.6.5)
  • mosek.Task.getsolution

    Syntax:

     

    getsolution (
        mosek.soltype whichsol,
        List|None prosta,
        List|None solsta,
        array(int) skc,
        array(int) skx,
        array(int) skn,
        array(double) xc,
        array(double) xx,
        array(double) y,
        array(double) slc,
        array(double) suc,
        array(double) slx,
        array(double) sux,
        array(double) snx)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    prosta (output)
    Problem status.
    solsta (output)
    Solution status.
    skc (output)
    Status keys for the constraints.
    skx (output)
    Status keys for the variables.
    skn (output)
    Status keys for the conic constraints.
    xc (output)
    Primal constraint solution.
    xx (output)
    Primal variable solution (x).
    y (output)
    Vector of dual variables corresponding to the constraints.
    slc (output)
    Dual variables corresponding to the lower bounds on the constraints ([[MathCmd 551]]).
    suc (output)
    Dual variables corresponding to the upper bounds on the constraints ([[MathCmd 552]]).
    slx (output)
    Dual variables corresponding to the lower bounds on the variables ([[MathCmd 553]]).
    sux (output)
    Dual variables corresponding to the upper bounds on the variables ([[MathCmd 554]]).
    snx (output)
    Dual variables corresponding to the conic constraints on the variables ([[MathCmd 555]]).
    Description:

    Obtains the complete solution.

    Consider the case of linear programming. The primal problem is given by

    \begin{math}\nonumber{}\begin{array}{lccccl}\nonumber{}\mbox{minimize} &  &  & c^{T}x+c^{f} &  & \\\nonumber{}\mbox{subject to} & l^{c} & \leq{} & Ax & \leq{} & u^{c},\\\nonumber{} & l^{x} & \leq{} & x & \leq{} & u^{x}.\end{array}\end{math} (13.6.6)

    and the corresponding dual problem is

    \begin{math}\nonumber{}\begin{array}{lccl}\nonumber{}\mbox{maximize} & (l^{c})^{T}s_{l}^{c}-(u^{c})^{T}s_{u}^{c} &  & \\\nonumber{} & +(l^{x})^{T}s_{l}^{x}-(u^{x})^{T}s_{u}^{x}+c^{f} &  & \\\nonumber{}\mbox{subject to} & A^{T}y+s_{l}^{x}-s_{u}^{x} & = & c,\\\nonumber{} & -y+s_{l}^{c}-s_{u}^{c} & = & 0,\\\nonumber{} & s_{l}^{c},s_{u}^{c},s_{l}^{x},s_{u}^{x}\geq{}0. &  &\end{array}\end{math} (13.6.7)

    In this case the mapping between variables and arguments to the function is as follows:

    xx: Corresponds to variable x.

    y: Corresponds to variable y.

    slc: Corresponds to variable [[MathCmd 551]].

    suc: Corresponds to variable [[MathCmd 552]].

    slx: Corresponds to variable [[MathCmd 553]].

    sux: Corresponds to variable [[MathCmd 554]].

    xc: Corresponds to Ax.

    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:

    mosek.solsta.optimal An optimal solution satisfying the optimality criteria for continuous problems is returned.

    mosek.solsta.integer_optimal An optimal solution satisfying the optimality criteria for integer problems is returned.

    mosek.solsta.prim_infeas_cer A primal certificate of infeasibility is returned.

    mosek.solsta.dual_infeas_cer A dual certificate of infeasibility is returned.

    See also:

     

    Task.getsolutioni

    Obtains the solution for a single constraint or variable.

    Task.getsolutionslice

    Obtains a slice of the solution.

  • mosek.Task.getsolutioni

    Syntax:

     

    getsolutioni (
        mosek.accmode accmode,
        int i,
        mosek.soltype whichsol,
        List|None sk,
        List|None x,
        List|None sl,
        List|None su,
        List|None sn)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    i (input)
    Index of the constraint or variable.
    whichsol (input)
    Selects a solution.
    sk (output)
    Status key of the constraint of variable.
    x (output)
    Solution value of the primal variable.
    sl (output)
    Solution value of the dual variable associated with the lower bound.
    su (output)
    Solution value of the dual variable associated with the upper bound.
    sn (output)
    Solution value of the dual variable associated with the cone constraint.
    Description:
    Obtains the primal and dual solution information for a single constraint or variable.
    See also:

     

    Task.getsolution

    Obtains the complete solution.

    Task.getsolutionslice

    Obtains a slice of the solution.

  • mosek.Task.getsolutioninf

    Syntax:

     

    getsolutioninf (
        mosek.soltype whichsol,
        List|None prosta,
        List|None solsta,
        List|None primalobj,
        List|None maxpbi,
        List|None maxpcni,
        List|None maxpeqi,
        List|None maxinti,
        List|None dualobj,
        List|None maxdbi,
        List|None maxdcni,
        List|None maxdeqi)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    prosta (output)
    Problem status.
    solsta (output)
    Solution status.
    primalobj (output)
    Objective value corresponding to the primal solution.
    maxpbi (output)
    Maximum primal bound infeasibility.
    maxpcni (output)
    Maximum infeasibility in the primal conic constraints.
    maxpeqi (output)
    Maximum infeasibility in the primal equality constraints.
    maxinti (output)
    Maximum infeasibility in integer constraints.
    dualobj (output)
    Objective value corresponding to the dual solution.
    maxdbi (output)
    Maximum dual bound infeasibility.
    maxdcni (output)
    Maximum infeasibility in the dual conic constraints.
    maxdeqi (output)
    Maximum infeasibility in the dual equality constraints.
    Description:
    Obtains information about a solution.
  • mosek.Task.getsolutionslice

    Syntax:

     

    getsolutionslice (
        mosek.soltype whichsol,
        mosek.solitem solitem,
        int first,
        int last,
        array(double) values)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    solitem (input)
    Which part of the solution is required.
    first (input)
    Index of the first value in the slice.
    last (input)
    Value of the last index+1 in the slice, e.h. if [[MathCmd 562]] is required last should be 10.
    values (output)
    The values in the required sequence are stored sequentially in values starting at values[0].
    Description:

    Obtains a slice of the solution.

    Consider the case of linear programming. The primal problem is given by

    \begin{math}\nonumber{}\begin{array}{lccccl}\nonumber{}\mbox{minimize} &  &  & c^{T}x+c^{f} &  & \\\nonumber{}\mbox{subject to} & l^{c} & \leq{} & Ax & \leq{} & u^{c},\\\nonumber{} & l^{x} & \leq{} & x & \leq{} & u^{x}.\end{array}\end{math} (13.6.8)

    and the corresponding dual problem is

    \begin{math}\nonumber{}\begin{array}{lccl}\nonumber{}\mbox{maximize} & (l^{c})^{T}s_{l}^{c}-(u^{c})^{T}s_{u}^{c} &  & \\\nonumber{} & +(l^{x})^{T}s_{l}^{x}-(u^{x})^{T}s_{u}^{x}+c^{f} &  & \\\nonumber{}\mbox{subject to} & A^{T}y+s_{l}^{x}-s_{u}^{x} & = & c,\\\nonumber{} & -y+s_{l}^{c}-s_{u}^{c} & = & 0,\\\nonumber{} & s_{l}^{c},s_{u}^{c},s_{l}^{x},s_{u}^{x}\geq{}0. &  &\end{array}\end{math} (13.6.9)

    The solitem argument determines which part of the solution is returned:

    mosek.solitem.xx: The variable values return x.

    mosek.solitem.y: The variable values return y.

    mosek.solitem.slc: The variable values return [[MathCmd 551]].

    mosek.solitem.suc: The variable values return [[MathCmd 552]].

    mosek.solitem.slx: The variable values return [[MathCmd 553]].

    mosek.solitem.sux: The variable values return [[MathCmd 554]].

    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{math}\nonumber{}\begin{array}{lccccc}\nonumber{}\mbox{maximize} & (l^{c})^{T}s_{l}^{c}-(u^{c})^{T}s_{u}^{c} &  & \\\nonumber{} & +(l^{x})^{T}s_{l}^{x}-(u^{x})^{T}s_{u}^{x}+c^{f} &  & \\\nonumber{}\mbox{subject to} & A^{T}y+s_{l}^{x}-s_{u}^{x}+s_{n}^{x} & = & c,\\\nonumber{} & -y+s_{l}^{c}-s_{u}^{c} & = & 0,\\\nonumber{} & s_{l}^{c},s_{u}^{c},s_{l}^{x},s_{u}^{x} & \geq{} & 0,\\\nonumber{} & s_{n}^{x}\in{}\mathcal{C}^{*} &  &\end{array}\end{math} (13.6.10)

    This introduces one additional dual variable [[MathCmd 555]]. This variable can be acceded by selecting solitem as mosek.solitem.snx.

    The meaning of the values returned by this function also depends on the solution status which can be obtained with Task.getsolutionstatus. Depending on the solution status value will be:

    mosek.solsta.optimal A part of the optimal solution satisfying the optimality criteria for continuous problems.

    mosek.solsta.integer_optimal A part of the optimal solution satisfying the optimality criteria for integer problems.

    mosek.solsta.prim_infeas_cer A part of the primal certificate of infeasibility.

    mosek.solsta.dual_infeas_cer A part of the dual certificate of infeasibility.

    See also:

     

    Task.getsolution

    Obtains the complete solution.

    Task.getsolutioni

    Obtains the solution for a single constraint or variable.

  • mosek.Task.getsolutionstatus

    Syntax:

     

    getsolutionstatus (
        mosek.soltype whichsol,
        List|None prosta,
        List|None solsta)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    prosta (output)
    Problem status.
    solsta (output)
    Solution status.
    Description:
    Obtains information about the problem and solution statuses.
  • mosek.Task.getsolutionstatuskeyslice

    Syntax:

     

    getsolutionstatuskeyslice (
        mosek.accmode accmode,
        mosek.soltype whichsol,
        int first,
        int last,
        array(int) sk)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    whichsol (input)
    Selects a solution.
    first (input)
    Index of the first value in the slice.
    last (input)
    Value of the last index+1 in the slice, e.g. if [[MathCmd 562]] is required last should be 10.
    sk (output)
    The status keys in the required sequence are stored sequentially in sk starting at sk[0].
    Description:
    Obtains a slice of the solution status keys.
    See also:

     

    Task.getsolution

    Obtains the complete solution.

    Task.getsolutioni

    Obtains the solution for a single constraint or variable.

  • mosek.Task.getstrparam

    Syntax:

     

    str getstrparam (
        mosek.sparam param,
        List|None len)
    
    Arguments:

     

    param (input)
    Which parameter.
    len (output)
    The length of the parameter value.
    Returns:
     
    Description:
    Obtains the value of a string parameter.
  • mosek.Task.gettaskname

    Syntax:

     

    str gettaskname (List|None len)
    
    Arguments:

     

    len (output)
    Is assigned the length of the task name.
    Returns:
     
    Description:
    Obtains the name assigned to the task.
  • mosek.Task.getvarbranchdir

    Syntax:

     

    int getvarbranchdir (int j)
    
    Arguments:

     

    j (input)
    Index of the variable.
    Returns:
     
    Description:
    Obtains the branching direction for a given variable j.
  • mosek.Task.getvarbranchpri

    Syntax:

     

    int getvarbranchpri (int j)
    
    Arguments:

     

    j (input)
    Index of the variable.
    Returns:
     
    Description:
    Obtains the branching priority for a given variable j.
  • mosek.Task.getvarname

    Syntax:

     

    str getvarname (int i)
    
    Arguments:

     

    i (input)
    Index.
    Returns:
     
    Description:
    Obtains a name of a variable.
    See also:

     

    Task.getmaxnamelen

    Obtains the maximum length of any objective, constraint, variable or cone name.

  • mosek.Task.getvartype

    Syntax:

     

    int getvartype (int j)
    
    Arguments:

     

    j (input)
    Index of the variable.
    Returns:
     
    Description:
    Gets the variable type of one variable.
  • mosek.Task.getvartypelist

    Syntax:

     

    getvartypelist (
        array(int) subj,
        array(int) vartype)
    
    Arguments:

     

    subj (input)
    A list of variable indexes.
    vartype (output)
    The variables types corresponding to the variables specified by subj.
    Description:

    Obtains the variable type of one or more variables.

    Upon return vartype[k] is the variable type of variable subj[k].

  • mosek.Task.initbasissolve

    Syntax:

     

    initbasissolve (array(int) basis)
    
    Arguments:

     

    basis (output)

    The array of basis indexes to use.

    The array is interpreted as follows: If [[MathCmd 572]], then [[MathCmd 573]] is in the basis at position i, otherwise [[MathCmd 574]] is in the basis at position i.

    Description:

    Prepare a task for use with the Task.solvewithbasis function.

    This function should be called

  • mosek.Task.inputdata

    Syntax:

     

    inputdata (
        int maxnumcon,
        int maxnumvar,
        array(double) c,
        double cfix,
        array(int) aptrb,
        array(int) aptre,
        array(int) asub,
        array(double) aval,
        array(int) bkc,
        array(double) blc,
        array(double) buc,
        array(int) bkx,
        array(double) blx,
        array(double) bux)
    
    Arguments:

     

    maxnumcon (input)
    Number of preallocated constraints in the optimization task.
    maxnumvar (input)
    Number of preallocated variables in the optimization task.
    c (input)
    Linear terms of the objective as a dense vector. The lengths is the number of variables.
    cfix (input)
    Fixed term in the objective.
    aptrb (input)
    Pointer to the first element in the rows or the columns of A. See (5.8.5) and section 5.8.3.
    aptre (input)
    Pointers to the last element + 1 in the rows or the columns of A. See (5.8.5) and section 5.8.3
    asub (input)
    Coefficient subscripts. See (5.8.5) and section 5.8.3.
    aval (input)
    Coefficient values. See (5.8.5) and section 5.8.3.
    bkc (input)
    Bound keys for the constraints.
    blc (input)
    Lower bounds for the constraints.
    buc (input)
    Upper bounds for the constraints.
    bkx (input)
    Bound keys for the variables.
    blx (input)
    Lower bounds for the variables.
    bux (input)
    Upper bounds for the variables.
    Description:

    Input the linear part of an optimization problem.

    The non-zeros of A are inputted column-wise in the format described in section 5.8.3.2.

    For an explained code example see section 5.2 and section 5.8.3.

  • mosek.Task.isdouparname

    Syntax:

     

    isdouparname (
        str parname,
        List|None param)
    
    Arguments:

     

    parname (input)
    Parameter name.
    param (output)
    Which parameter.
    Description:
    Checks whether parname is a valid double parameter name.
  • mosek.Task.isintparname

    Syntax:

     

    isintparname (
        str parname,
        List|None param)
    
    Arguments:

     

    parname (input)
    Parameter name.
    param (output)
    Which parameter.
    Description:
    Checks whether parname is a valid integer parameter name.
  • mosek.Task.isstrparname

    Syntax:

     

    isstrparname (
        str parname,
        List|None param)
    
    Arguments:

     

    parname (input)
    Parameter name.
    param (output)
    Which parameter.
    Description:
    Checks whether parname is a valid string parameter name.
  • mosek.Task.linkfiletotaskstream

    Syntax:

     

    linkfiletotaskstream (
        mosek.streamtype whichstream,
        str filename,
        int append)
    
    Arguments:

     

    whichstream (input)
    Index of the stream.
    filename (input)
    The name of the file where text from the stream defined by whichstream is written.
    append (input)
    If this argument is 0 the output file will be overwritten, otherwise text is append to the output file.
    Description:
    Directs all output from a task stream to a file.
  • mosek.Task.makesolutionstatusunknown

    Syntax:

     

    makesolutionstatusunknown (mosek.soltype whichsol)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    Description:
    Sets the solution status to unknown. Also all the status keys for the constraints and the variables are set to unknown.
  • mosek.Task.optimize

    Syntax:

     

    optimize ()
    
    Description:
    Calls the optimizer. Depending on the problem type and the selected solver this will call one of the solvers in MOSEK.
    See also:

     

    Task.optimizeconcurrent

    Optimize a given task with several optimizers concurrently.

    Task.getsolution

    Obtains the complete solution.

    Task.getsolutioni

    Obtains the solution for a single constraint or variable.

    Task.getsolutioninf

    Obtains information about a solution.

    mosek.iparam.optimizer
  • mosek.Task.optimizeconcurrent

    Syntax:

     

    optimizeconcurrent (array(Task) taskarray)
    
    Arguments:

     

    taskarray (input)
    An array of num tasks.
    Description:

    Solves several instances of the same problem in parallel, with unique parameter settings for each task. The argument task contains the problem to be solved. taskarray is a pointer to an array of num empty tasks. The task task and the num tasks pointed to by taskarray are solved in parallel. That is [[MathCmd 575]] threads are started with one optimizer in each. Each of the tasks can be initialized with different parameters, e.g different selection of solver.

    All the concurrently running tasks are stopped when the optimizer successfully terminates for one of the tasks. After the function returns task contains the solution found by the task that finished first.

    After Task.optimizeconcurrent returns task holds the optimal solution of the task which finished first. If all the concurrent optimizations finished without providing an optimal solution the error code from the solution of the task task is returned.

    In summary a call to Task.optimizeconcurrent does the following:

    1. All data except task parameters (mosek.iparam, mosek.dparam and mosek.sparam) in task is copied to each of the tasks in taskarray. In particular this means that any solution in task is copied to the other tasks. Call-back functions are not copied.
    2. The tasks task and the num tasks in taskarray are started in parallel.
    3. When a task finishes providing an optimal solution (or a certificate of infeasibility) its solution is copied to task and all other tasks are stopped.

    For an explained code example see section 7.6.4.

  • mosek.Task.optimizetrm

    Syntax:

     

    optimizetrm (List|None trmcode)
    
    Arguments:

     

    trmcode (output)
    Is either mosek.rescode.ok or a termination response code.
    Description:

    This function is equivalent to Task.optimize except in the case where Task.optimize would have returned a termination response code such as

  • mosek.Task.primalsensitivity

    Syntax:

     

    primalsensitivity (
        array(int) subi,
        array(int) marki,
        array(int) subj,
        array(int) markj,
        array(double) leftpricei,
        array(double) rightpricei,
        array(double) leftrangei,
        array(double) rightrangei,
        array(double) leftpricej,
        array(double) rightpricej,
        array(double) leftrangej,
        array(double) rightrangej)
    
    Arguments:

     

    subi (input)
    Indexes of bounds on constraints to analyze.
    marki (input)
    The value of marki[i] specifies for which bound (upper or lower) on constraint subi[i] sensitivity analysis should be performed.
    subj (input)
    Indexes of bounds on variables to analyze.
    markj (input)
    The value of markj[j] specifies for which bound (upper or lower) on variable subj[j] sensitivity analysis should be performed.
    leftpricei (output)
    leftpricei[i] is the left shadow price for the upper/lower bound (indicated by marki[i]) of the constraint with index subi[i].
    rightpricei (output)
    rightpricei[i] is the right shadow price for the upper/lower bound (indicated by marki[i]) of the constraint with index subi[i].
    leftrangei (output)
    leftrangei[i] is the left range for the upper/lower bound (indicated by marki[i]) of the constraint with index subi[i].
    rightrangei (output)
    rightrangei[i] is the right range for the upper/lower bound (indicated by marki[i]) of the constraint with index subi[i].
    leftpricej (output)
    leftpricej[j] is the left shadow price for the upper/lower bound (indicated by marki[j]) on variable subj[j].
    rightpricej (output)
    rightpricej[j] is the right shadow price for the upper/lower bound (indicated by marki[j]) on variable subj[j] .
    leftrangej (output)
    leftrangej[j] is the left range for the upper/lower bound (indicated by marki[j]) on variable subj[j].
    rightrangej (output)
    rightrangej[j] is the right range for the upper/lower bound (indicated by marki[j]) on variable subj[j].
    Description:

    Calculates sensitivity information for bounds on variables and constraints.

    For details on sensitivity analysis and the definitions of shadow price and linearity interval see chapter 11.

    The constraints for which sensitivity analysis is performed are given by the data structures:

    1. subi Index of constraint to analyze.
    2. marki Indicate for which bound of constraint subi[i] sensitivity analysis is performed. If marki[i] = mosek.mark.up the upper bound of constraint subi[i] is analyzed, and if marki[i] = mosek.mark.lo the lower bound is analyzed. If subi[i] is an equality constraint, either mosek.mark.lo or mosek.mark.up can be used to select the constraint for sensitivity analysis.

    Consider the problem:

    \begin{math}\nonumber{}\begin{array}{lccl}\nonumber{}\mbox{minimize} & x_{1}+x_{2} &  & \\\nonumber{}\mbox{subject to}-1\leq{} & x_{1}-x_{2} & \leq{} & 1,\\\nonumber{} & x_{1} & = & 0,\\\nonumber{} & x_{1}\geq{}0,x_{2}\geq{}0 &  &\end{array}\end{math} (13.6.11)

    Suppose that

                        numi = 1;
                        subi = [0];
                        marki = [mosek.mark.up]                    
                        

    then

    leftpricei[0], rightpricei[0], leftrangei[0] and rightrangei[0] will contain the sensitivity information for the upper bound on constraint 0 given by the expression:

    \begin{math}\nonumber{}x_{1}-x_{2}\leq{}1\end{math} (13.6.12)

    Similarly, the variables for which to perform sensitivity analysis are given by the structures:

    1. subj Index of variables to analyze.
    2. markj Indicate for which bound of variable subi[j] sensitivity analysis is performed. If markj[j] = mosek.mark.up the upper bound of constraint subi[j] is analyzed, and if markj[j] = mosek.mark.lo the lower bound is analyzed. If subi[j] is an equality constraint, either mosek.mark.lo or mosek.mark.up can be used to select the constraint for sensitivity analysis.

    For an example, please see section 11.5.

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

    See also:

     

    Task.dualsensitivity

    Performs sensitivity analysis on objective coefficients.

    Task.sensitivityreport

    Creates a sensitivity report.

    mosek.iparam.sensitivity_type
    mosek.iparam.log_sensitivity
    mosek.iparam.log_sensitivity_opt
  • mosek.Task.printdata

    Syntax:

     

    printdata (
        mosek.streamtype whichstream,
        int firsti,
        int lasti,
        int firstj,
        int lastj,
        int firstk,
        int lastk,
        int c,
        int qo,
        int a,
        int qc,
        int bc,
        int bx,
        int vartype,
        int cones)
    
    Arguments:

     

    whichstream (input)
    Index of the stream.
    firsti (input)
    Index of first constraint for which data should be printed.
    lasti (input)
    Index of last constraint plus 1 for which data should be printed.
    firstj (input)
    Index of first variable for which data should be printed.
    lastj (input)
    Index of last variable plus 1 for which data should be printed.
    firstk (input)
    Index of first cone for which data should be printed.
    lastk (input)
    Index of last cone plus 1 for which data should be printed.
    c (input)
    If non-zero, then c is printed.
    qo (input)
    If non-zero, then [[MathCmd 25]] is printed.
    a (input)
    If non-zero, then A is printed.
    qc (input)
    If non-zero, then [[MathCmd 26]] is printed for the relevant constraints.
    bc (input)
    If non-zero, then constraints bounds are printed.
    bx (input)
    If non-zero, then variable bounds are printed.
    vartype (input)
    If non-zero, then variable types are printed.
    cones (input)
    If non-zero, then conic data is printed.
    Description:
    Prints a part of the problem data to a stream. This function is normally used for debugging purposes only, e.g. to verify that the correct data has been inputted.
  • mosek.Task.printparam

    Syntax:

     

    printparam ()
    
    Description:
    Prints the current parameter settings to the message stream.
  • mosek.Task.putaij

    Syntax:

     

    putaij (
        int i,
        int j,
        double aij)
    
    Arguments:

     

    i (input)
    Index of the constraint in which the change should occur.
    j (input)
    Index of the variable in which the change should occur.
    aij (input)
    New coefficient for [[MathCmd 580]].
    Description:

    Changes a coefficient in A using the method

    \begin{displaymath}\nonumber{}a_{{\mathtt{i}\mathtt{j}}}=\mathtt{aij}.\end{displaymath}
    See also:

     

    Task.putavec

    Replaces all elements in one row or column of A.

    Task.putaijlist

    Changes one or more coefficients in A.

    Comments:
  • mosek.Task.putaijlist

    Syntax:

     

    putaijlist (
        array(int) subi,
        array(int) subj,
        array(double) valij)
    
    Arguments:

     

    subi (input)
    Constraint indexes in which the change should occur.
    subj (input)
    Variable indexes in which the change should occur.
    valij (input)
    New coefficient values for [[MathCmd 580]].
    Description:

    Changes one or more coefficients in A using the method

    \begin{displaymath}\nonumber{}a_{{\mathtt{subi[k]},\mathtt{subj[k]}}}=\mathtt{valij[k]},\quad{}k=0,\ldots ,\mathtt{num}-1.\end{displaymath}

    If the same [[MathCmd 580]] entry appears multiple times only the last one will be used.

    See also:

     

    Task.putavec

    Replaces all elements in one row or column of A.

    Task.putaij

    Changes a single value in the linear coefficient matrix.

    Task.putmaxnumanz

    The function changes the size of the preallocated storage for linear coefficients.

    Comments:
  • mosek.Task.putavec

    Syntax:

     

    putavec (
        mosek.accmode accmode,
        int i,
        array(int) asub,
        array(double) aval)
    
    Arguments:

     

    accmode (input)
    Defines whether to replace a column or a row.
    i (input)
    If accmode equals mosek.accmode.con, then i is a constraint index. Otherwise it is a column index.
    asub (input)
    Index of the [[MathCmd 580]] values that should be changed.
    aval (input)
    New [[MathCmd 580]] values.
    Description:

    Replaces all elements in one row or column of A.

    Assuming that there are no duplicate subscripts in asub, assignment is performed as follows:

    If asub contains duplicates, the corresponding coefficients will be added together.

    For an explanation of the meaning of ptrb and ptre see 5.8.3.2 and .

    See also:

     

    Task.putaij

    Changes a single value in the linear coefficient matrix.

    Task.putmaxnumanz

    The function changes the size of the preallocated storage for linear coefficients.

  • mosek.Task.putaveclist

    Syntax:

     

    putaveclist (
        mosek.accmode accmode,
        array(int) sub,
        array(int) ptrb,
        array(int) ptre,
        array(int) asub,
        array(double) aval)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    sub (input)
    Indexes of rows or columns that should be replaced. sub should not contain duplicate values.
    ptrb (input)
    Array of pointers to the first element in the rows or columns stored in asub and aval. For an explanation of the meaning of ptrb see 5.8.3.2 and section .
    ptre (input)
    Array of pointers to the last element plus one in the rows or columns stored in asub and aval. For an explanation of the meaning of ptre see 5.8.3.2 and section .
    asub (input)
    If accmode is mosek.accmode.con, then asub contains the new variable indexes, otherwise it contains the new constraint indexes.
    aval (input)
    Coefficient values. See (5.8.5) and section 5.8.3.
    Description:

    Replaces all elements in a set of rows or columns of A.

    The elements are replaced as follows.

    If the same row or column appears multiple times only the last one will be used.

    See also:

     

    Task.putavec

    Replaces all elements in one row or column of A.

    Task.putaij

    Changes a single value in the linear coefficient matrix.

    Task.putmaxnumanz

    The function changes the size of the preallocated storage for linear coefficients.

  • mosek.Task.putbound

    Syntax:

     

    putbound (
        mosek.accmode accmode,
        int i,
        mosek.boundkey bk,
        double bl,
        double bu)
    
    Arguments:

     

    accmode (input)
    Defines whether the bound for a constraint or a variable is changed.
    i (input)
    Index of the constraint or variable.
    bk (input)
    New bound key.
    bl (input)
    New lower bound.
    bu (input)
    New upper bound.
    Description:

    Changes the bounds for either one constraint or one variable.

    If the a bound value specified is numerically larger than mosek.dparam.data_tol_bound_inf it is considered infinite and the bound key is changed accordingly. If a bound value is numerically larger than mosek.dparam.data_tol_bound_wrn, a warning will be displayed, but the bound is inputted as specified.

    See also:

     

    Task.chgbound

    Changes the bounds for one constraint or variable.

    Task.putboundlist

    Changes the bounds of constraints or variables.

  • mosek.Task.putboundlist

    Syntax:

     

    putboundlist (
        mosek.accmode accmode,
        array(int) sub,
        array(int) bk,
        array(double) bl,
        array(double) bu)
    
    Arguments:

     

    accmode (input)
    Defines whether bounds for constraints (mosek.accmode.con) or variables (mosek.accmode.var) are changed.
    sub (input)
    Subscripts of the bounds that should be changed.
    bk (input)
    If con is non-zero (zero), then constraint (variable) sub[t] is assigned the key bk[t].
    bl (input)
    If con is non-zero (zero), then constraint (variable) sub[t] is assigned the lower bound bl[t].
    bu (input)
    If con is non-zero (zero), then constraint (variable) sub[t] is assigned the upper bound bu[t].
    Description:
    Changes the bounds for either some constraints or variables. If multiple bound changes are specified for a constraint or a variable, only the last change takes effect.
    See also:

     

    Task.putbound

    Changes the bound for either one constraint or one variable.

    mosek.dparam.data_tol_bound_inf
    mosek.dparam.data_tol_bound_wrn
  • mosek.Task.putboundslice

    Syntax:

     

    putboundslice (
        mosek.accmode con,
        int first,
        int last,
        array(int) bk,
        array(double) bl,
        array(double) bu)
    
    Arguments:

     

    con (input)
    Defines whether bounds for constraints (mosek.accmode.con) or variables (mosek.accmode.var) are changed.
    first (input)
    First index in the sequence.
    last (input)
    Last index plus 1 in the sequence.
    bk (input)
    Bound keys.
    bl (input)
    Values for lower bounds.
    bu (input)
    Values for upper bounds.
    Description:
    Changes the bounds for a sequence of variables or constraints.
    See also:

     

    Task.putbound

    Changes the bound for either one constraint or one variable.

    mosek.dparam.data_tol_bound_inf
    mosek.dparam.data_tol_bound_wrn
  • mosek.Task.putcfix

    Syntax:

     

    putcfix (double cfix)
    
    Arguments:

     

    cfix (input)
    Fixed term in the objective.
    Description:
    Replaces the fixed term in the objective by a new one.
  • mosek.Task.putcj

    Syntax:

     

    putcj (
        int j,
        double cj)
    
    Arguments:

     

    j (input)
    Index of the variable for which c should be changed.
    cj (input)
    New value of [[MathCmd 80]].
    Description:

    Modifies one coefficient in the linear objective vector c, i.e.

    \begin{displaymath}\nonumber{}c_{{\mathtt{j}}}=\mathtt{cj}.\end{displaymath}
  • mosek.Task.putclist

    Syntax:

     

    putclist (
        array(int) subj,
        array(double) val)
    
    Arguments:

     

    subj (input)
    Index of variables for which c should be changed.
    val (input)
    New numerical values for coefficients in c that should be modified.
    Description:

    Modifies elements in the linear term c in the objective using the principle

    \begin{displaymath}\nonumber{}c_{{\mathtt{subj[t]}}}=\mathtt{val[t]},\quad{}t=0,\ldots ,\mathtt{num}-1.\end{displaymath}

    If a variable index is specified multiple times in subj only the last entry is used.

  • mosek.Task.putcone

    Syntax:

     

    putcone (
        int k,
        mosek.conetype conetype,
        double conepar,
        array(int) submem)
    
    Arguments:

     

    k (input)
    Index of the cone.
    conetype (input)
    Specifies the type of the cone.
    conepar (input)
    This argument is currently not used. Can be set to 0.0.
    submem (input)
    Variable subscripts of the members in the cone.
    Description:
    Replaces a conic constraint.
  • mosek.Task.putdouparam

    Syntax:

     

    putdouparam (
        mosek.dparam param,
        double parvalue)
    
    Arguments:

     

    param (input)
    Which parameter.
    parvalue (input)
    Parameter value.
    Description:
    Sets the value of a double parameter.
  • mosek.Task.putintparam

    Syntax:

     

    putintparam (
        mosek.iparam param,
        int parvalue)
    
    Arguments:

     

    param (input)
    Which parameter.
    parvalue (input)
    Parameter value.
    Description:
    Sets the value of an integer parameter.
  • mosek.Task.putmaxnumanz

    Syntax:

     

    putmaxnumanz (int maxnumanz)
    
    Arguments:

     

    maxnumanz (input)
    New size of the storage reserved for storing A.
    Description:

    MOSEK stores only the non-zero elements in A. Therefore, MOSEK 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 the data input phase.

    It is not mandatory to call this function, since MOSEK will reallocate internal structures whenever it is necessary.

    See also:

     

    mosek.iparam.maxnumanz_double_trh
    mosek.iinfitem.sto_num_a_realloc
  • mosek.Task.putmaxnumcon

    Syntax:

     

    putmaxnumcon (int maxnumcon)
    
    Arguments:

     

    maxnumcon (input)
    Number of preallocated constraints in the optimization task.
    Description:

    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.

  • mosek.Task.putmaxnumcone

    Syntax:

     

    putmaxnumcone (int maxnumcone)
    
    Arguments:

     

    maxnumcone (input)
    Number of preallocated conic constraints in the optimization task.
    Description:

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

  • mosek.Task.putmaxnumqnz

    Syntax:

     

    putmaxnumqnz (int maxnumqnz)
    
    Arguments:

     

    maxnumqnz (input)
    Number of non-zero elements preallocated in quadratic coefficient matrices.
    Description:

    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 A 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 A.

    It is never mandatory to call this function, since its only function is to give a hint of the amount of data to preallocate for efficiency reasons.

  • mosek.Task.putmaxnumvar

    Syntax:

     

    putmaxnumvar (int maxnumvar)
    
    Arguments:

     

    maxnumvar (input)
    Number of preallocated variables in the optimization task.
    Description:

    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 never mandatory to call this function, since its only function is to give a hint of 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.

  • mosek.Task.putnadouparam

    Syntax:

     

    putnadouparam (
        str paramname,
        double parvalue)
    
    Arguments:

     

    paramname (input)
    Name of a MOSEK parameter.
    parvalue (input)
    Parameter value.
    Description:
    Sets the value of a named double parameter.
  • mosek.Task.putnaintparam

    Syntax:

     

    putnaintparam (
        str paramname,
        int parvalue)
    
    Arguments:

     

    paramname (input)
    Name of a MOSEK parameter.
    parvalue (input)
    Parameter value.
    Description:
    Sets the value of a named integer parameter.
  • mosek.Task.putname

    Syntax:

     

    putname (
        mosek.problemitem whichitem,
        int i,
        str name)
    
    Arguments:

     

    whichitem (input)
    Problem item, i.e. a cone, a variable or a constraint name..
    i (input)
    Index.
    name (input)
    New name to be assigned to the item.
    Description:
    Assigns the name defined by name to a problem item (a variable, a constraint or a cone).
  • mosek.Task.putnastrparam

    Syntax:

     

    putnastrparam (
        str paramname,
        str parvalue)
    
    Arguments:

     

    paramname (input)
    Name of a MOSEK parameter.
    parvalue (input)
    Parameter value.
    Description:
    Sets the value of a named string parameter.
  • mosek.Task.putobjname

    Syntax:

     

    putobjname (str objname)
    
    Arguments:

     

    objname (input)
    Name of the objective.
    Description:
    Assigns the name given by objname to the objective function.
  • mosek.Task.putobjsense

    Syntax:

     

    putobjsense (mosek.objsense sense)
    
    Arguments:

     

    sense (input)
    The objective sense of the task. The values mosek.objsense.maximize and mosek.objsense.minimize means that the the problem is maximized or minimized respectively. The value mosek.objsense.undefined means that the objective sense is taken from the parameter mosek.iparam.objective_sense.
    Description:
    Sets the objective sense of the task.
    See also:

     

    Task.getobjsense

    Gets the objective sense.

  • mosek.Task.putparam

    Syntax:

     

    putparam (
        str parname,
        str parvalue)
    
    Arguments:

     

    parname (input)
    Parameter name.
    parvalue (input)
    Parameter value.
    Description:
    Checks if a parname is valid parameter name. If it is, the parameter is assigned the value specified by parvalue.
  • mosek.Task.putqcon

    Syntax:

     

    putqcon (
        array(int) qcsubk,
        array(int) qcsubi,
        array(int) qcsubj,
        array(double) qcval)
    
    Arguments:

     

    qcsubk (input)
    k subscripts for [[MathCmd 82]]. See (5.8.4).
    qcsubi (input)
    i subscripts for [[MathCmd 82]]. See (5.8.4).
    qcsubj (input)
    j subscripts for [[MathCmd 82]]. See (5.8.4).
    qcval (input)
    Numerical value for [[MathCmd 82]].
    Description:

    Replaces all quadratic entries in the constraints. Consider constraints on the form:

    \begin{math}\nonumber{}l_{k}^{c}\leq{}\frac{1}{2}\sum _{{i=0}}^{{\mathtt{numvar}-1}}\sum _{{j=0}}^{{\mathtt{numvar}-1}}q_{{ij}}^{k}x_{i}x_{j}+\sum _{{j=0}}^{{\mathtt{numvar}-1}}a_{{kj}}x_{j}\leq{}u_{k}^{c},~k=0,\ldots ,m-1.\end{math} (13.6.13)

    The function assigns values to q such that:

    \begin{math}\nonumber{}q_{{\mathtt{qcsubi[t]},\mathtt{qcsubj[t]}}}^{{\mathtt{qcsubk[t]}}}=\mathtt{qcval[t]},~t=0,\ldots ,\mathtt{numqcnz}-1.\end{math} (13.6.14)

    and

    \begin{math}\nonumber{}q_{{\mathtt{\mathtt{qcsubj[t]},qcsubi[t]}}}^{{\mathtt{qcsubk[t]}}}=\mathtt{qcval[t]},~t=0,\ldots ,\mathtt{numqcnz}-1.\end{math} (13.6.15)

    Values not assigned are set to zero.

    See also:

     

    Task.putqconk

    Replaces all quadratic terms in a single constraint.

    Task.putmaxnumqnz

    Changes the size of the preallocated storage for Q.

  • mosek.Task.putqconk

    Syntax:

     

    putqconk (
        int k,
        array(int) qcsubi,
        array(int) qcsubj,
        array(double) qcval)
    
    Arguments:

     

    k (input)
    The constraint in which new the Q elements are inserted.
    qcsubi (input)
    i subscripts for [[MathCmd 82]]. See (5.8.4).
    qcsubj (input)
    j subscripts for [[MathCmd 82]]. See (5.8.4).
    qcval (input)
    Numerical value for [[MathCmd 82]].
    Description:

    Replaces all the quadratic entries in one constraint k of the form:

    \begin{math}\nonumber{}l_{k}^{c}\leq{}\frac{1}{2}\sum _{{i=0}}^{{\mathtt{numvar}-1}}\sum _{{j=0}}^{{\mathtt{numvar}-1}}q_{{ij}}^{k}x_{i}x_{j}+\sum _{{j=0}}^{{\mathtt{numvar}-1}}a_{{kj}}x_{j}\leq{}u_{k}^{c}.\end{math} (13.6.16)

    It is assumed that [[MathCmd 26]] is symmetric, i.e. [[MathCmd 610]], and therefore, only the values of [[MathCmd 611]] for which ij should be inputted to MOSEK. To be precise, MOSEK uses the following procedure

    \begin{displaymath}\nonumber{}\begin{array}{ll}\nonumber{}1. & Q^{{k}}=0\\\nonumber{}2. & \mbox{for }t=0\mbox{ to }\mathtt{numqonz}-1\\\nonumber{}3. & \qquad{}q_{{\mathtt{qcsubi[t]},\mathtt{qcsubj[t]}}}^{{k}}=q_{{\mathtt{qcsubi[t]},\mathtt{qcsubj[t]}}}^{{k}}+\mathtt{qcval[t]}\\\nonumber{}3. & \qquad{}q_{{\mathtt{qcsubj[t]},\mathtt{qcsubi[t]}}}^{{k}}=q_{{\mathtt{qcsubj[t]},\mathtt{qcsubi[t]}}}^{{k}}+\mathtt{qcval[t]}\end{array}\end{displaymath}

    Please note that:

    • For large problems it is essential for the efficiency that the function Task.putmaxnumqnz is employed to specify an appropriate maxnumqnz.
    • Only the lower triangular part should be specified because [[MathCmd 26]] is symmetric. Specifying values for [[MathCmd 611]] 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. Hence, it is recommended not to specify the same element multiple times in qosubi, qosubj, and qoval.

    For a code example see section 5.3.2.

    See also:

     

    Task.putqcon

    Replaces all quadratic terms in constraints.

    Task.putmaxnumqnz

    Changes the size of the preallocated storage for Q.

  • mosek.Task.putqobj

    Syntax:

     

    putqobj (
        array(int) qosubi,
        array(int) qosubj,
        array(double) qoval)
    
    Arguments:

     

    qosubi (input)
    i subscript for [[MathCmd 77]].
    qosubj (input)
    j subscript for [[MathCmd 77]].
    qoval (input)
    Numerical value for [[MathCmd 77]].
    Description:

    Replaces all the quadratic terms in the objective

    \begin{math}\nonumber{}\frac{1}{2}\sum \limits _{{i=0}}^{{\mathtt{numvar}-1}}\sum _{{j=0}}^{{\mathtt{numvar}-1}}q_{{ij}}^{o}x_{i}x_{j}+\sum _{{j=0}}^{{\mathtt{numvar}-1}}c_{j}x_{j}+c^{f}.\end{math} (13.6.17)

    It is assumed that [[MathCmd 25]] is symmetric, i.e. [[MathCmd 620]], and therefore, only the values of [[MathCmd 621]] for which ij should be specified. To be precise, MOSEK uses the following procedure

    \begin{displaymath}\nonumber{}\begin{array}{ll}\nonumber{}1. & Q^{o}=0\\\nonumber{}2. & \mbox{for }t=0\mbox{ to }\mathtt{numqonz}-1\\\nonumber{}3. & \qquad{}q_{{\mathtt{qosubi[t]},\mathtt{qosubj[t]}}}^{{o}}=q_{{\mathtt{qosubi[t]},\mathtt{qosubj[t]}}}^{{o}}+\mathtt{qoval[t]}\\\nonumber{}3. & \qquad{}q_{{\mathtt{qosubj[t]},\mathtt{qosubi[t]}}}^{{o}}=q_{{\mathtt{qosubj[t]},\mathtt{qosubi[t]}}}^{{o}}+\mathtt{qoval[t]}\end{array}\end{displaymath}

    Please note that:

    • Only the lower triangular part should be specified because [[MathCmd 25]] is symmetric. Specifying values for [[MathCmd 621]] 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 not added to together; only the last value for each entry is used.

    For a code example see section 5.3.1.

  • mosek.Task.putqobjij

    Syntax:

     

    putqobjij (
        int i,
        int j,
        double qoij)
    
    Arguments:

     

    i (input)
    Row index for the coefficient to be replaced.
    j (input)
    Column index for the coefficient to be replaced.
    qoij (input)
    The new value for [[MathCmd 77]].
    Description:

    Replaces one of the coefficients in the quadratic term in the objective. The function performs the assignment

    \begin{displaymath}\nonumber{}q_{{\mathtt{i}\mathtt{j}}}^{o}=\mathtt{qoij}.\end{displaymath}
  • mosek.Task.putsolution

    Syntax:

     

    putsolution (
        mosek.soltype whichsol,
        array(int) skc,
        array(int) skx,
        array(int) skn,
        array(double) xc,
        array(double) xx,
        array(double) y,
        array(double) slc,
        array(double) suc,
        array(double) slx,
        array(double) sux,
        array(double) snx)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    skc (input)
    Status keys for the constraints.
    skx (input)
    Status keys for the variables.
    skn (input)
    Status keys for the conic constraints.
    xc (input)
    Primal constraint solution.
    xx (input)
    Primal variable solution (x).
    y (input)
    Vector of dual variables corresponding to the constraints.
    slc (input)
    Dual variables corresponding to the lower bounds on the constraints ([[MathCmd 551]]).
    suc (input)
    Dual variables corresponding to the upper bounds on the constraints ([[MathCmd 552]]).
    slx (input)
    Dual variables corresponding to the lower bounds on the variables ([[MathCmd 553]]).
    sux (input)
    Dual variables corresponding to the upper bounds on the variables ([[MathCmd 554]]).
    snx (input)
    Dual variables corresponding to the conic constraints on the variables ([[MathCmd 555]]).
    Description:
    Inserts a solution into the task.
  • mosek.Task.putsolutioni

    Syntax:

     

    putsolutioni (
        mosek.accmode accmode,
        int i,
        mosek.soltype whichsol,
        mosek.stakey sk,
        double x,
        double sl,
        double su,
        double sn)
    
    Arguments:

     

    accmode (input)
    If non-zero, then the solution information for a constraint is modified. Otherwise for a variable.
    i (input)
    Index of the constraint or variable.
    whichsol (input)
    Selects a solution.
    sk (input)
    Status key of the constraint or variable.
    x (input)
    Solution value of the primal constraint or variable.
    sl (input)
    Solution value of the dual variable associated with the lower bound.
    su (input)
    Solution value of the dual variable associated with the upper bound.
    sn (input)
    Solution value of the dual variable associated with the cone constraint.
    Description:

    Sets the primal and dual solution information for a single constraint or variable.

    To define a solution or a significant part of a solution, first call the Task.makesolutionstatusunknown function, then for each relevant function and variable, call Task.putsolutioni to set the solution information.

    See also:

     

    Task.makesolutionstatusunknown

    Sets the solution status to unknown.

  • mosek.Task.putsolutionyi

    Syntax:

     

    putsolutionyi (
        int i,
        mosek.soltype whichsol,
        double y)
    
    Arguments:

     

    i (input)
    Index of the dual variable.
    whichsol (input)
    Selects a solution.
    y (input)
    Solution value of the dual variable.
    Description:
    Inputs the dual variable of a solution.
    See also:

     

    Task.makesolutionstatusunknown

    Sets the solution status to unknown.

    Task.putsolutioni

    Sets the primal and dual solution information for a single constraint or variable.

  • mosek.Task.putstrparam

    Syntax:

     

    putstrparam (
        mosek.sparam param,
        str parvalue)
    
    Arguments:

     

    param (input)
    Which parameter.
    parvalue (input)
    Parameter value.
    Description:
    Sets the value of a string parameter.
  • mosek.Task.puttaskname

    Syntax:

     

    puttaskname (str taskname)
    
    Arguments:

     

    taskname (input)
    Name assigned to the task.
    Description:
    Assigns the name taskname to the task.
  • mosek.Task.putvarbranchorder

    Syntax:

     

    putvarbranchorder (
        int j,
        int priority,
        mosek.branchdir direction)
    
    Arguments:

     

    j (input)
    Index of the variable.
    priority (input)
    The branching priority that should be assigned to variable j.
    direction (input)
    Specifies the preferred branching direction for variable j.
    Description:
    The purpose of the function is to assign a branching priority and direction. The higher priority that is assigned to an integer variable the earlier the mixed integer optimizer will branch on the variable. The branching direction controls if the optimizer branches up or down on the variable.
  • mosek.Task.putvartype

    Syntax:

     

    putvartype (
        int j,
        mosek.variabletype vartype)
    
    Arguments:

     

    j (input)
    Index of the variable.
    vartype (input)
    The new variable type.
    Description:
    Sets the variable type of one variable.
  • mosek.Task.putvartypelist

    Syntax:

     

    putvartypelist (
        array(int) subj,
        array(int) vartype)
    
    Arguments:

     

    subj (input)
    A list of variable indexes for which the variable type should be changed.
    vartype (input)
    A list of variable types that should be assigned to the variables specified by subj. See section 16.48 for the possible values of vartype.
    Description:

    Sets the variable type for one or more variables, i.e. variable number [[MathCmd 632]] is assigned the variable type [[MathCmd 633]].

    If the same index is specified multiple times in subj only the last entry takes effect.

  • mosek.Task.readbranchpriorities

    Syntax:

     

    readbranchpriorities (str filename)
    
    Arguments:

     

    filename (input)
    Data is written to the file filename.
    Description:
    Reads branching priority data from a file.
    See also:

     

    Task.writebranchpriorities

    Writes branching priority data to a file.

  • mosek.Task.readdata

    Syntax:

     

    readdata (str filename)
    
    Arguments:

     

    filename (input)
    Data is read from the file filename if it is a nonempty string. Otherwise data is read from the file specified by mosek.sparam.data_file_name.
    Description:

    Reads an optimization data and associated data from a file.

    The data file format is determined by the mosek.iparam.read_data_format parameter. By default the parameter has the value mosek.dataformat.extension indicating that the extension of the input file should determine the file type, where the extension is interpreted as follows:

    • ".lp" and ".lp.gz" are interpreted as an LP file and a compressed LP file respectively.
    • ".opf" and ".opf.gz" is interpreted as an OPF file and a compressed OPF file respectively.
    • ".mps" and ".mps.gz" is interpreted as an MPS file and a compressed MPS file respectively.
    • ".mbt" is interpreted as an MBT file (MOSEK binary task file).
    See also:

     

    Task.writedata

    Writes problem data to a file.

    mosek.iparam.read_data_format
  • mosek.Task.readparamfile

    Syntax:

     

    readparamfile ()
    
    Description:
    Reads a parameter file.
  • mosek.Task.readsolution

    Syntax:

     

    readsolution (
        mosek.soltype whichsol,
        str filename)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    filename (input)
    A valid file name.
    Description:
    Reads a solution file and inserts the solution into the solution whichsol.
  • mosek.Task.readsummary

    Syntax:

     

    readsummary (mosek.streamtype whichstream)
    
    Arguments:

     

    whichstream (input)
    Index of the stream.
    Description:
    Prints a short summary of last file that was read.
  • mosek.Task.relaxprimal

    Syntax:

     

    Task relaxprimal (
        array(double) wlc,
        array(double) wuc,
        array(double) wlx,
        array(double) wux)
    
    Arguments:

     

    wlc (input/output)
    Weights associated with lower bounds on the activity of constraints. If negative, the bound is strictly enforced, i.e. if [[MathCmd 634]], then [[MathCmd 361]] is fixed to zero. On return wlc[i] contains the relaxed bound.
    wuc (input/output)
    Weights associated with upper bounds on the activity of constraints. If negative, the bound is strictly enforced, i.e. if [[MathCmd 636]], then [[MathCmd 362]] is fixed to zero. On return wuc[i] contains the relaxed bound.
    wlx (input/output)
    Weights associated with lower bounds on the activity of variables. If negative, the bound is strictly enforced, i.e. if [[MathCmd 638]] then [[MathCmd 639]] is fixed to zero. On return wlx[i] contains the relaxed bound.
    wux (input/output)
    Weights associated with upper bounds on the activity of variables. If negative, the bound is strictly enforced, i.e. if [[MathCmd 640]] then [[MathCmd 641]] is fixed to zero. On return wux[i] contains the relaxed bound.
    Returns:
     
    Description:

    Creates a problem that computes the minimal (weighted) relaxation of the bounds that will make an infeasible problem feasible.

    Given an existing task describing the problem

    \begin{math}\nonumber{}\begin{array}{lccccl}\nonumber{}\mbox{minimize} &  &  & c^{T}x &  & \\\nonumber{}\mbox{subject to} & l^{c} & \leq{} & Ax & \leq{} & u^{c},\\\nonumber{} & l^{x} & \leq{} & x & \leq{} & u^{x},\end{array}\end{math} (13.6.18)

    the function forms a new task relaxedtask having the form

    \begin{math}\nonumber{}\begin{array}{lccccl}\nonumber{}\mbox{minimize} &  &  & p &  & \\\nonumber{}\mbox{subject to} & l^{c} & \leq{} & Ax+v_{l}^{c}-v_{u}^{c} & \leq{} & u^{c},\\\nonumber{} & l^{x} & \leq{} & x+v_{l}^{x}-v_{u}^{x} & \leq{} & u^{x},\\\nonumber{} &  &  & (w_{l}^{c})^{T}v_{l}^{c}+(w_{u}^{c})^{T}v_{u}^{c}+(w_{l}^{x})^{T}v_{l}^{x}+(w_{u}^{x})^{T}v_{u}^{x}-p & \leq{} & 0,\\\nonumber{} &  &  & v_{l}^{c},v_{u}^{c},v_{l}^{x},v_{u}^{x}\geq{}0. &  &\end{array}\end{math} (13.6.19)

    Hence, the function adds so-called elasticity variables to all the constraints which relax the constraints, for instance [[MathCmd 361]] and [[MathCmd 362]] relax [[MathCmd 366]] and [[MathCmd 647]] respectively. It should be obvious that (13.6.19) is feasible. Moreover, the function adds the constraint

    \begin{displaymath}\nonumber{}(w_{l}^{c})^{T}v_{l}^{c}+(w_{u}^{c})^{T}v_{u}^{c}+(w_{l}^{x})^{T}v_{l}^{x}+(w_{u}^{x})^{T}v_{u}^{x}-p\leq{}0\end{displaymath}

    to the problem which makes the variable p bigger than the total weighted sum of the relaxation to the bounds. [[MathCmd 370]], [[MathCmd 371]], [[MathCmd 372]] and [[MathCmd 373]] are user-defined weights which normally should be nonnegative. If a weight is negative, then the corresponding elasticity variable is fixed to zero.

    Hence, when the problem (13.6.19) is optimized, the weighted minimal change to the bounds such that the problem is feasible is computed.

    One can specify that a bound should be strictly enforced by assigning a negative value to the corresponding weight, i.e if [[MathCmd 634]] then [[MathCmd 361]] is fixed to zero.

    Now let [[MathCmd 376]] be the optimal objective value to (13.6.19), then a natural thing to do is to solve the optimization problem

    \begin{math}\nonumber{}\begin{array}{lccccl}\nonumber{}\mbox{minimize} &  &  & c^{T}x &  & \\\nonumber{}\mbox{subject to} & l^{c} & \leq{} & Ax+v_{l}^{c}-v_{u}^{c} & \leq{} & u^{c},\\\nonumber{} & l^{x} & \leq{} & x+v_{l}^{x}-v_{u}^{x} & \leq{} & u^{x},\\\nonumber{} &  &  & (w_{l}^{c})^{T}v_{l}^{c}+(w_{u}^{c})^{T}v_{u}^{c}+(w_{l}^{x})^{T}v_{l}^{x}+(w_{u}^{x})^{T}v_{u}^{x}-p & \leq{} & 0,\\\nonumber{} &  &  & p & = & p^{*},\\\nonumber{} &  &  & v_{l}^{c},v_{u}^{c},v_{l}^{x},v_{u}^{x}\geq{}0, &  &\end{array}\end{math} (13.6.20)

    where the original objective function is minimized subject to the constraint that the total weighted relaxation is minimal.

    The parameter mosek.iparam.feasrepair_optimize controls whether the function returns the problem (13.6.19) or the problem (13.6.20).The parameter can take one of the following values.

    mosek.feasrepairtype.optimize_none

    : The returned task relaxedtask contains problem (13.6.19) and is not optimized.

    mosek.feasrepairtype.optimize_penalty

    : The returned task relaxedtask contains problem (13.6.19) and is optimized.

    mosek.feasrepairtype.optimize_combined

    : The returned task relaxedtask contains problem (13.6.20) and is optimized.

    Please note that the v variables are appended to the x variables ordered as

    \begin{displaymath}\nonumber{}(v_{u}^{c})_{1},(v_{l}^{c})_{1},(v_{u}^{c})_{2},(v_{l}^{c})_{2},\ldots ,(v_{u}^{c})_{m},(v_{l}^{c})_{m},\quad{}(v_{u}^{x})_{1},(v_{l}^{x})_{1},(v_{u}^{x})_{2},(v_{l}^{x})_{2},\ldots ,(v_{u}^{x})_{n},(v_{l}^{x})_{n}\end{displaymath}

    in the returned task.

    If NAME_CON (NAME_VAR) is the name of the ith constraint (variable) then the new variables are named as follows:

    • The variable corresponding to [[MathCmd 362]] ([[MathCmd 659]]) is named “NAME_CON*up” (“NAME_VAR*up”).
    • The variable corresponding to [[MathCmd 361]] ([[MathCmd 363]]) is named “NAME_CON*lo” (“NAME_VAR*lo”).

    where “*” can be replaced by a user-defined string by setting the mosek.sparam.feasrepair_name_separator parameter.

    Please note that if [[MathCmd 662]] or [[MathCmd 663]] then the feasibility repair problem becomes infeasible. Such trivial conflicts must therefore be removed manually before using Task.relaxprimal.

    The above discussion shows how the function works for a linear optimization problem. However, the function also works for quadratic and conic optimization problems but it cannot be used for general nonlinear optimization problems.

    See also:

     

    mosek.dparam.feasrepair_tol
    mosek.iparam.feasrepair_optimize
    mosek.sparam.feasrepair_name_separator
    mosek.sparam.feasrepair_name_prefix
  • mosek.Task.remove

    Syntax:

     

    remove (
        mosek.accmode accmode,
        array(int) sub)
    
    Arguments:

     

    accmode (input)
    Defines if operations are performed row-wise (constraint-oriented) or column-wise (variable-oriented).
    sub (input)
    Indexes of constraints or variables which should be removed.
    Description:
    The function removes a number of constraints or variables from the optimization task. This implies that the existing constraints and variables are renumbered, for instance if constraint 5 is removed then constraint 6 becomes constraint 5 and so forth.
    See also:

     

    Task.append

    Appends a number of variables or constraints to the optimization task.

  • mosek.Task.removecone

    Syntax:

     

    removecone (int k)
    
    Arguments:

     

    k (input)
    Index of the conic constraint that should be removed.
    Description:

    Removes a conic constraint from the problem. This implies that all the conic constraints appearing after cone number k are renumbered, decresing their indexes by one.

    In general, it is much more efficient to remove a cone with a high index than a low index.

  • mosek.Task.resizetask

    Syntax:

     

    resizetask (
        int maxnumcon,
        int maxnumvar,
        int maxnumcone,
        int maxnumanz,
        int maxnumqnz)
    
    Arguments:

     

    maxnumcon (input)
    New maximum number of constraints.
    maxnumvar (input)
    New maximum number of variables.
    maxnumcone (input)
    New maximum number of cones.
    maxnumanz (input)
    New maximum number of non-zeros in A.
    maxnumqnz (input)
    New maximum number of non-zeros in all Q matrices.
    Description:

    Sets the amount of preallocated space assigned for each type of data in an optimization task.

    It is never mandatory to call this function, since its only function is to give a hint of the amount of data to preallocate for efficiency reasons.

    Please note that the procedure is destructive in the sense that all existing data stored in the task is destroyed.

    See also:

     

    Task.putmaxnumvar

    Sets the number of preallocated variables in the optimization task.

    Task.putmaxnumcon

    Sets the number of preallocated constraints in the optimization task.

    Task.putmaxnumcone

    Sets the number of preallocated conic constraints in the optimization task.

    Task.putmaxnumanz

    The function changes the size of the preallocated storage for linear coefficients.

    Task.putmaxnumqnz

    Changes the size of the preallocated storage for Q.

  • mosek.Task.sensitivityreport

    Syntax:

     

    sensitivityreport (mosek.streamtype whichstream)
    
    Arguments:

     

    whichstream (input)
    Index of the stream.
    Description:
    Reads a sensitivity format file from a location given by mosek.sparam.sensitivity_file_name and writes the result to the stream whichstream. If mosek.sparam.sensitivity_res_file_name is set to a non-empty string, then the sensitivity report is also written to a file of this name.
    See also:

     

    Task.dualsensitivity

    Performs sensitivity analysis on objective coefficients.

    Task.primalsensitivity

    Perform sensitivity analysis on bounds.

    mosek.iparam.log_sensitivity
    mosek.iparam.log_sensitivity_opt
    mosek.iparam.sensitivity_type
  • mosek.Task.set_Stream

    Syntax:

     

    set_Stream (mosek.streamtype whichstream)
    
    Arguments:

     

    whichstream
    Index of the stream.
    Description:
    Attach a stream call-back handler.
  • mosek.Task.setdefaults

    Syntax:

     

    setdefaults ()
    
    Description:
    Resets all the parameters to their default values.
  • mosek.Task.solutiondef

    Syntax:

     

    int solutiondef (mosek.soltype whichsol)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    Returns:
     
    Description:
    Checks whether a solution is defined.
  • mosek.Task.solutionsummary

    Syntax:

     

    solutionsummary (mosek.streamtype whichstream)
    
    Arguments:

     

    whichstream (input)
    Index of the stream.
    Description:
    Prints a short summary of the current solution.
  • mosek.Task.solvewithbasis

    Syntax:

     

    int solvewithbasis (
        int transp,
        int numnz,
        array(int) sub,
        array(double) val)
    
    Arguments:

     

    transp (input)
    If this argument is non-zero, then (13.6.22) is solved. Otherwise the system (13.6.21) is solved.
    numnz (input/output)
    As input it is the number of non-zeros in b. As output it is the number of non-zeros in [[MathCmd 664]].
    sub (input/output)

    As input it contains the positions of the non-zeros in b, i.e.

    \begin{displaymath}\nonumber{}b[\mathtt{sub}[k]]\not=0,~k=0,\ldots ,\mathtt{numnz[0]}-1.\end{displaymath}

    As output it contains the positions of the non-zeros in [[MathCmd 664]]. It is important that sub has room for numcon elements.

    val (input/output)

    As input it is the vector b. Although the positions of the non-zero elements are specified in sub it is required that [[MathCmd 667]] if b[i]=0. As output val is the vector [[MathCmd 664]].

    Please note that val is a dense vector — not a packed sparse vector. This implies that val has room for numcon elements.

    Returns:
     
    Description:

    If a basic solution is available, then exactly [[MathCmd 669]] basis variables are defined. These [[MathCmd 669]] basis variables are denoted the basis. Associated with the basis is a basis matrix denoted B. This function solves either the linear equation system

    \begin{math}\nonumber{}B\bar{x}=b\end{math} (13.6.21)

    or the system

    \begin{math}\nonumber{}B^{T}\bar{x}=b\end{math} (13.6.22)

    for the unknowns [[MathCmd 664]], with b being a user-defined vector.

    In order to make sense of the solution [[MathCmd 664]] it is important to know the ordering of the variables in the basis because the ordering specifies how B is constructed. When calling Task.initbasissolve an ordering of the basis variables is obtained, whicd can be used to deduce how MOSEK has constructed B. Indeed if the kth basis variable is variable [[MathCmd 244]] it implies that

    \begin{displaymath}\nonumber{}B_{{i,k}}=A_{{i,j}},~i=0,\ldots ,\mathtt{numcon}-1.\end{displaymath}

    Otherwise if the kth basis variable is variable [[MathCmd 677]] it implies that

    \begin{displaymath}\nonumber{}B_{{i,k}}=\left\lbrace{}\begin{array}{ll}\nonumber{}-1, & i=j,\\\nonumber{}0, & i\not=j.\end{array}\right.\end{displaymath}

    Given the knowledge of how B is constructed it is possible to interpret the solution [[MathCmd 664]] correctly.

    Please note that this function exploits the sparsity in the vector b to speed up the computations.

    See also:

     

    Task.initbasissolve

    Prepare a task for use with the Task.solvewithbasis function.

  • mosek.Task.startstat

    Syntax:

     

    startstat ()
    
    Description:
    Starts the statistics file.
  • mosek.Task.stopstat

    Syntax:

     

    stopstat ()
    
    Description:
    Stops the statistics file.
  • mosek.Task.strtoconetype

    Syntax:

     

    strtoconetype (
        str str,
        List|None conetype)
    
    Arguments:

     

    str (input)
    String corresponding to the cone type code codetype.
    conetype (output)
    The cone type corresponding to the string str.
    Description:
    Obtains cone type code corresponding to a cone type string.
  • mosek.Task.strtosk

    Syntax:

     

    strtosk (
        str str,
        List|None sk)
    
    Arguments:

     

    str (input)
    Status key string.
    sk (output)
    Status key corresponding to the string.
    Description:
    Obtains the status key corresponding to an explanatory string.
  • mosek.Task.undefsolution

    Syntax:

     

    undefsolution (mosek.soltype whichsol)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    Description:
    Undefines a solution. Purges all information regarding whichsol.
  • mosek.Task.writebranchpriorities

    Syntax:

     

    writebranchpriorities (str filename)
    
    Arguments:

     

    filename (input)
    Data is written to the file filename.
    Description:
    Writes branching priority data to a file.
    See also:

     

    Task.readbranchpriorities

    Reads branching priority data from a file.

  • mosek.Task.writedata

    Syntax:

     

    writedata (str filename)
    
    Arguments:

     

    filename (input)
    Data is written to the file filename if it is a nonempty string. Otherwise data is written to the file specified by mosek.sparam.data_file_name.
    Description:

    Writes problem data associated with the optimization task to a file in one of four formats:

    LP : A text based row oriented format. File extension .lp. See Appendix B.

    MPS : A text based column oriented format. File extension .mps. See Appendix A.

    OPF : A text based row oriented format. File extension .opf. Supports more problem types than MPS and LP. See Appendix C.

    MBT : A binary format for fast reading and writing. File extension .mbt.

    By default the data file format is determined by the file name extension. This behaviour can be overridden by setting the mosek.iparam.write_data_format parameter.

    Please note that MPS, LP and OPF files require all variables to have unique names. If a task contains no names, it is possible to write the file with automaticly generated anonymous names by setting the mosek.iparam.write_generic_names parameter to mosek.onoffkey.on.

    See also:

     

    Task.readdata

    Reads problem data from a file.

    mosek.iparam.write_data_format
  • mosek.Task.writeparamfile

    Syntax:

     

    writeparamfile (str filename)
    
    Arguments:

     

    filename (input)
    The name of parameter file.
    Description:
    Writes all the parameters to a parameter file.
  • mosek.Task.writesolution

    Syntax:

     

    writesolution (
        mosek.soltype whichsol,
        str filename)
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    filename (input)
    A valid file name.
    Description:
    Saves the current basic, interior-point, or integer solution to a file.

13.7. Class mosek.Warning

Derived from:

mosek.Exception

Description:

This is an exception class representing MOSEK warnings.

13.7.1. Constructors

  • mosek.Warning

    Syntax: 

    Warning (mosek.rescode code)
    
    Description:Construct a warning from a MOSEK error code.

    Arguments: 

    code
    The MOSEK response code to create the exception from.
Mon Sep 14 15:53:08 2009