## `linopt::Transparent` -- return the ordinary simplex tableau of a linear program

#### Introduction

`linopt::Transparent(`[constr, obj]`)` returns the ordinary simplex tableau of the given linear program given by the constraints `constr` and the linear objective function `obj`.

#### Call(s)

`linopt::Transparent([constr, obj])`
`linopt::Transparent([constr, obj <, NonNegative> <, seti>])`
`linopt::Transparent([constr, obj <, NonNegative> <, All>])`
`linopt::Transparent([constr, obj <, setn> <, seti>])`
`linopt::Transparent([constr, obj <, setn> <, All>])`

#### Parameters

`constr` | - | a set or list of linear constraints
`obj` | - | a linear expression
`seti` | - | a set which contains identifiers interpreted as indeterminates
`setn` | - | a set which contains identifiers interpreted as indeterminates

#### Options

`All` | - | all variables are constrained to be integer
`NonNegative` | - | all variables are constrained to be nonnegative

#### Returns

a simplex tableau of domain type `linopt::Transparent`.

#### Related Functions

`linopt::Transparent::autostep`, `linopt::Transparent::convert`, `linopt::Transparent::dual_prices`, `linopt::Transparent::phaseI_tableau`, `linopt::Transparent::phaseII_tableau`, `linopt::Transparent::result`, `linopt::Transparent::simplex`, `linopt::Transparent::suggest`, `linopt::Transparent::userstep`

#### Details

- [`constr`, `obj`] is a Linear Optimization Problem of the same structure like in `linopt::maximize`. As the result the ordinary simplex tableau of the given problem is returned; this means that equations will be replaced by two unequations and unbounded variables will be replaced by two new variables.
- Internally the tableau returned consists of more information than viewable on the screen. Therefore `linopt::Transparent::convert` is provided to perform the transduction into the structure of the screen-tableau. (This can be necessary if the returned tableau shall serve as an input-parameter for another function -- e.g. a user defined procedure for the selection of pivot elements.) If an ordinary simplex with two phases is wished, the next step should be the call of `linopt::Transparent::phaseI_tableau`.
- All functions of the linopt library using the tableau returned by `linopt::Transparent` try to minimize the problem! Therefore it can be necessary to multiply the objective function with -1 first.
- In the simplex tableau returned a special notation is used. "linopt" stands for the tableau them self, "obj" describes the linear objective function, "restr" stands for the vector of restrictions, slk[1], slk[2], ... are the slack variables and the names of the other variables stand for themselves. Variables which are given as row labels indicate that they are part of the base.

#### Example 1

First a small example, returning the ordinary simplex tableau of the given linear program. One can see that the slack variables are forming the basis:

    >> k := [[x + y >= -1, x + y <= 3], x + 2*y, NonNegative]:
       linopt::Transparent(k)

                  +-                                           -+
                  |  "linopt", "restr", slk[1], slk[2],  x,  y  |
                  |                                             |
                  |    "obj",     0,       0,      0,    1,  2  |
                  |                                             |
                  |   slk[1],     1,       1,      0,   -1, -1  |
                  |                                             |
                  |   slk[2],     3,       0,      1,    1,  1  |
                  +-                                           -+

It follows a little bit larger example:

    >> k := [{3*x + 4*y - 3*z <= 23, 5*x - 4*y - 3*z <= 10,
              7*x + 4*y + 11*z <= 30}, -x + y + 2*z, NonNegative]:
       linopt::Transparent(k)

            +-                                                       -+
            |  "linopt", "restr", slk[1], slk[2], slk[3],  z,  x,  y  |
            |                                                         |
            |    "obj",     0,       0,      0,      0,    2, -1,  1  |
            |                                                         |
            |   slk[1],     30,      1,      0,      0,   11,  7,  4  |
            |                                                         |
            |   slk[2],     10,      0,      1,      0,   -3,  5, -4  |
            |                                                         |
            |   slk[3],     23,      0,      0,      1,   -3,  3,  4  |
            +-                                                       -+

The result of `linopt::Transparent` is of domain type `linopt::Transparent`. So it can be used as input for other `linopt::Transparent::*` function, e.g. for
`linopt::Transparent::suggest`:

    >> k := [[x + y >= -1, x + y <= 3], x + 2*y, NonNegative]:
       t := linopt::Transparent(k):
       domtype(t), linopt::Transparent::suggest(t)

                           linopt::Transparent, OPTIMAL

    >> delete k, t:

#### Background

- References:

  Papadimitriou, Christos H; Steiglitz, Kenneth: Combinatorial Optimization; Algorithms and Complexity. Prentice-Hall, 1982.

  Nemhauser, George L; Wolsey, Laurence A: Integer and Combinatorial Optimization. New York, Wiley, 1988.

  Salkin, Harvey M; Mathur, Kamlesh: Foundations of Integer Programming. North-Holland, 1989.

  Neumann, Klaus; Morlock, Martin: Operations-Research. Munich, Hanser, 1993.

  Duerr, Walter; Kleibohm, Klaus: Operations Research; Lineare Modelle und ihre Anwendungen. Munich, Hanser, 1992.

  Suhl, Uwe H: MOPS - Mathematical OPtimization System. European Journal of Operational Research 72(1994)312-322. North-Holland, 1994.

  Suhl, Uwe H; Szymanski, Ralf: Supernode Processing of Mixed Integer Models. Boston, Kluwer Academic Publishers, 1994.

#### Changes

- new function
- The linopt library was completely rewritten in MuPAD version 2.0.

Do you have questions or comments?
Copyright © SciFace Software GmbH & Co. KG 2000