An exterior plane algorithm for linear programming

An algorithm that solves a linear program by using planes exterior to
the feasible region is described. Given a linear program in standard
form, a constraint derived from the given objective function is added to
the constraint set, and the objective function is removed. The added
constraint is designed to make the program infeasible. It is then
incrementally and unidirectionally moved toward the solution vertex in
cycles, which causes the constraint set to change each time. A cycle
consists of two steps: moving the added constraint and testing the
updated constraint set for feasibility. Ultimately the moving constraint
reaches the solution vertex and the program becomes feasible, this
signals both the solution of the program and termination of the
algorithm. Because of unidirectionality, the algorithm is guaranteed to
terminate. If fixed point arithmetic with B bit numbers is used and
feasibility testing complexity with N variables is O(f(N)), then the
worst-case complexity of the incremental exterior plane algorithm is
2^B O(f(N)). f(N) is O(N^3) with the simplex method and
O(N^3.5) with many interior point methods. The algorithm can be
substantially improved by using binary search, the resulting complexity
is O(B f(N)). The algorithm is compared qualitatively with three types
of LP algorithms: simplex, ellipsoid, and interior point.