lp                  package:lpSolve                  R Documentation

_L_i_n_e_a_r _a_n_d _I_n_t_e_g_e_r _P_r_o_g_r_a_m_m_i_n_g

_D_e_s_c_r_i_p_t_i_o_n:

     Interface to lp_solve linear/integer programming system

_U_s_a_g_e:

     lp (direction = "min", objective.in, const.mat, const.dir, const.rhs,
             transpose.constraints = TRUE, int.vec, presolve=0, compute.sens=0,
             binary.vec, all.int=FALSE, all.bin=FALSE, scale = 196, dense.const, 
             num.bin.solns=1, use.rw=FALSE)

_A_r_g_u_m_e_n_t_s:

direction: Character string giving direction of optimization: "min"
          (default) or "max."

objective.in: Numeric vector of coefficients of objective function

const.mat: Matrix of numeric constraint coefficients, one row  per
          constraint, one column per variable (unless
          transpose.constraints =  FALSE; see below).

const.dir: Vector of character strings giving the direction of  the
          constraint: each value should be one of "<," "<=," "=," "==,"
          ">," or ">=". (In each pair the two values are identical.)

const.rhs: Vector of numeric values for the right-hand sides of  the
          constraints.

transpose.constraints: By default each constraint occupies a row  of
          const.mat, and that matrix needs to be transposed before
          being passed  to the optimizing code.  For very large
          constraint matrices it may be wiser  to construct the
          constraints in a matrix column-by-column. In that case set 
          transpose.constraints to FALSE.

 int.vec: Numeric vector giving the indices of variables that are 
          required to be integer. The length of this vector will
          therefore be the  number of integer variables.

presolve: Numeric: presolve? Default 0 (no); any non-zero value means
          "yes." Currently ignored.

compute.sens: Numeric: compute sensitivity? Default 0 (no); any
          non-zero value means "yes."

binary.vec: Numeric vector like int.vec giving the indices of variables
           that are required to be binary.

 all.int: Logical: should all variables be integer? Default: FALSE.

 all.bin: Logical: should all variables be binary? Default: FALSE.

   scale: Integer: value for lpSolve scaling. Details can be found in
          the lpSolve documentation. Set to 0 for no scaling. Default:
          196

dense.const: Three column dense constraint array. This is ignored if
          const.mat is supplied. Otherwise the columns are constraint
          number, column number, and value; there should be one row for
          each non-zero entry in the constraint matrix.

num.bin.solns: Integer: if all.bin=TRUE, the user can request up to
          num.bin.solns optimal solutions to be returned.

  use.rw: Logical: if TRUE and num.bin.solns > 1, write the lp out to a
          file and read it back in for each solution after the first.
          This is just to defeat a bug somewhere. Although the default
          is FALSE, we recommend you set this to TRUE if you need
          num.bin.solns > 1, until the bug is found.

_D_e_t_a_i_l_s:

     This function calls the lp_solve 5.5 solver. That system has many
     options not supported here. The current version is maintained at
     <URL: ftp://ftp.es.ele.tue.nl/pub/lp_solve>

_V_a_l_u_e:

     An lp object. See 'lp.object' for details.

_A_u_t_h_o_r(_s):

     Sam Buttrey, buttrey@nps.edu

_S_e_e _A_l_s_o:

     'lp.assign', 'lp.transport'

_E_x_a_m_p_l_e_s:

     #
     # Set up problem: maximize
     #   x1 + 9 x2 +   x3 subject to
     #   x1 + 2 x2 + 3 x3  <= 9
     # 3 x1 + 2 x2 + 2 x3 <= 15
     #
     f.obj <- c(1, 9, 3)
     f.con <- matrix (c(1, 2, 3, 3, 2, 2), nrow=2, byrow=TRUE)
     f.dir <- c("<=", "<=")
     f.rhs <- c(9, 15)
     #
     # Now run.
     #
     lp ("max", f.obj, f.con, f.dir, f.rhs)
     ## Not run: Success: the objective function is 40.5
     lp ("max", f.obj, f.con, f.dir, f.rhs)$solution
     ## Not run: [1] 0.0 4.5 0.0
     #
     # Get sensitivities
     #
     lp ("max", f.obj, f.con, f.dir, f.rhs, compute.sens=TRUE)$sens.coef.from
     ## Not run: [1] -1e+30  2e+00 -1e+30
     lp ("max", f.obj, f.con, f.dir, f.rhs, compute.sens=TRUE)$sens.coef.to  
     ## Not run: [1] 4.50e+00 1.00e+30 1.35e+01
     #
     # Right now the dual values for the constraints and the variables are
     # combined, constraints coming first. So in this example...
     #
     lp ("max", f.obj, f.con, f.dir, f.rhs, compute.sens=TRUE)$duals     
     ## Not run: [1]   4.5   0.0  -3.5   0.0 -10.5
     #
     # ...the duals of the constraints are 4.5 and 0, and of the variables,
     # -3.5, 0.0, -10.5. Here are the lower and upper limits on these:
     #
     lp ("max", f.obj, f.con, f.dir, f.rhs, compute.sens=TRUE)$duals.from
     ## Not run: [1]  0e+00 -1e+30 -1e+30 -1e+30 -6e+00
     lp ("max", f.obj, f.con, f.dir, f.rhs, compute.sens=TRUE)$duals.to  
     ## Not run: [1] 1.5e+01 1.0e+30 3.0e+00 1.0e+30 3.0e+00
     #
     # Run again, this time requiring that all three variables be integer
     #
     lp ("max", f.obj, f.con, f.dir, f.rhs, int.vec=1:3)
     ## Not run: Success: the objective function is 37
     lp ("max", f.obj, f.con, f.dir, f.rhs, int.vec=1:3)$solution
     ## Not run: [1] 1 4 0
     #
     # You can get sensitivities in the integer case, but they're harder to
     # interpret.
     #
     lp ("max", f.obj, f.con, f.dir, f.rhs, int.vec=1:3, compute.sens=TRUE)$duals
     ## Not run: [1] 1 0 0 7 0
     #
     # Here's an example in which we want more than one solution to a problem
     # in which all variables are binary: the 8-queens problem.
     #
     chess.obj <- rep (1, 64)
     q8 <- make.q8 ()
     chess.dir <- rep (c("=", "<"), c(16, 26))
     chess.rhs <- rep (1, 42)
     lp ('max', chess.obj, , chess.dir, chess.rhs, dense.const = q8, 
         all.bin=TRUE, num.bin.solns=3)

