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 initially infeasible. It is
then incrementally and unidirectionally moved toward the solution vertex
in cycles, which causes the constraint set to change each time. Each
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 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 an
interior point method. The algorithm can be substantially improved by
using binary search, the resulting complexity is B O(f(N)). The
algorithm is compared qualitatively with three types of LP algorithms:
simplex, ellipsoid, and interior point.