13. API reference


This chapter lists all functionality in the MOSEK Java 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.solstatostr
Obtains a solution status string.

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.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.getinfindex
Obtains the index of a named information item.

mosek.Task.getinfmax
Obtains the maximum index of an information of a given type inftype plus 1.

mosek.Task.getinfname
Obtains the name of an 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.getparammax
Obtains the maximum index of a parameter of a given type plus 1.

mosek.Task.getparamname
Obtains the name of a parameter.

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

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

mosek.Env.iparvaltosymnam
Obtains the symbolic name corresponding to a value that can be assigned to an integer parameter.

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.getvarbranchorder
Obtains the branching priority 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:

system.Exception

Description:

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

13.3. Class mosek.Callback

Description:

Base class for all call-back objects used in MOSEK

13.4. Class mosek.Env

Description:

A Mosek Environment

13.4.1. Constructors

  • mosek.Env

    Syntax: 

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

    Syntax: 

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

    Arguments: 

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

13.4.2. Attributes

  • set_CtrlC(mosek.CtrlC) Control-c call-back object.
  • set_Exit(mosek.Exit) Exit handler call-back object.

13.4.3. Methods

  • mosek.Env.echointro

    Syntax:

     

    public void echointro (int longver)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void getsymbcondim (
        int[] num,
        int[] maxlen)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getversion (
        int[] major,
        int[] minor,
        int[] build,
        int[] revision)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void initenv ()
        throws mosek.Error,
               mosek.Warning;
    
    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.iparvaltosymnam

    Syntax:

     

    public void iparvaltosymnam (
        int whichparam,
        int whichvalue,
        StringBuffer symbolicname)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    whichparam (input)
    Which parameter.
    whichvalue (input)
    Which value.
    symbolicname (output)
    The symbolic name corresponding to whichvalue.
    Description:
    Obtains the symbolic name corresponding to a value that can be assigned to an integer parameter.
  • mosek.Env.linkfiletoenvstream

    Syntax:

     

    public void linkfiletoenvstream (
        int whichstream,
        String filename,
        int append)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putcpudefaults (
        int cputype,
        int sizel1,
        int sizel2)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putdllpath (String dllpath)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putkeepdlls (int keepdlls)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putlicensedefaults (
        String licensefile,
        int[] licensebuf,
        int licwait,
        int licdebug)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 Env.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:

     

    public void set_Stream (
        int whichstream,
        mosek.Stream stream)
    
    Arguments:

     

    whichstream
    Index of the stream.
    stream
    The stream object to attach. To detach all objects, let this be null.
    Description:
    Attach a stream call-back handler.

13.5. Class mosek.Error

Derived from:

mosek.Exception

Description:

This is an exception class representing MOSEK errors.

