text: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  /*                                                                           */
  /*                  This file is part of the program and library             */
  /*         SCIP --- Solving Constraint Integer Programs                      */
  /*                                                                           */
  /*    Copyright (C) 2002-2018 Konrad-Zuse-Zentrum                            */
  /*                            fuer Informationstechnik Berlin                */
  /*                                                                           */
  /*  SCIP is distributed under the terms of the ZIB Academic License.         */
  /*                                                                           */
  /*  You should have received a copy of the ZIB Academic License              */
  /*  along with SCIP; see the file COPYING. If not email to scip@zib.de.      */
  /*                                                                           */
  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
  /**@file   lpi.h
   * @ingroup LPIS
   * @brief  interface methods for specific LP solvers
   * @author Tobias Achterberg
   * @author Marc Pfetsch
   *
   */
  
  /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
  
  #ifndef __SCIP_LPI_H__
  #define __SCIP_LPI_H__
  
  
  #include "scip/def.h"
  #include "blockmemshell/memory.h"
  #include "scip/type_retcode.h"
  #include "lpi/type_lpi.h"
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /**@addtogroup LPIS
   *
   * This file specifies a generic LP solver interface used by SCIP to create, modify, and solve linear programs of the
   * form
   *
   *   min/max   obj * x
   *      lhs <=   A * x  <= rhs
   *      lb  <=       x  <= ub
   *
   * and query information about the solution. Although it includes a few SCIP header files, e.g., because it uses SCIP's
   * return codes, it can be used independently of any SCIP instance.
   *
   * The basis status for (column) variables are as follows:
   * - If x_j = lb, then j is at its lower bound (SCIP_BASESTAT_LOWER).
   * - If x_j = ub, then j is at its lower bound (SCIP_BASESTAT_UPPER).
   * - If x_j is in the basis, it has SCIP_BASESTAT_BASIC status.
   * - If x_j is free and non-basic, it has SCIP_BASESTAT_ZERO status.
   *
   * The basis status for (row) slack variables are:
   * - If (A * x)_i = lhs, then i is at its lower bound (SCIP_BASESTAT_LOWER).
   * - If (A * x)_i = rhs, then i is at its upper bound (SCIP_BASESTAT_UPPER).
   * - If the slack variable for row i is basic, it has SCIP_BASESTAT_BASIC status.
   *
   * If the solvers use their status differently, those status codes have to be corrected.
   *
   * In the methods accessing information about the (inverse of the) basis matrix, the interface assumes the following
   * column-oriented format: slack variables of rows have coefficient +1 and the basis matrix is a regular m times m
   * submatrix of (A,I), where m is the number of rows and I is the identity matrix. This means that if, internally, the
   * LP solver uses coefficients -1 for some of the slack variables, then every row associated with a slack variable whose
   * coefficient is -1 should be negated in order to return the result in terms of the LP interface definition.
   *
   * The creation of a new LP should always be done in the following ways: Either one can use SCIPlpiLoadColLP() or one
   * first adds empty columns or rows. Then the matrix entries can be added by adding columns and rows, respectively.
   * Adding matrix entries for a row or column that have not been added before will result in an error.
   *
   * The handling of the objective limit is as follows, if supported by the LP-solver: If the objective is larger than the
   * objective limit for minimization problems or smaller than the objective limit for maximization problems, the solution
   * process can be stopped. This naturally occurs in a branch-and-bound process, where the objective limit is set to the
   * value of the best solution found so far. If the problem is a minimization problem and we use the dual simplex, the
   * dual feasible solutions are maximized. If their value are larger than the objective limit, the process can be
   * stopped. In this case, no feasible integer solution can be found in the corresponding branch.
   *
   * Some LP-solvers also support the opposite setting, but this can easily be checked after the solution process (i.e.,
   * for a minimization problem a check whether the optimal value is smaller than the limit). Note that this check can
   * only be determined at the end of the optimization. Thus, we do not support this.
   *
   * @{
   */
  
  /*
   * Miscellaneous Methods
   */
  
  /**@name Miscellaneous Methods */
  /**@{ */
  
  /** gets name and version of LP solver */
  EXTERN
  const char* SCIPlpiGetSolverName(
     void
     );
  
  /** gets description of LP solver (developer, webpage, ...) */
  EXTERN
  const char* SCIPlpiGetSolverDesc(
     void
     );
  
  /** gets pointer for LP solver - use only with great care
   *
   *  The behavior of this function depends on the solver and its use is
   *  therefore only recommended if you really know what you are
   *  doing. In general, it returns a pointer to the LP solver object.
   */
  EXTERN
  void* SCIPlpiGetSolverPointer(
     SCIP_LPI*             lpi                 /**< pointer to an LP interface structure */
     );
  
  /** pass integrality information about variables to the solver */
  EXTERN
  SCIP_RETCODE SCIPlpiSetIntegralityInformation(
     SCIP_LPI*             lpi,                /**< pointer to an LP interface structure */
     int                   ncols,              /**< length of integrality array */
     int*                  intInfo             /**< integrality array (0: continuous, 1: integer). May be NULL iff ncols is 0.  */
     );
  
  /**@} */
  
  
  
  
  /*
   * LPI Creation and Destruction Methods
   */
  
  /**@name LPI Creation and Destruction Methods */
  /**@{ */
  
  /** creates an LP problem object */
  EXTERN
  SCIP_RETCODE SCIPlpiCreate(
     SCIP_LPI**            lpi,                /**< pointer to an LP interface structure */
     SCIP_MESSAGEHDLR*     messagehdlr,        /**< message handler to use for printing messages, or NULL */
     const char*           name,               /**< problem name */
     SCIP_OBJSEN           objsen              /**< objective sense */
     );
  
  /** deletes an LP problem object */
  EXTERN
  SCIP_RETCODE SCIPlpiFree(
     SCIP_LPI**            lpi                 /**< pointer to an LP interface structure */
     );
  
  /**@} */
  
  
  
  
  /*
   * Modification Methods
   */
  
  /**@name Modification Methods */
  /**@{ */
  
  /** copies LP data with column matrix into LP solver */
  EXTERN
  SCIP_RETCODE SCIPlpiLoadColLP(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_OBJSEN           objsen,             /**< objective sense */
     int                   ncols,              /**< number of columns */
     const SCIP_Real*      obj,                /**< objective function values of columns */
     const SCIP_Real*      lb,                 /**< lower bounds of columns */
     const SCIP_Real*      ub,                 /**< upper bounds of columns */
     char**                colnames,           /**< column names, or NULL */
     int                   nrows,              /**< number of rows */
     const SCIP_Real*      lhs,                /**< left hand sides of rows */
     const SCIP_Real*      rhs,                /**< right hand sides of rows */
     char**                rownames,           /**< row names, or NULL */
     int                   nnonz,              /**< number of nonzero elements in the constraint matrix */
     const int*            beg,                /**< start index of each column in ind- and val-array */
     const int*            ind,                /**< row indices of constraint matrix entries */
     const SCIP_Real*      val                 /**< values of constraint matrix entries */
     );
  
  /** adds columns to the LP
   *
   *  @note ind array is not checked for duplicates, problems may appear if indices are added more than once
   */
  EXTERN
  SCIP_RETCODE SCIPlpiAddCols(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   ncols,              /**< number of columns to be added */
     const SCIP_Real*      obj,                /**< objective function values of new columns */
     const SCIP_Real*      lb,                 /**< lower bounds of new columns */
     const SCIP_Real*      ub,                 /**< upper bounds of new columns */
     char**                colnames,           /**< column names, or NULL */
     int                   nnonz,              /**< number of nonzero elements to be added to the constraint matrix */
     const int*            beg,                /**< start index of each column in ind- and val-array, or NULL if nnonz == 0 */
     const int*            ind,                /**< row indices of constraint matrix entries, or NULL if nnonz == 0 */
     const SCIP_Real*      val                 /**< values of constraint matrix entries, or NULL if nnonz == 0 */
     );
  
  /** deletes all columns in the given range from LP */
  EXTERN
  SCIP_RETCODE SCIPlpiDelCols(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstcol,           /**< first column to be deleted */
     int                   lastcol             /**< last column to be deleted */
     );
  
  /** deletes columns from SCIP_LPI; the new position of a column must not be greater that its old position */
  EXTERN
  SCIP_RETCODE SCIPlpiDelColset(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  dstat               /**< deletion status of columns
                                                *   input:  1 if column should be deleted, 0 if not
                                                *   output: new position of column, -1 if column was deleted */
     );
  
  /** adds rows to the LP
   *
   *  @note ind array is not checked for duplicates, problems may appear if indices are added more than once
   */
  EXTERN
  SCIP_RETCODE SCIPlpiAddRows(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   nrows,              /**< number of rows to be added */
     const SCIP_Real*      lhs,                /**< left hand sides of new rows */
     const SCIP_Real*      rhs,                /**< right hand sides of new rows */
     char**                rownames,           /**< row names, or NULL */
     int                   nnonz,              /**< number of nonzero elements to be added to the constraint matrix */
     const int*            beg,                /**< start index of each row in ind- and val-array, or NULL if nnonz == 0 */
     const int*            ind,                /**< column indices of constraint matrix entries, or NULL if nnonz == 0 */
     const SCIP_Real*      val                 /**< values of constraint matrix entries, or NULL if nnonz == 0 */
     );
  
  /** deletes all rows in the given range from LP */
  EXTERN
  SCIP_RETCODE SCIPlpiDelRows(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstrow,           /**< first row to be deleted */
     int                   lastrow             /**< last row to be deleted */
     );
  
  /** deletes rows from SCIP_LPI; the new position of a row must not be greater that its old position */
  EXTERN
  SCIP_RETCODE SCIPlpiDelRowset(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  dstat               /**< deletion status of rows
                                                *   input:  1 if row should be deleted, 0 if not
                                                *   output: new position of row, -1 if row was deleted */
     );
  
  /** clears the whole LP */
  EXTERN
  SCIP_RETCODE SCIPlpiClear(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** changes lower and upper bounds of columns */
  EXTERN
  SCIP_RETCODE SCIPlpiChgBounds(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   ncols,              /**< number of columns to change bounds for */
     const int*            ind,                /**< column indices or NULL if ncols is zero */
     const SCIP_Real*      lb,                 /**< values for the new lower bounds or NULL if ncols is zero */
     const SCIP_Real*      ub                  /**< values for the new upper bounds or NULL if ncols is zero */
     );
  
  /** changes left and right hand sides of rows */
  EXTERN
  SCIP_RETCODE SCIPlpiChgSides(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   nrows,              /**< number of rows to change sides for */
     const int*            ind,                /**< row indices */
     const SCIP_Real*      lhs,                /**< new values for left hand sides */
     const SCIP_Real*      rhs                 /**< new values for right hand sides */
     );
  
  /** changes a single coefficient */
  EXTERN
  SCIP_RETCODE SCIPlpiChgCoef(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   row,                /**< row number of coefficient to change */
     int                   col,                /**< column number of coefficient to change */
     SCIP_Real             newval              /**< new value of coefficient */
     );
  
  /** changes the objective sense */
  EXTERN
  SCIP_RETCODE SCIPlpiChgObjsen(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_OBJSEN           objsen              /**< new objective sense */
     );
  
  /** changes objective values of columns in the LP */
  EXTERN
  SCIP_RETCODE SCIPlpiChgObj(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   ncols,              /**< number of columns to change objective value for */
     const int*            ind,                /**< column indices to change objective value for */
     const SCIP_Real*      obj                 /**< new objective values for columns */
     );
  
  /** multiplies a row with a non-zero scalar; for negative scalars, the row's sense is switched accordingly */
  EXTERN
  SCIP_RETCODE SCIPlpiScaleRow(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   row,                /**< row number to scale */
     SCIP_Real             scaleval            /**< scaling multiplier */
     );
  
  /** multiplies a column with a non-zero scalar; the objective value is multiplied with the scalar, and the bounds
   *  are divided by the scalar; for negative scalars, the column's bounds are switched
   */
  EXTERN
  SCIP_RETCODE SCIPlpiScaleCol(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   col,                /**< column number to scale */
     SCIP_Real             scaleval            /**< scaling multiplier */
     );
  
  /**@} */
  
  
  
  
  /*
   * Data Accessing Methods
   */
  
  /**@name Data Accessing Methods */
  /**@{ */
  
  /** gets the number of rows in the LP */
  EXTERN
  SCIP_RETCODE SCIPlpiGetNRows(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  nrows               /**< pointer to store the number of rows */
     );
  
  /** gets the number of columns in the LP */
  EXTERN
  SCIP_RETCODE SCIPlpiGetNCols(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  ncols               /**< pointer to store the number of cols */
     );
  
  /** gets the objective sense of the LP */
  EXTERN
  SCIP_RETCODE SCIPlpiGetObjsen(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_OBJSEN*          objsen              /**< pointer to store objective sense */
     );
  
  /** gets the number of nonzero elements in the LP constraint matrix */
  EXTERN
  SCIP_RETCODE SCIPlpiGetNNonz(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  nnonz               /**< pointer to store the number of nonzeros */
     );
  
  /** gets columns from LP problem object; the arrays have to be large enough to store all values;
   *  Either both, lb and ub, have to be NULL, or both have to be non-NULL,
   *  either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
   */
  EXTERN
  SCIP_RETCODE SCIPlpiGetCols(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstcol,           /**< first column to get from LP */
     int                   lastcol,            /**< last column to get from LP */
     SCIP_Real*            lb,                 /**< buffer to store the lower bound vector, or NULL */
     SCIP_Real*            ub,                 /**< buffer to store the upper bound vector, or NULL */
     int*                  nnonz,              /**< pointer to store the number of nonzero elements returned, or NULL */
     int*                  beg,                /**< buffer to store start index of each column in ind- and val-array, or NULL */
     int*                  ind,                /**< buffer to store row indices of constraint matrix entries, or NULL */
     SCIP_Real*            val                 /**< buffer to store values of constraint matrix entries, or NULL */
     );
  
  /** gets rows from LP problem object; the arrays have to be large enough to store all values.
   *  Either both, lhs and rhs, have to be NULL, or both have to be non-NULL,
   *  either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL.
   */
  EXTERN
  SCIP_RETCODE SCIPlpiGetRows(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstrow,           /**< first row to get from LP */
     int                   lastrow,            /**< last row to get from LP */
     SCIP_Real*            lhs,                /**< buffer to store left hand side vector, or NULL */
     SCIP_Real*            rhs,                /**< buffer to store right hand side vector, or NULL */
     int*                  nnonz,              /**< pointer to store the number of nonzero elements returned, or NULL */
     int*                  beg,                /**< buffer to store start index of each row in ind- and val-array, or NULL */
     int*                  ind,                /**< buffer to store column indices of constraint matrix entries, or NULL */
     SCIP_Real*            val                 /**< buffer to store values of constraint matrix entries, or NULL */
     );
  
  /** gets column names */
  EXTERN
  SCIP_RETCODE SCIPlpiGetColNames(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstcol,           /**< first column to get name from LP */
     int                   lastcol,            /**< last column to get name from LP */
     char**                colnames,           /**< pointers to column names (of size at least lastcol-firstcol+1) or NULL if namestoragesize is zero */
     char*                 namestorage,        /**< storage for col names or NULL if namestoragesize is zero */
     int                   namestoragesize,    /**< size of namestorage (if 0, -storageleft returns the storage needed) */
     int*                  storageleft         /**< amount of storage left (if < 0 the namestorage was not big enough) or NULL if namestoragesize is zero */
     );
  
  /** gets row names */
  EXTERN
  SCIP_RETCODE SCIPlpiGetRowNames(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstrow,           /**< first row to get name from LP */
     int                   lastrow,            /**< last row to get name from LP */
     char**                rownames,           /**< pointers to row names (of size at least lastrow-firstrow+1) or NULL if namestoragesize is zero */
     char*                 namestorage,        /**< storage for row names or NULL if namestoragesize is zero */
     int                   namestoragesize,    /**< size of namestorage (if 0, -storageleft returns the storage needed) */
     int*                  storageleft         /**< amount of storage left (if < 0 the namestorage was not big enough) or NULL if namestoragesize is zero */
     );
  
  /** gets objective coefficients from LP problem object */
  EXTERN
  SCIP_RETCODE SCIPlpiGetObj(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstcol,           /**< first column to get objective coefficient for */
     int                   lastcol,            /**< last column to get objective coefficient for */
     SCIP_Real*            vals                /**< array to store objective coefficients */
     );
  
  /** gets current bounds from LP problem object */
  EXTERN
  SCIP_RETCODE SCIPlpiGetBounds(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstcol,           /**< first column to get bounds for */
     int                   lastcol,            /**< last column to get bounds for */
     SCIP_Real*            lbs,                /**< array to store lower bound values, or NULL */
     SCIP_Real*            ubs                 /**< array to store upper bound values, or NULL */
     );
  
  /** gets current row sides from LP problem object */
  EXTERN
  SCIP_RETCODE SCIPlpiGetSides(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   firstrow,           /**< first row to get sides for */
     int                   lastrow,            /**< last row to get sides for */
     SCIP_Real*            lhss,               /**< array to store left hand side values, or NULL */
     SCIP_Real*            rhss                /**< array to store right hand side values, or NULL */
     );
  
  /** gets a single coefficient */
  EXTERN
  SCIP_RETCODE SCIPlpiGetCoef(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   row,                /**< row number of coefficient */
     int                   col,                /**< column number of coefficient */
     SCIP_Real*            val                 /**< pointer to store the value of the coefficient */
     );
  
  /**@} */
  
  
  
  
  /*
   * Solving Methods
   */
  
  /**@name Solving Methods */
  /**@{ */
  
  /** calls primal simplex to solve the LP */
  EXTERN
  SCIP_RETCODE SCIPlpiSolvePrimal(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** calls dual simplex to solve the LP */
  EXTERN
  SCIP_RETCODE SCIPlpiSolveDual(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** calls barrier or interior point algorithm to solve the LP with crossover to simplex basis */
  EXTERN
  SCIP_RETCODE SCIPlpiSolveBarrier(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_Bool             crossover           /**< perform crossover */
     );
  
  /** start strong branching - call before any strong branching */
  EXTERN
  SCIP_RETCODE SCIPlpiStartStrongbranch(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** end strong branching - call after any strong branching */
  EXTERN
  SCIP_RETCODE SCIPlpiEndStrongbranch(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** performs strong branching iterations on one @b fractional candidate */
  EXTERN
  SCIP_RETCODE SCIPlpiStrongbranchFrac(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   col,                /**< column to apply strong branching on */
     SCIP_Real             psol,               /**< fractional current primal solution value of column */
     int                   itlim,              /**< iteration limit for strong branchings */
     SCIP_Real*            down,               /**< stores dual bound after branching column down */
     SCIP_Real*            up,                 /**< stores dual bound after branching column up */
     SCIP_Bool*            downvalid,          /**< stores whether the returned down value is a valid dual bound;
                                                *   otherwise, it can only be used as an estimate value */
     SCIP_Bool*            upvalid,            /**< stores whether the returned up value is a valid dual bound;
                                                *   otherwise, it can only be used as an estimate value */
     int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
     );
  
  /** performs strong branching iterations on given @b fractional candidates */
  EXTERN
  SCIP_RETCODE SCIPlpiStrongbranchesFrac(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  cols,               /**< columns to apply strong branching on */
     int                   ncols,              /**< number of columns */
     SCIP_Real*            psols,              /**< fractional current primal solution values of columns */
     int                   itlim,              /**< iteration limit for strong branchings */
     SCIP_Real*            down,               /**< stores dual bounds after branching columns down */
     SCIP_Real*            up,                 /**< stores dual bounds after branching columns up */
     SCIP_Bool*            downvalid,          /**< stores whether the returned down values are valid dual bounds;
                                                *   otherwise, they can only be used as an estimate values */
     SCIP_Bool*            upvalid,            /**< stores whether the returned up values are a valid dual bounds;
                                                *   otherwise, they can only be used as an estimate values */
     int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
     );
  
  /** performs strong branching iterations on one candidate with @b integral value */
  EXTERN
  SCIP_RETCODE SCIPlpiStrongbranchInt(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   col,                /**< column to apply strong branching on */
     SCIP_Real             psol,               /**< current integral primal solution value of column */
     int                   itlim,              /**< iteration limit for strong branchings */
     SCIP_Real*            down,               /**< stores dual bound after branching column down */
     SCIP_Real*            up,                 /**< stores dual bound after branching column up */
     SCIP_Bool*            downvalid,          /**< stores whether the returned down value is a valid dual bound;
                                                *   otherwise, it can only be used as an estimate value */
     SCIP_Bool*            upvalid,            /**< stores whether the returned up value is a valid dual bound;
                                                *   otherwise, it can only be used as an estimate value */
     int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
     );
  
  /** performs strong branching iterations on given candidates with @b integral values */
  EXTERN
  SCIP_RETCODE SCIPlpiStrongbranchesInt(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  cols,               /**< columns to apply strong branching on */
     int                   ncols,              /**< number of columns */
     SCIP_Real*            psols,              /**< current integral primal solution values of columns */
     int                   itlim,              /**< iteration limit for strong branchings */
     SCIP_Real*            down,               /**< stores dual bounds after branching columns down */
     SCIP_Real*            up,                 /**< stores dual bounds after branching columns up */
     SCIP_Bool*            downvalid,          /**< stores whether the returned down values are valid dual bounds;
                                                *   otherwise, they can only be used as an estimate values */
     SCIP_Bool*            upvalid,            /**< stores whether the returned up values are a valid dual bounds;
                                                *   otherwise, they can only be used as an estimate values */
     int*                  iter                /**< stores total number of strong branching iterations, or -1; may be NULL */
     );
  /**@} */
  
  
  
  
  /*
   * Solution Information Methods
   */
  
  /**@name Solution Information Methods */
  /**@{ */
  
  /** returns whether a solve method was called after the last modification of the LP */
  EXTERN
  SCIP_Bool SCIPlpiWasSolved(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** gets information about primal and dual feasibility of the current LP solution */
  EXTERN
  SCIP_RETCODE SCIPlpiGetSolFeasibility(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_Bool*            primalfeasible,     /**< stores primal feasibility status */
     SCIP_Bool*            dualfeasible        /**< stores dual feasibility status */
     );
  
  /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point);
   *  this does not necessarily mean, that the solver knows and can return the primal ray
   */
  EXTERN
  SCIP_Bool SCIPlpiExistsPrimalRay(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point),
   *  and the solver knows and can return the primal ray
   */
  EXTERN
  SCIP_Bool SCIPlpiHasPrimalRay(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to be primal unbounded */
  EXTERN
  SCIP_Bool SCIPlpiIsPrimalUnbounded(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to be primal infeasible */
  EXTERN
  SCIP_Bool SCIPlpiIsPrimalInfeasible(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to be primal feasible */
  EXTERN
  SCIP_Bool SCIPlpiIsPrimalFeasible(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point);
   *  this does not necessarily mean, that the solver knows and can return the dual ray
   */
  EXTERN
  SCIP_Bool SCIPlpiExistsDualRay(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point),
   *  and the solver knows and can return the dual ray
   */
  EXTERN
  SCIP_Bool SCIPlpiHasDualRay(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to be dual unbounded */
  EXTERN
  SCIP_Bool SCIPlpiIsDualUnbounded(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to be dual infeasible */
  EXTERN
  SCIP_Bool SCIPlpiIsDualInfeasible(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP is proven to be dual feasible */
  EXTERN
  SCIP_Bool SCIPlpiIsDualFeasible(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff LP was solved to optimality */
  EXTERN
  SCIP_Bool SCIPlpiIsOptimal(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff current LP basis is stable */
  EXTERN
  SCIP_Bool SCIPlpiIsStable(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff the objective limit was reached */
  EXTERN
  SCIP_Bool SCIPlpiIsObjlimExc(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff the iteration limit was reached */
  EXTERN
  SCIP_Bool SCIPlpiIsIterlimExc(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns TRUE iff the time limit was reached */
  EXTERN
  SCIP_Bool SCIPlpiIsTimelimExc(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** returns the internal solution status of the solver */
  EXTERN
  int SCIPlpiGetInternalStatus(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call */
  EXTERN
  SCIP_RETCODE SCIPlpiIgnoreInstability(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_Bool*            success             /**< pointer to store, whether the instability could be ignored */
     );
  
  /** gets objective value of solution */
  EXTERN
  SCIP_RETCODE SCIPlpiGetObjval(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_Real*            objval              /**< stores the objective value */
     );
  
  /** gets primal and dual solution vectors for feasible LPs */
  EXTERN
  SCIP_RETCODE SCIPlpiGetSol(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_Real*            objval,             /**< stores the objective value, may be NULL if not needed */
     SCIP_Real*            primsol,            /**< primal solution vector, may be NULL if not needed */
     SCIP_Real*            dualsol,            /**< dual solution vector, may be NULL if not needed */
     SCIP_Real*            activity,           /**< row activity vector, may be NULL if not needed */
     SCIP_Real*            redcost             /**< reduced cost vector, may be NULL if not needed */
     );
  
  /** gets primal ray for unbounded LPs */
  EXTERN
  SCIP_RETCODE SCIPlpiGetPrimalRay(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_Real*            ray                 /**< primal ray */
     );
  
  /** gets dual Farkas proof for infeasibility */
  EXTERN
  SCIP_RETCODE SCIPlpiGetDualfarkas(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_Real*            dualfarkas          /**< dual Farkas row multipliers */
     );
  
  /** gets the number of LP iterations of the last solve call */
  EXTERN
  SCIP_RETCODE SCIPlpiGetIterations(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  iterations          /**< pointer to store the number of iterations of the last solve call */
     );
  
  /** gets information about the quality of an LP solution
   *
   *  Such information is usually only available, if also a (maybe not optimal) solution is available.
   *  The LPI should return SCIP_INVALID for @p quality, if the requested quantity is not available.
   */
  EXTERN
  SCIP_RETCODE SCIPlpiGetRealSolQuality(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_LPSOLQUALITY     qualityindicator,   /**< indicates which quality should be returned */
     SCIP_Real*            quality             /**< pointer to store quality number */
     );
  
  /**@} */
  
  
  
  
  /*
   * LP Basis Methods
   */
  
  /**@name LP Basis Methods */
  /**@{ */
  
  /** gets current basis status for columns and rows; arrays must be large enough to store the basis status */
  EXTERN
  SCIP_RETCODE SCIPlpiGetBase(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  cstat,              /**< array to store column basis status, or NULL */
     int*                  rstat               /**< array to store row basis status, or NULL */
     );
  
  /** sets current basis status for columns and rows */
  EXTERN
  SCIP_RETCODE SCIPlpiSetBase(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     const int*            cstat,              /**< array with column basis status */
     const int*            rstat               /**< array with row basis status */
     );
  
  /** returns the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m */
  EXTERN
  SCIP_RETCODE SCIPlpiGetBasisInd(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int*                  bind                /**< pointer to store basis indices ready to keep number of rows entries */
     );
  
  /** get row of inverse basis matrix B^-1
   *
   *  @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
   *        uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
   *        see also the explanation in lpi.h.
   */
  EXTERN
  SCIP_RETCODE SCIPlpiGetBInvRow(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   r,                  /**< row number */
     SCIP_Real*            coef,               /**< pointer to store the coefficients of the row */
     int*                  inds,               /**< array to store the non-zero indices, or NULL */
     int*                  ninds               /**< pointer to store the number of non-zero indices, or NULL
                                                *   (-1: if we do not store sparsity information) */
     );
  
  /** get column of inverse basis matrix B^-1
   *
   *  @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
   *        uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
   *        see also the explanation in lpi.h.
   */
  EXTERN
  SCIP_RETCODE SCIPlpiGetBInvCol(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   c,                  /**< column number of B^-1; this is NOT the number of the column in the LP;
                                                *   you have to call SCIPlpiGetBasisInd() to get the array which links the
                                                *   B^-1 column numbers to the row and column numbers of the LP!
                                                *   c must be between 0 and nrows-1, since the basis has the size
                                                *   nrows * nrows */
     SCIP_Real*            coef,               /**< pointer to store the coefficients of the column */
     int*                  inds,               /**< array to store the non-zero indices, or NULL */
     int*                  ninds               /**< pointer to store the number of non-zero indices, or NULL
                                                *   (-1: if we do not store sparsity information) */
     );
  
  /** get row of inverse basis matrix times constraint matrix B^-1 * A
   *
   *  @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
   *        uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
   *        see also the explanation in lpi.h.
   */
  EXTERN
  SCIP_RETCODE SCIPlpiGetBInvARow(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   r,                  /**< row number */
     const SCIP_Real*      binvrow,            /**< row in (A_B)^-1 from prior call to SCIPlpiGetBInvRow(), or NULL */
     SCIP_Real*            coef,               /**< vector to return coefficients */
     int*                  inds,               /**< array to store the non-zero indices, or NULL */
     int*                  ninds               /**< pointer to store the number of non-zero indices, or NULL
                                                *   (-1: if we do not store sparsity information) */
     );
  
  /** get column of inverse basis matrix times constraint matrix B^-1 * A
   *
   *  @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver
   *        uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated;
   *        see also the explanation in lpi.h.
   */
  EXTERN
  SCIP_RETCODE SCIPlpiGetBInvACol(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     int                   c,                  /**< column number */
     SCIP_Real*            coef,               /**< vector to return coefficients */
     int*                  inds,               /**< array to store the non-zero indices, or NULL */
     int*                  ninds               /**< pointer to store the number of non-zero indices, or NULL
                                                *   (-1: if we do not store sparsity information) */
     );
  
  /**@} */
  
  
  
  
  /*
   * LPi State Methods
   */
  
  /**@name LPi State Methods */
  /**@{ */
  
  /** stores LPi state (like basis information) into lpistate object */
  EXTERN
  SCIP_RETCODE SCIPlpiGetState(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     BMS_BLKMEM*           blkmem,             /**< block memory */
     SCIP_LPISTATE**       lpistate            /**< pointer to LPi state information (like basis information) */
     );
  
  /** loads LPi state (like basis information) into solver; note that the LP might have been extended with additional
   *  columns and rows since the state was stored with SCIPlpiGetState()
   */
  EXTERN
  SCIP_RETCODE SCIPlpiSetState(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     BMS_BLKMEM*           blkmem,             /**< block memory */
     const SCIP_LPISTATE*  lpistate            /**< LPi state information (like basis information), or NULL */
     );
  
  /** clears current LPi state (like basis information) of the solver */
  EXTERN
  SCIP_RETCODE SCIPlpiClearState(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** frees LPi state information */
  EXTERN
  SCIP_RETCODE SCIPlpiFreeState(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     BMS_BLKMEM*           blkmem,             /**< block memory */
     SCIP_LPISTATE**       lpistate            /**< pointer to LPi state information (like basis information) */
     );
  
  /** checks, whether the given LPi state contains simplex basis information */
  EXTERN
  SCIP_Bool SCIPlpiHasStateBasis(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_LPISTATE*        lpistate            /**< LPi state information (like basis information) */
     );
  
  /** reads LPi state (like basis information from a file */
  EXTERN
  SCIP_RETCODE SCIPlpiReadState(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     const char*           fname               /**< file name */
     );
  
  /** writes LPi state (i.e. basis information) to a file */
  EXTERN
  SCIP_RETCODE SCIPlpiWriteState(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     const char*           fname               /**< file name */
     );
  
  /**@} */
  
  
  /*
   * LPi Pricing Norms Methods
   */
  
  /**@name LPi Pricing Norms Methods */
  /**@{ */
  
  /** stores LPi pricing norms into lpinorms object */
  extern
  SCIP_RETCODE SCIPlpiGetNorms(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     BMS_BLKMEM*           blkmem,             /**< block memory */
     SCIP_LPINORMS**       lpinorms            /**< pointer to LPi pricing norms information */
     );
  
  /** loads LPi pricing norms into solver; note that the LP might have been extended with additional
   *  columns and rows since the norms were stored with SCIPlpiGetNorms()
   */
  extern
  SCIP_RETCODE SCIPlpiSetNorms(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     BMS_BLKMEM*           blkmem,             /**< block memory */
     const SCIP_LPINORMS*  lpinorms            /**< LPi pricing norms information, or NULL */
     );
  
  /** frees LPi pricing norms information */
  extern
  SCIP_RETCODE SCIPlpiFreeNorms(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     BMS_BLKMEM*           blkmem,             /**< block memory */
     SCIP_LPINORMS**       lpinorms            /**< pointer to LPi pricing norms information, or NULL */
     );
  
  
  /**@} */
  
  
  
  
  /*
   * Parameter Methods
   */
  
  /**@name Parameter Methods */
  /**@{ */
  
  /** gets integer parameter of LP */
  EXTERN
  SCIP_RETCODE SCIPlpiGetIntpar(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_LPPARAM          type,               /**< parameter number */
     int*                  ival                /**< buffer to store the parameter value */
     );
  
  /** sets integer parameter of LP */
  EXTERN
  SCIP_RETCODE SCIPlpiSetIntpar(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_LPPARAM          type,               /**< parameter number */
     int                   ival                /**< parameter value */
     );
  
  /** gets floating point parameter of LP */
  EXTERN
  SCIP_RETCODE SCIPlpiGetRealpar(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_LPPARAM          type,               /**< parameter number */
     SCIP_Real*            dval                /**< buffer to store the parameter value */
     );
  
  /** sets floating point parameter of LP */
  EXTERN
  SCIP_RETCODE SCIPlpiSetRealpar(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_LPPARAM          type,               /**< parameter number */
     SCIP_Real             dval                /**< parameter value */
     );
  
  /**@} */
  
  
  
  
  /*
   * Numerical Methods
   */
  
  /**@name Numerical Methods */
  /**@{ */
  
  /** returns value treated as infinity in the LP solver */
  EXTERN
  SCIP_Real SCIPlpiInfinity(
     SCIP_LPI*             lpi                 /**< LP interface structure */
     );
  
  /** checks if given value is treated as infinity in the LP solver */
  EXTERN
  SCIP_Bool SCIPlpiIsInfinity(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     SCIP_Real             val                 /**< value to be checked for infinity */
     );
  
  /**@} */
  
  
  
  
  /*
   * File Interface Methods
   */
  
  /**@name File Interface Methods */
  /**@{ */
  
  /** reads LP from a file */
  EXTERN
  SCIP_RETCODE SCIPlpiReadLP(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     const char*           fname               /**< file name */
     );
  
  /** writes LP to a file */
  EXTERN
  SCIP_RETCODE SCIPlpiWriteLP(
     SCIP_LPI*             lpi,                /**< LP interface structure */
     const char*           fname               /**< file name */
     );
  
  /**@} */
  
  /**@} */
  
  
  #ifdef __cplusplus
  }
  #endif
  
  #endif
  