13.5.1. Constructors

  • mosek.Error

    Syntax: 

    public Error (int code)
    
    Description:Construct an error from a MOSEK error code.

    Arguments: 

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

    Syntax: 

    public Error (
        int code,
        String 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.6. Class mosek.Exception

Derived from:

system.Exception

Description:

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

13.6.1. Constructors

  • mosek.Exception

    Syntax: 

    public Exception (int code)
    
    Description:Construct an exception from a MOSEK error code.

    Arguments: 

    code
    The MOSEK response code to create the exception from.

13.7. Class mosek.Exit

Derived from:

mosek.Callback

Description:

Base class for MOSEK exit call-back handler. An object of this type can be attached to a MOSEK environment.

If MOSEK encounters a fatal error, for example if memory corrupted, a certain member of the class is called before the program terminates.

13.7.1. Constructors

  • mosek.Exit

    Syntax: 

    public Exit ()
    
    Description:Construct an Exit object.

13.7.2. Methods

  • mosek.Exit.exit
    This method is called when a fatal error situation is encountered.
  • mosek.Exit.exit

    Syntax:

     

    public void exit (
        String file,
        int line,
        String msg)
    
    Arguments:

     

    file (input)
    The source file in which the fatal error was detected.
    line
    The line on which the fatal error was detected.
    msg (input)
    A string describing the error.
    Description:
    This method is called when a fatal error situation is encountered. To intercept the message, override this function.

13.8. Class mosek.Progress

Derived from:

mosek.Callback

Description:

This is the base class for user-defined progress call-back objects. An object of this type can be attached to a MOSEK task in order to receive frequent calls with a progress indicator during long optimizations. The calls are received by overriding a certain member of this class.

The call-back method is called at the beginning of each iteration in the interior-point optimizer. For the simplex optimizers the parameter Env.iparam.log_sim_freq controls how frequent the call-backs are.

Typically, the user-defined call-back method displays information about the solution process. The call-back function can also be used to terminate the optimization process: If the method returns a non-zero value when called, MOSEK will abort optimization and perform proper cleanup of the task.

It is important that the user-defined call-back function does not modify the optimization task, this will lead to undefined behavior and incorrect results. The only MOSEK functions that can be called safely from within the user-defined call-back function are Task.getdouinf and Task.getintinf which access the task information database. The items in task information database are updated during the optimization process.

13.8.1. Constructors

  • mosek.Progress

    Syntax: 

    public Progress ()
    
    Description:Construct a Progress object.

13.8.2. Methods

  • mosek.Progress.progress

    Syntax:

     

    public void progress (int caller)
    
    Arguments:

     

    caller
    A value indicating the point from where the function was called.
    Description:
    The method called during optimization. Override this function to receive the progress indicators.

13.9. Class mosek.Stream

Derived from:

mosek.Callback

Description:

Base class for stream printer classes which can be attached to MOSEK tasks and environments to intercept output.

13.9.1. Constructors

  • mosek.Stream

    Syntax: 

    public Stream ()
    
    Description:Construct a MOSEK Stream printer object.

13.9.2. Methods

  • mosek.Stream.print

    Syntax:

     

    public void print (String str)
    
    Arguments:

     

    str
    A string to be outputted.
    Description:
    The method which receives output strings from MOSEK.

13.10. Class mosek.Task

Description:

A Mosek Optimization task

13.10.1. Constructors

  • mosek.Task

    Syntax: 

    public Task (
        mosek.Env env,
        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: 

    env
    The environment the task should belong to.
    maxnumcon
    Initially reserve space for this many constraints.
    maxnumvar
    Initially reserve space for this many variables.

13.10.2. Attributes

  • set_ErrorHandler(mosek.ErrorHandler) Error handler call-back object
  • set_Nonlinear(mosek.Nonlinear) Nonlinear sparsity and value computation call-back object.
  • set_Progress(mosek.Progress) Progress call-back object

13.10.3. Methods

  • mosek.Task.append

    Syntax:

     

    public void append (
        int accmode,
        int num)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void appendcone (
        int conetype,
        double conepar,
        int[] submem)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 523]] 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:

     

    public void appendcons (
        int[] aptrb,
        int[] aptre,
        int[] asub,
        double[] aval,
        int[] bkc,
        double[] blc,
        double[] buc)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    aptrb (input)
    See (13.10.2).
    aptre (input)
    See (13.10.2).
    asub (input)
    Variable subscripts of the new A coefficients. See (13.10.2).
    aval (input)
    A coefficients of the new constraints. See (13.10.2).
    bkc (input)
    Bound keys for constraints to be appended. See (13.10.1).
    blc (input)
    Lower bounds on constraints to be appended. See (13.10.1).
    buc (input)
    Upper bounds on constraints to be appended. See (13.10.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.10.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.10.2)
    See also:

     

    Task.putmaxnumcon

    Sets the number of preallocated constraints in the optimization task.

  • mosek.Task.appendstat

    Syntax:

     

    public void appendstat ()
        throws mosek.Error,
               mosek.Warning;
    
    Description:
    Appends a record to the statistics file.
  • mosek.Task.appendvars

    Syntax:

     

    public void appendvars (
        double[] cval,
        int[] aptrb,
        int[] aptre,
        int[] asub,
        double[] aval,
        int[] bkx,
        double[] blx,
        double[] bux)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    cval (input)
    Values of c for the variables to be appended. See (13.10.3).
    aptrb (input)
    See (13.10.4).
    aptre (input)
    See (13.10.4).
    asub (input)
    Constraint subscripts of the A coefficients to be added. See (13.10.4).
    aval (input)
    The A coefficients corresponding to the appended variables. See (13.10.4).
    bkx (input)
    Bound keys on variables to be appended. See (13.10.3).
    blx (input)
    Lower bounds on variables to be appended. See (13.10.3).
    bux (input)
    Upper bounds on variables to be appended. See (13.10.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.10.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.10.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:

     

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

     

    Env.iparam.check_convexity
  • mosek.Task.checkdata

    Syntax:

     

    public void checkdata ()
        throws mosek.Error,
               mosek.Warning;
    
    Description:
    Checks the data of the optimization task.
  • mosek.Task.checkmemtask

    Syntax:

     

    public void checkmemtask (
        String file,
        int line)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void chgbound (
        int accmode,
        int i,
        int lower,
        int finite,
        double value)
        throws mosek.Error,
               mosek.Warning;
    
    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 Env.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.

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

    Syntax:

     

    public void clonetask (TaskContainer clonedtask)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    clonedtask (output)
    The cloned task.
    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:

     

    public void commitchanges ()
        throws mosek.Error,
               mosek.Warning;
    
    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.conetypetostr

    Syntax:

     

    public void conetypetostr (
        int conetype,
        StringBuffer str)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    conetype (input)
    Specifies the type of the cone.
    str (output)
    String corresponding to the cone type code codetype.
    Description:
    Obtains the cone string identifier corresponding to a cone type.
  • mosek.Task.deletesolution

    Syntax:

     

    public void deletesolution (int whichsol)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void dualsensitivity (
        int[] subj,
        double[] leftpricej,
        double[] rightpricej,
        double[] leftrangej,
        double[] rightrangej)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    subj (input)
    Index of objective coefficients to analyze.
    leftpricej (output)
    [[MathCmd 530]] is the left shadow price for the coefficients with index [[MathCmd 531]].
    rightpricej (output)
    [[MathCmd 532]] is the right shadow price for the coefficients with index [[MathCmd 531]].
    leftrangej (output)
    [[MathCmd 534]] is the left range [[MathCmd 463]] for the coefficient with index [[MathCmd 531]].
    rightrangej (output)
    [[MathCmd 537]] is the right range [[MathCmd 464]] for the coefficient with index [[MathCmd 531]].
    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 541]] is the left shadow price of the objective coefficient with index [[MathCmd 542]].

    The type of sensitivity analysis to perform (basis or optimal partition) is controlled by the parameter Env.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.

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

    Syntax:

     

    public void getaij (
        int i,
        int j,
        double[] aij)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    i (input)
    Row index of the coefficient to be returned.
    j (input)
    Column index of the coefficient to be returned.
    aij (output)
    The required coefficient [[MathCmd 543]].
    Description:
    Obtains a single coefficient in A.
  • mosek.Task.getapiecenumnz

    Syntax:

     

    public void getapiecenumnz (
        int firsti,
        int lasti,
        int firstj,
        int lastj,
        int[] numnz)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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.
    numnz (output)
    Number of non-zero A elements in the rectangular piece.
    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 545]] means the number of elements in the set [[MathCmd 546]].

    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:

     

    public void getaslice (
        int accmode,
        int first,
        int last,
        int[] surp,
        int[] ptrb,
        int[] ptre,
        int[] sub,
        double[] val)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getaslicenumnz (
        int accmode,
        int first,
        int last,
        int[] numnz)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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.
    numnz (output)
    Number of non-zeros in the slice.
    Description:
    Obtains the number of non-zeros in a row or column slice of A.
  • mosek.Task.getaslicetrip

    Syntax:

     

    public void getaslicetrip (
        int accmode,
        int first,
        int last,
        int[] surp,
        int[] subi,
        int[] subj,
        double[] val)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getavec (
        int accmode,
        int i,
        int[] nzi,
        int[] subi,
        double[] vali)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 Env.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 Env.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:

     

    public void getavecnumnz (
        int accmode,
        int i,
        int[] nzj)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getbound (
        int accmode,
        int i,
        int[] bk,
        double[] bl,
        double[] bu)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getboundslice (
        int accmode,
        int first,
        int last,
        int[] bk,
        double[] bl,
        double[] bu)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getc (double[] c)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getcfix (double[] cfix)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    cfix (output)
    Fixed term in the objective.
    Description:
    Obtains the fixed term in the objective.
  • mosek.Task.getcone

    Syntax:

     

    public void getcone (
        int k,
        int[] conetype,
        double[] conepar,
        int[] nummem,
        int[] submem)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getconeinfo (
        int k,
        int[] conetype,
        double[] conepar,
        int[] nummem)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getconname (
        int i,
        StringBuffer name)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    i (input)
    Index.
    name (output)
    Is assigned the required name.
    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:

     

    public void getcslice (
        int first,
        int last,
        double[] c)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getdouinf (
        int whichdinf,
        double[] dvalue)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    whichdinf (input)
    A double information item. See section 16.11 for the possible values.
    dvalue (output)
    The value of the required double information item.
    Description:
    Obtains a double information item from the task information database.
  • mosek.Task.getdouparam

    Syntax:

     

    public void getdouparam (
        int param,
        double[] parvalue)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getdualobj (
        int whichsol,
        double[] dualobj)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getinfeasiblesubproblem (
        int whichsol,
        TaskContainer inftask)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    whichsol (input)
    Which solution to use when determining the infeasible subproblem.
    inftask (output)
    A new task containing the infeasible subproblem.
    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:

     

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

    Syntax:

     

    public void getinfindex (
        int inftype,
        String infname,
        int[] infindex)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    inftype (input)
    Type of the information item.
    infname (input)
    Name of the information item.
    infindex (output)
    The item index.
    Description:
    Obtains the index of a named information item.
  • mosek.Task.getinfmax

    Syntax:

     

    public void getinfmax (
        int inftype,
        int[] infmax)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    inftype (input)
    Type of the information item.
    infmax (output)
    Description:
    Obtains the maximum index of an information of a given type inftype plus 1.
  • mosek.Task.getinfname

    Syntax:

     

    public void getinfname (
        int inftype,
        int whichinf,
        StringBuffer infname)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    inftype (input)
    Type of the information item.
    whichinf (input)
    An information item. See section 16.11 and section 16.14 for the possible values.
    infname (output)
    Name of the information item.
    Description:
    Obtains the name of an information item.
  • mosek.Task.getintinf

    Syntax:

     

    public void getintinf (
        int whichiinf,
        int[] ivalue)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    whichiinf (input)
    Specifies an information item.
    ivalue (output)
    The value of the required integer information item.
    Description:
    Obtains an integer information item from the task information database.
  • mosek.Task.getintparam

    Syntax:

     

    public void getintparam (
        int param,
        int[] parvalue)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getmaxnamelen (int[] maxlen)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getmaxnumanz (int[] maxnumanz)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    maxnumanz (output)
    Number of preallocated non-zero elements in A.
    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:

     

    public void getmaxnumcon (int[] maxnumcon)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getmaxnumcone (int[] maxnumcone)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getmaxnumqnz (int[] maxnumqnz)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getmaxnumvar (int[] maxnumvar)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getmemusagetask (
        int[] meminuse,
        int[] maxmemuse)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getname (
        int whichitem,
        int i,
        int[] len,
        StringBuffer name)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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.
    name (output)
    Is assigned the required name.
    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:

     

    public void getnameindex (
        int whichitem,
        String name,
        int[] asgn,
        int[] index)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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.
    index (output)
    If the name identifies an item in the task, then index is assigned the index of that item.
    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:

     

    public void getnumanz (int[] numanz)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    numanz (output)
    Number of non-zero elements in A.
    Description:
    Obtains the number of non-zeros in A.
  • mosek.Task.getnumcon

    Syntax:

     

    public void getnumcon (int[] numcon)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    numcon (output)
    Number of constraints.
    Description:
    Obtains the number of constraints.
  • mosek.Task.getnumcone

    Syntax:

     

    public void getnumcone (int[] numcone)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    numcone (output)
    Number conic constraints.
    Description:
    Obtains the number of cones.
  • mosek.Task.getnumconemem

    Syntax:

     

    public void getnumconemem (
        int k,
        int[] nummem)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getnumintvar (int[] numintvar)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getnumparam (
        int partype,
        int[] numparam)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getnumqconnz (
        int i,
        int[] numqcnz)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getnumqobjnz (int[] numqonz)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    numqonz (output)
    Number of non-zero elements in [[MathCmd 25]].
    Description:
    Obtains the number of non-zero quadratic terms in the objective.
  • mosek.Task.getnumvar

    Syntax:

     

    public void getnumvar (int[] numvar)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    numvar (output)
    Number of variables.
    Description:
    Obtains the number of variables.
  • mosek.Task.getobjname

    Syntax:

     

    public void getobjname (
        int[] len,
        StringBuffer objname)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getobjsense (int[] sense)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    sense (output)
    The returned objective sense.
    Description:
    Gets the objective sense of the task.
    See also:

     

    Task.putobjsense

    Sets the objective sense.

  • mosek.Task.getparammax

    Syntax:

     

    public void getparammax (
        int partype,
        int[] parammax)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    partype (input)
    Parameter type.
    parammax (input)
    Description:
    Obtains the maximum index of a parameter of a given type plus 1.
  • mosek.Task.getparamname

    Syntax:

     

    public void getparamname (
        int partype,
        int param,
        StringBuffer parname)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    partype (input)
    Parameter type.
    param (input)
    Which parameter.
    parname (output)
    Parameter name.
    Description:
    Obtains the name for a parameter param of type partype.
  • mosek.Task.getprimalobj

    Syntax:

     

    public void getprimalobj (
        int whichsol,
        double[] primalobj)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    primalobj (output)
    Objective value corresponding to the primal solution.
    Description:
    Obtains the primal objective value for a solution.
  • mosek.Task.getprobtype

    Syntax:

     

    public void getprobtype (int[] probtype)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getqconk (
        int k,
        int[] qcsurp,
        int[] numqcnz,
        int[] qcsubi,
        int[] qcsubj,
        double[] qcval)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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.
    numqcnz (output)
    Number of quadratic terms. See (5.8.4).
    qcsubi (output)
    i subscripts for [[MathCmd 83]]. See (5.8.4).
    qcsubj (output)
    j subscripts for [[MathCmd 83]]. See (5.8.4).
    qcval (output)
    Numerical value for [[MathCmd 83]].
    Description:
    Obtains all the quadratic terms in a constraint. The quadratic terms are stored sequentially qcsubi, qcsubj, and qcval.
  • mosek.Task.getqobj

    Syntax:

     

    public void getqobj (
        int[] qosurp,
        int[] numqonz,
        int[] qosubi,
        int[] qosubj,
        double[] qoval)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getqobjij (
        int i,
        int j,
        double[] qoij)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getreducedcosts (
        int whichsol,
        int first,
        int last,
        double[] redcosts)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    first (input)
    See formula (13.10.5) for the definition.
    last (input)
    See formula (13.10.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.10.5)
  • mosek.Task.getsolution

    Syntax:

     

    public void getsolution (
        int whichsol,
        int[] prosta,
        int[] solsta,
        int[] skc,
        int[] skx,
        int[] skn,
        double[] xc,
        double[] xx,
        double[] y,
        double[] slc,
        double[] suc,
        double[] slx,
        double[] sux,
        double[] snx)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 559]]).
    suc (output)
    Dual variables corresponding to the upper bounds on the constraints ([[MathCmd 560]]).
    slx (output)
    Dual variables corresponding to the lower bounds on the variables ([[MathCmd 561]]).
    sux (output)
    Dual variables corresponding to the upper bounds on the variables ([[MathCmd 562]]).
    snx (output)
    Dual variables corresponding to the conic constraints on the variables ([[MathCmd 563]]).
    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.10.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.10.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 559]].

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

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

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

    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:

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

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

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

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

     

    public void getsolutioni (
        int accmode,
        int i,
        int whichsol,
        int[] sk,
        double[] x,
        double[] sl,
        double[] su,
        double[] sn)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getsolutioninf (
        int whichsol,
        int[] prosta,
        int[] solsta,
        double[] primalobj,
        double[] maxpbi,
        double[] maxpcni,
        double[] maxpeqi,
        double[] maxinti,
        double[] dualobj,
        double[] maxdbi,
        double[] maxdcni,
        double[] maxdeqi)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getsolutionslice (
        int whichsol,
        int solitem,
        int first,
        int last,
        double[] values)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 570]] 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.10.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.10.9)

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

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

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

    Env.solitem.slc: The variable values return [[MathCmd 559]].

    Env.solitem.suc: The variable values return [[MathCmd 560]].

    Env.solitem.slx: The variable values return [[MathCmd 561]].

    Env.solitem.sux: The variable values return [[MathCmd 562]].

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

    This introduces one additional dual variable [[MathCmd 563]]. This variable can be acceded by selecting solitem as Env.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:

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

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

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

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

     

    public void getsolutionstatus (
        int whichsol,
        int[] prosta,
        int[] solsta)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void getsolutionstatuskeyslice (
        int accmode,
        int whichsol,
        int first,
        int last,
        int[] sk)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 570]] 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:

     

    public void getstrparam (
        int param,
        int[] len,
        StringBuffer parvalue)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    param (input)
    Which parameter.
    len (output)
    The length of the parameter value.
    parvalue (output)
    If this is not NULL, the parameter value is stored here.
    Description:
    Obtains the value of a string parameter.
  • mosek.Task.getsymbcon

    Syntax:

     

    public void getsymbcon (
        int i,
        int maxlen,
        StringBuffer name,
        int[] value)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    i (input)
    Index.
    maxlen (input)
    The length of the buffer pointed to by the value argument.
    name (output)
    Name of the ith symbolic constant.
    value (output)
    The corresponding value.
    Description:
    Obtains the name and corresponding value for the ith symbolic constant.
  • mosek.Task.gettaskname

    Syntax:

     

    public void gettaskname (
        int[] len,
        StringBuffer taskname)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getvarbranchdir (
        int j,
        int[] direction)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    j (input)
    Index of the variable.
    direction (output)
    The branching direction assigned to variable j.
    Description:
    Obtains the branching direction for a given variable j.
  • mosek.Task.getvarbranchorder

    Syntax:

     

    public void getvarbranchorder (
        int j,
        int[] priority,
        int[] direction)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    j (input)
    Index of the variable.
    priority (output)
    The branching priority assigned to variable j.
    direction (output)
    The preferred branching direction for variable j.
    Description:
    Obtains the branching priority and direction for a given variable j.
  • mosek.Task.getvarbranchpri

    Syntax:

     

    public void getvarbranchpri (
        int j,
        int[] priority)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getvarname (
        int i,
        StringBuffer name)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    i (input)
    Index.
    name (output)
    Is assigned the required name.
    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:

     

    public void getvartype (
        int j,
        int[] vartype)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void getvartypelist (
        int[] subj,
        int[] vartype)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void initbasissolve (int[] basis)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    basis (output)

    The array of basis indexes to use.

    The array is interpreted as follows: If [[MathCmd 580]], then [[MathCmd 581]] is in the basis at position i, otherwise [[MathCmd 582]] 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:

     

    public void inputdata (
        int maxnumcon,
        int maxnumvar,
        double[] c,
        double cfix,
        int[] aptrb,
        int[] aptre,
        int[] asub,
        double[] aval,
        int[] bkc,
        double[] blc,
        double[] buc,
        int[] bkx,
        double[] blx,
        double[] bux)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void isdouparname (
        String parname,
        int[] param)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void isintparname (
        String parname,
        int[] param)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void isstrparname (
        String parname,
        int[] param)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

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

    Syntax:

     

    public void linkfiletotaskstream (
        int whichstream,
        String filename,
        int append)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void makesolutionstatusunknown (int whichsol)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void optimize ()
        throws mosek.Error,
               mosek.Warning;
    
    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.

    Env.iparam.optimizer
  • mosek.Task.optimizeconcurrent

    Syntax:

     

    public void optimizeconcurrent (Task[] taskarray)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 583]] 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 (Env.iparam, Env.dparam and Env.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:

     

    public void optimizetrm (int[] trmcode)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    trmcode (output)
    Is either Env.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:

     

    public void primalsensitivity (
        int[] subi,
        int[] marki,
        int[] subj,
        int[] markj,
        double[] leftpricei,
        double[] rightpricei,
        double[] leftrangei,
        double[] rightrangei,
        double[] leftpricej,
        double[] rightpricej,
        double[] leftrangej,
        double[] rightrangej)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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] = Env.mark.up the upper bound of constraint subi[i] is analyzed, and if marki[i] = Env.mark.lo the lower bound is analyzed. If subi[i] is an equality constraint, either Env.mark.lo or Env.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.10.11)

    Suppose that

                        numi = 1;
                        subi = [0];
                        marki = [Env.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.10.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] = Env.mark.up the upper bound of constraint subi[j] is analyzed, and if markj[j] = Env.mark.lo the lower bound is analyzed. If subi[j] is an equality constraint, either Env.mark.lo or Env.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 Env.iparam.sensitivity_type.

    See also:

     

    Task.dualsensitivity

    Performs sensitivity analysis on objective coefficients.

    Task.sensitivityreport

    Creates a sensitivity report.

    Env.iparam.sensitivity_type
    Env.iparam.log_sensitivity
    Env.iparam.log_sensitivity_opt
  • mosek.Task.probtypetostr

    Syntax:

     

    public void probtypetostr (
        int probtype,
        StringBuffer str)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    probtype (input)
    Problem type.
    str (output)
    String corresponding to the problem type key probtype.
    Description:
    Obtains a string containing the name of a problem type given.
  • mosek.Task.prostatostr

    Syntax:

     

    public void prostatostr (
        int prosta,
        StringBuffer str)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    prosta (input)
    Problem status.
    str (output)
    String corresponding to the status key prosta.
    Description:
    Obtains a string containing the name of a problem status given.
  • mosek.Task.putaij

    Syntax:

     

    public void putaij (
        int i,
        int j,
        double aij)
        throws mosek.Error,
               mosek.Warning;
    
    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 543]].
    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:

     

    public void putaijlist (
        int[] subi,
        int[] subj,
        double[] valij)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 543]].
    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 543]] 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:

     

    public void putavec (
        int accmode,
        int i,
        int[] asub,
        double[] aval)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    accmode (input)
    Defines whether to replace a column or a row.
    i (input)
    If accmode equals Env.accmode.con, then i is a constraint index. Otherwise it is a column index.
    asub (input)
    Index of the [[MathCmd 543]] values that should be changed.
    aval (input)
    New [[MathCmd 543]] 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:

     

    public void putaveclist (
        int accmode,
        int[] sub,
        int[] ptrb,
        int[] ptre,
        int[] asub,
        double[] aval)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 Env.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:

     

    public void putbound (
        int accmode,
        int i,
        int bk,
        double bl,
        double bu)
        throws mosek.Error,
               mosek.Warning;
    
    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 Env.dparam.data_tol_bound_inf it is considered infinite and the bound key is changed accordingly. If a bound value is numerically larger than Env.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:

     

    public void putboundlist (
        int accmode,
        int[] sub,
        int[] bk,
        double[] bl,
        double[] bu)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    accmode (input)
    Defines whether bounds for constraints (Env.accmode.con) or variables (Env.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.

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

    Syntax:

     

    public void putboundslice (
        int con,
        int first,
        int last,
        int[] bk,
        double[] bl,
        double[] bu)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    con (input)
    Defines whether bounds for constraints (Env.accmode.con) or variables (Env.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.

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

    Syntax:

     

    public void putcfix (double cfix)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void putcj (
        int j,
        double cj)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    j (input)
    Index of the variable for which c should be changed.
    cj (input)
    New value of [[MathCmd 81]].
    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:

     

    public void putclist (
        int[] subj,
        double[] val)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void putcone (
        int k,
        int conetype,
        double conepar,
        int[] submem)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void putdouparam (
        int param,
        double parvalue)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void putintparam (
        int param,
        int parvalue)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void putmaxnumanz (int maxnumanz)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

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

    Syntax:

     

    public void putmaxnumcon (int maxnumcon)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putmaxnumcone (int maxnumcone)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putmaxnumqnz (int maxnumqnz)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putmaxnumvar (int maxnumvar)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putnadouparam (
        String paramname,
        double parvalue)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putnaintparam (
        String paramname,
        int parvalue)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putname (
        int whichitem,
        int i,
        String name)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putnastrparam (
        String paramname,
        String parvalue)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putobjname (String objname)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void putobjsense (int sense)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

     

    Task.getobjsense

    Gets the objective sense.

  • mosek.Task.putparam

    Syntax:

     

    public void putparam (
        String parname,
        String parvalue)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putqcon (
        int[] qcsubk,
        int[] qcsubi,
        int[] qcsubj,
        double[] qcval)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    qcsubk (input)
    k subscripts for [[MathCmd 83]]. See (5.8.4).
    qcsubi (input)
    i subscripts for [[MathCmd 83]]. See (5.8.4).
    qcsubj (input)
    j subscripts for [[MathCmd 83]]. See (5.8.4).
    qcval (input)
    Numerical value for [[MathCmd 83]].
    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.10.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.10.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.10.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:

     

    public void putqconk (
        int k,
        int[] qcsubi,
        int[] qcsubj,
        double[] qcval)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    k (input)
    The constraint in which new the Q elements are inserted.
    qcsubi (input)
    i subscripts for [[MathCmd 83]]. See (5.8.4).
    qcsubj (input)
    j subscripts for [[MathCmd 83]]. See (5.8.4).
    qcval (input)
    Numerical value for [[MathCmd 83]].
    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.10.16)

    It is assumed that [[MathCmd 26]] is symmetric, i.e. [[MathCmd 616]], and therefore, only the values of [[MathCmd 617]] 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 617]] 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:

     

    public void putqobj (
        int[] qosubi,
        int[] qosubj,
        double[] qoval)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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.10.17)

    It is assumed that [[MathCmd 25]] is symmetric, i.e. [[MathCmd 626]], and therefore, only the values of [[MathCmd 627]] 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 627]] 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:

     

    public void putqobjij (
        int i,
        int j,
        double qoij)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putsolution (
        int whichsol,
        int[] skc,
        int[] skx,
        int[] skn,
        double[] xc,
        double[] xx,
        double[] y,
        double[] slc,
        double[] suc,
        double[] slx,
        double[] sux,
        double[] snx)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 559]]).
    suc (input)
    Dual variables corresponding to the upper bounds on the constraints ([[MathCmd 560]]).
    slx (input)
    Dual variables corresponding to the lower bounds on the variables ([[MathCmd 561]]).
    sux (input)
    Dual variables corresponding to the upper bounds on the variables ([[MathCmd 562]]).
    snx (input)
    Dual variables corresponding to the conic constraints on the variables ([[MathCmd 563]]).
    Description:
    Inserts a solution into the task.
  • mosek.Task.putsolutioni

    Syntax:

     

    public void putsolutioni (
        int accmode,
        int i,
        int whichsol,
        int sk,
        double x,
        double sl,
        double su,
        double sn)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putsolutionyi (
        int i,
        int whichsol,
        double y)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putstrparam (
        int param,
        String parvalue)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void puttaskname (String taskname)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void putvarbranchorder (
        int j,
        int priority,
        int direction)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putvartype (
        int j,
        int vartype)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void putvartypelist (
        int[] subj,
        int[] vartype)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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 638]] is assigned the variable type [[MathCmd 639]].

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

  • mosek.Task.readbranchpriorities

    Syntax:

     

    public void readbranchpriorities (String filename)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void readdata (String filename)
        throws mosek.Error,
               mosek.Warning;
    
    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 Env.sparam.data_file_name.
    Description:

    Reads an optimization data and associated data from a file.

    The data file format is determined by the Env.iparam.read_data_format parameter. By default the parameter has the value Env.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.

    Env.iparam.read_data_format
  • mosek.Task.readparamfile

    Syntax:

     

    public void readparamfile ()
        throws mosek.Error,
               mosek.Warning;
    
    Description:
    Reads a parameter file.
  • mosek.Task.readsolution

    Syntax:

     

    public void readsolution (
        int whichsol,
        String filename)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void readsummary (int whichstream)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void relaxprimal (
        TaskContainer relaxedtask,
        double[] wlc,
        double[] wuc,
        double[] wlx,
        double[] wux)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    relaxedtask (output)
    The returned task.
    wlc (input/output)
    Weights associated with lower bounds on the activity of constraints. If negative, the bound is strictly enforced, i.e. if [[MathCmd 640]], then [[MathCmd 367]] 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 642]], then [[MathCmd 368]] 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 644]] then [[MathCmd 645]] 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 646]] then [[MathCmd 647]] is fixed to zero. On return wux[i] contains the relaxed bound.
    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.10.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.10.19)

    Hence, the function adds so-called elasticity variables to all the constraints which relax the constraints, for instance [[MathCmd 367]] and [[MathCmd 368]] relax [[MathCmd 372]] and [[MathCmd 653]] respectively. It should be obvious that (13.10.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 376]], [[MathCmd 377]], [[MathCmd 378]] and [[MathCmd 379]] 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.10.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 640]] then [[MathCmd 367]] is fixed to zero.

    Now let [[MathCmd 382]] be the optimal objective value to (13.10.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.10.20)

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

    The parameter Env.iparam.feasrepair_optimize controls whether the function returns the problem (13.10.19) or the problem (13.10.20).The parameter can take one of the following values.

    Env.feasrepairtype.optimize_none

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

    Env.feasrepairtype.optimize_penalty

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

    Env.feasrepairtype.optimize_combined

    : The returned task relaxedtask contains problem (13.10.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 368]] ([[MathCmd 665]]) is named “NAME_CON*up” (“NAME_VAR*up”).
    • The variable corresponding to [[MathCmd 367]] ([[MathCmd 369]]) is named “NAME_CON*lo” (“NAME_VAR*lo”).

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

    Please note that if [[MathCmd 668]] or [[MathCmd 669]] 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:

     

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

    Syntax:

     

    public void remove (
        int accmode,
        int[] sub)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void removecone (int k)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void resizetask (
        int maxnumcon,
        int maxnumvar,
        int maxnumcone,
        int maxnumanz,
        int maxnumqnz)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void sensitivityreport (int whichstream)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    whichstream (input)
    Index of the stream.
    Description:
    Reads a sensitivity format file from a location given by Env.sparam.sensitivity_file_name and writes the result to the stream whichstream. If Env.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.

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

    Syntax:

     

    public void set_Stream (
        int whichstream,
        mosek.Stream stream)
    
    Arguments:

     

    whichstream
    Index of the stream.
    stream
    The stream object to attach. To detach all objects, let this be null.
    Description:
    Attach a stream call-back handler.
  • mosek.Task.setdefaults

    Syntax:

     

    public void setdefaults ()
        throws mosek.Error,
               mosek.Warning;
    
    Description:
    Resets all the parameters to their default values.
  • mosek.Task.sktostr

    Syntax:

     

    public void sktostr (
        int sk,
        StringBuffer str)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    sk (input)
    A valid status key.
    str (output)
    String corresponding to the status key sk.
    Description:
    Obtains an explanatory string corresponding to a status key.
  • mosek.Task.solstatostr

    Syntax:

     

    public void solstatostr (
        int solsta,
        StringBuffer str)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

    solsta (input)
    Solution status.
    str (output)
    String corresponding to the solution status solsta.
    Description:
    Obtains an explanatory string corresponding to a solution status.
  • mosek.Task.solutiondef

    Syntax:

     

    public void solutiondef (
        int whichsol,
        int[] isdef)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    whichsol (input)
    Selects a solution.
    isdef (output)
    Is non-zero if the requested solution is defined.
    Description:
    Checks whether a solution is defined.
  • mosek.Task.solutionsummary

    Syntax:

     

    public void solutionsummary (int whichstream)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void solvewithbasis (
        int transp,
        int[] numnz,
        int[] sub,
        double[] val)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    Arguments:

     

    transp (input)
    If this argument is non-zero, then (13.10.22) is solved. Otherwise the system (13.10.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 670]].
    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 670]]. 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 673]] if b[i]=0. As output val is the vector [[MathCmd 670]].

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

    Description:

    If a basic solution is available, then exactly [[MathCmd 675]] basis variables are defined. These [[MathCmd 675]] 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.10.21)

    or the system

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

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

    In order to make sense of the solution [[MathCmd 670]] 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 250]] 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 683]] 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 670]] 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:

     

    public void startstat ()
        throws mosek.Error,
               mosek.Warning;
    
    Description:
    Starts the statistics file.
  • mosek.Task.stopstat

    Syntax:

     

    public void stopstat ()
        throws mosek.Error,
               mosek.Warning;
    
    Description:
    Stops the statistics file.
  • mosek.Task.strtoconetype

    Syntax:

     

    public void strtoconetype (
        String str,
        int[] conetype)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void strtosk (
        String str,
        int[] sk)
        throws mosek.Error,
               mosek.Warning,
               mosek.ArrayLengthException;
    
    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:

     

    public void undefsolution (int whichsol)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void writebranchpriorities (String filename)
        throws mosek.Error,
               mosek.Warning;
    
    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:

     

    public void writedata (String filename)
        throws mosek.Error,
               mosek.Warning;
    
    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 Env.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 C.

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

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

    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 Env.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 Env.iparam.write_generic_names parameter to Env.onoffkey.on.

    See also:

     

    Task.readdata

    Reads problem data from a file.

    Env.iparam.write_data_format
  • mosek.Task.writeparamfile

    Syntax:

     

    public void writeparamfile (String filename)
        throws mosek.Error,
               mosek.Warning;
    
    Arguments:

     

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

    Syntax:

     

    public void writesolution (
        int whichsol,
        String filename)
        throws mosek.Error,
               mosek.Warning;
    
    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.11. Class mosek.Warning

Derived from:

mosek.Exception

Description:

This is an exception class representing MOSEK warnings.

13.11.1. Constructors

  • mosek.Warning

    Syntax: 

    public Warning (int 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:42:35 2009