Showing papers on "Integer programming published in 1969"

Optimal File Allocation in a Multiple Computer System

Abstract: A model is developed for allocating information files required in common by several computers The model considers storage cost, transmission cost, file lengths, and request rates, as well as updating rates of files, the maximum allowable expected access times to files at each computer, and the storage capacity of each computer The criterion of optimality is minimal overall operating costs (storage and transmission) The model is formulated into a nonlinear integer zero-one programming problem, which may be reduced to a linear zero-one programming problem A simple example is given to illustrate the model

Integer Programming and the Theory of Grouping

Abstract: This paper is written with three objectives in mind. First, to point out that the problem of grouping, where a larger number of elements n are combined into m mutually exclusive groups (m < n) should be recognized as a problem in Integer Programming, and that such recognition can help us in avoiding complete enumeration of stages in grouping from n to n — 1 … to m, and of alternative possibilities in each stage. Second, to formulate mathematically some simple versions of the relevant Integer Programming Problem, so that the available computer codes can solve it. When the grouping attempts to minimize the within groups sums of squares, the so-called string property is proved to be necessary for the minimum (Lemma 1). It is shown that the string property can be exploited to write the non-linear within group sums of squares as a linear function (Lemma 2). An attempt is made to generalize the string property for the higher dimensional case. Third, to give some numerical examples to clarify the mathem...

An Improved Implicit Enumeration Approach for Integer Programming

Abstract: This paper synthesizes the Balasian implicit enumeration approach to integer linear programming with the approach typified by Land and Doig and by Roy, Bertier, and Nghiem. The synthesis results from the use of an imbedded linear program to compute surrogate constraints that are as "strong" as possible in a sense slightly different from that originally used by Glover. A simple implicit enumeration algorithm fitted with optional imbedded linear programming machinery was implemented and tested extensively on an IBM 7044. Use of the imbedded linear program greatly reduced solution times in virtually every case, and seemed to render the tested algorithm superior to the five other implicit enumeration algorithms for which comparable published experience was available. The crucial issue of the sensitivity of solution time to the number of integer variables was given special attention. Sequences were run of set-covering, optimal-routing, and knapsack problems with multiple constraints of varying sizes up to 90 variables. The results suggest that use of the imbedded linear program in the prescribed way may mitigate solution-time dependence on the number of variables from an exponential to a low-order polynomial increase. The dependence appeared to be approximately linear for the first two problem classes, with 90-variable problems typically being solved in about 15 seconds; and approximately cubic for the third class, with 80-variable problems typically solved in less than 2 minutes. In the 35-variable range for all three classes, use of the imbedded linear program reduced solution times by a factor of about 100.

A branch‐bound algorithm for the capacitated facilities location problem

Abstract: This paper discusses a mixed integer programming method for solving the Facilities Location Problem with capacities on the facilities. The algorithm uses a Decomposition technique to solve the dual of the associated continuous problem in each branch-bound iteration. The method was designed to produce the global optimum solution for problems with up to 100 facilities and 1,000 customers. Computational experience and a complete example are also presented in the appendix.

A Column Generation Algorithm for a Ship Scheduling Problem

Abstract: This paper describes an algorithm for a ship scheduling problem, obtained from a Swedish shipowning company The algorithm uses the Dantzig-Wolfe decomposition method for linear programming The subprograms are simple network flow problems that are solved by dynamic programming The master program in the decomposition algorithm is an LP problem with only zero-one elements in the matrix and the right-hand side Integer solutions are not guaranteed, but generation and solution of a large number of problems indicates that the frequency of fractional solutions is as small as 1–2 per cent Problems with about 40 ships and 50 cargoes are solved in about 25 minutes on an IBM 7090 In order to resolve the fractional cases, some integer programming experiments have been made The results will be reported in a forthcoming paper

The Airline Crew Scheduling Problem: A Survey

Abstract: This is a survey of the different approaches studied by a number of airlines in the past few years to attempt to optimize the allocation of crews to flights. The approach is usually one of integer programming with 0-1 variables, the matrix of coefficients having a very special form. The survey covers the generation, costing, reduction, and optimization of such matrices.

Efficient Heuristic Procedures for Integer Linear Programming with an Interior

Abstract: This paper presents and evaluates some new heuristic procedures for seeking an approximate solution of pure integer linear programming problems having only inequality constraints. The computation time required by these methods after obtaining the optimal noninteger solution by the simplex method has generally been only a small fraction of that used by the simplex method for the problems tested which have 15 to 300 original variables. Furthermore, the solution obtained by the better procedures consistently has been close to optimal and frequently has actually been optimal. Plans for generalizing these methods also are outlined. A companion paper presents an optimal "bound-and-scan" algorithm that may be used in conjunction with these approximate procedures.

On Connections Between Zero-One Integer Programming and Concave Programming Under Linear Constraints

Abstract: Consider the zero-one integer programming problem P1i:minimize Z = c'x subject to Ax ≦ b, 0 ≦ xi ≦ 1, xj = 0 or 1, j = 1, 2, ', n, where A is an m × n matrix, c' = c1, ', cn, x' = x1, ', xn, and b is an m × 1 vector with b' = b1, ', bm. Assume the elements of A, b, c are all rational. This paper characterizes the feasible solutions of P1, shows that P1 is equivalent to a problem of minimizing a concave quadratic objective function over a convex set, and applies a method developed by Tul to solve such a problem to yield a procedure for the zero-one integer programming problem.

Integer Linear Programming: A Study in Computational Efficiency

Abstract: In this report, twenty-nine integer linear programming problems, raging from very simple to apparently rather difficult, are introduced. The results of running these problems on four different computer codes, involving five distinct algorithms, are presented as both time and iteration data. A brief description of the codes used is also included.

Optimization by Integer Programming of Constrained Reliability Problems with Several Modes of Failure

Abstract: Reliability optimization problems with N stages or subsystems in series, utilizing parallel or series redundant units, can be formulated and solved as integer programming problems. The systems considered have subsystems with components which can fail in several modes and are subject to linear and nonlinear constraints. Two situations are considered in which components within the subsystem 1) all fail in the same mode, or 2) all may fail in different modes. Expressions are developed for the probability of failure in each case. Two examples are solved.

A Bound-and-Scan Algorithm for Pure Integer Linear Programming with General Variables

Abstract: A new algorithm for solving the pure-integer linear programming problem with general integer variables is presented and evaluated. Roughly speaking, this algorithm proceeds by obtaining tight bounds or conditional bounds on the relevant values of the respective variables, and then identifying a sequence of constantly improving feasible solutions by scanning the relevant solutions. Encouraging computational experience is reported that suggests that this algorithm should compare favorably in efficiency with existing algorithms. Plans for investigating ways of further increasing the efficiency of the algorithm and of extending it to more general problems also are outlined.

Integer Programming over a Finite Additive Group

Abstract: An algorithm is given for solving an integer program over an additive group. Computation times appear to grow more favorably with increases in the number of variables and group elements than with the dynamic programming approach proposed by Gomory. A new property satisfied by optimal solutions to the group problem is established by reference to the structure of the algorithm. Extension of the algorithm to the general integer programming problem is developed in a sequel.

An algorithm for nonconvex programming

Abstract: : The paper presents an algorithm to solve the most general mathematical programming problem: s.t. (g superscript i)(y) = or < 0, i = 1,2,. ..,m, Min. g(y), y = (y1,...,yn). The only restriction required is that the functions g superscript i, g be real valued. The general formulation allows for nonlinear or linear integer programming, mixed integer programming and general nonconvex continuous variable programming. The classical approaches have been essentially 'local' or 'neighborhood' techniques dependent on derivatives (or finite difference approximations to derivatives). They suffer from two serious difficulties which can be characterized as the 'dimensionality problem' and the problem of 'trapping at local optima.' Our central aim here is to present a new framework for reaching global optimum. The procedure involves two interconnected mechanisms, a method for structuring the search and a decision rule for selecting the course of the search.

A Graph-Theoretic Approach to a Class of Integer-Programming Problems

Abstract: This paper presents an efficient algorithm for finding a minimum-weight generalized matching in a weighted bipartite graph. Computational evidence is given that indicates that the time required to find a least-cost assignment of n jobs to n workers goes roughly as n2 for 10 ≦ n ≦ 50. It is shown that this algorithm can be used to solve effectively the well known transportation problem of integer programming where the objective function is convex-separable. Finally, the paper gives an algorithm that applies the same concept to a graph that is not necessarily bipartite.

The intersection cut - a new cutting plane for integer programming.

Abstract: : A new cutting plane is proposed for integer programming, generated as follows. Let X be the feasible set, and x bar the optimal (noninteger) solution of the linear program associated with an integer program in n-space. A convex polytope X' is defined, such that X included in X', x bar is an optimal vertex of X', and X' has exactly n vertices adjacent to x bar (whether x bar is degenerate or not). Consider now the unit cube containing x bar, whose vertices are integer, and the hypersphere through the vertices of this cube. This hypersphere is intersected in n linearly independent points by the n halflines originating at x bar and containing the n vertices of X' adjecent to x bar. The hyperplane through these n points of intersection (of the halflines with the hypersphere) defines a valid cut (the intersection cut), which does not belong to the class of cuts introduced by Gomory. A simple formula is given for finding the equation of the hyperplane. A comparison of the intersection cut to one particular Gomory cut is given in geometric terms. Possible ways of strengthening the cut are discussed: 'integerization' of the pivot row, choice of the 'best' unit cube among those containing x bar. An algorithm is then proposed and a convergence proof is given. Extension of the new cut to the mixed integer case, a discussion of relations to other work and a numerical example conclude the paper. (Author)

Letter to the Editor-Computational Results of an Integer Programming Algorithm

Abstract: This note reports on a method for solving the general integer linear programming problem that is called the Bounded Variable Algorithm. It first describes the basic algorithm and then makes a comparison of limited scope between the Bounded Variable Algorithm and other published algorithms on a set of common problems.

On a multi-product assembly line balancing problem.

Abstract: : A multi-product assembly line balancing problem is presented. The problem is formulated as a linear integer programming problem for which zero-one programming is applicable. A reformulation based on finding the shortest route in a finite directed network is developed and an example problem is solved. (Author)

Letter to the Editor—Toward a Unifying Theory for Integer Linear Programming

Abstract: During the last decade a great number of approaches and schemes have been proposed for solving integer linear programming problems. These range from the implicit enumeration schemes including, for example, the additive algorithm of Balas to schemes that proceed in a simplicial fashion to an optimal solution as does, for example, the All-Integer Method of Gomory. Still other approaches have been heuristic in nature and strive to achieve so-called good (not necessarily optimal) solutions. The purpose of this paper is to discuss a framework that appears to offer some potential for devising new algorithms, and, at the same time, provides a theory that helps to unify some of the previously advanced methods for solving integer linear programming problems. The framework involves the use of bounds on variables and is related to some of the author's earlier work on the Geometric Definition Method of linear programming.

C2 and lpu2 combinations for treating different risks and uncertainties in capital budgets

Abstract: : Chance Constrained (C sup 2) Programming and Linear Programming under Uncertainty (LP(U sup 2)) are joined together in order to deal with different risks and uncertainties which are commonly encountered in capital budgeting. This includes payback period protection via chance constraints formulated to cover (or bound) a possible loss of future opportunities during the payback period. It also includes liquidity requirements formulated preemptively via (LP(U sup 2)) to provide protection against possible cash (or liquidity) shortages at specified times. The case of arbitrary discrete distributions is examined and new formulations are developed which model economic, statistical, and technological decision interdependencies. Relations to geometric programming are indicated prior to reducing these formulations to zero-one integer programming (deterministic) equivalents. Duality relations obtained from these formulations provide separate evaluators for yield, risk, portfolio and liquidity effects of cash investment. Finally, relations to 'Balas-type' subsidy and penalty adjustments are noted.

Algorithm 348: matrix scaling by integer programming [F1]

Abstract: p r o c e d u r e scale (a, m, n, g, u, v); v a l u e m, n , g; i n t e g e r m, n; rea l g; r e a l a r r a y a; i n t e g e r array u, v; c o m m e n t T h e use of s ca l ing to p r e c o n d i t i o n m a t r i c e s so as to i m p r o v e s u b s e q u e n t c o m p u t a t i o n a l c h a r a c t e r i s t i c s is of cons i d e r a b l e i m p o r t a n c e . T o m e a s u r e t h e s ca l ing c o n d i t i o n of a m a t r i x , a l j ( i = 1 , . . . , m and j = l , . . . , n ) , F u l k e r s o n and Wol fe [1] s u g g e s t e d t he ra t io of t h e m a t r i x e n t r y of l a r g e s t a b s o l u t e v a l u e to t h a t of t he s m a l l e s t nonze ro a b s o l u t e va lue . T h i s p r o c e d u r e i m p l e m e n t s t h e m e t h o d of [1], i.e. f ind ing m u l t i p l i c a t i ve row f ac to r s , r~, and c o l u m n fac to r s , sy, which , w h e n appl ied, m i n i m i z e t h e above c o n d i t i o n n u m b e r . T h e m i n i m i z a t i o n p r o b l e m can be exp re s sed as an e q u i v a l e n t a d d i t i v e d i sc re t e p r o b l e m b y t a k i n g l o g a r i t h m s and def in ing :

Dense sets of two variable integer programs requiring arbitrarily many cuts by fractional algorithms.

Abstract: : A class of two variable integer programming problems is defined which are indexed by a continuous parameter t > 0. It is then shown that, given any non-empty open interval I of positive reals and any number N, there can be found a rational value (t sub o) is an element of I, such that the problem indexed by (t sub o) requires at least N cuts before convergence to the integer optimal occurs, using the algorithm of Gomory based on the fractional row cut. This result is derived as a corollary to the main theorem of the paper, which states an entirely parallel result for any Generalized Fractional Algorithm (GFA), a notion defined in the paper and shown to include the algorithm of Gomory as a special case. While the definition of a GFA is very broad, it does not permit the possibility of adding the entire group of cuts to the tableau at each iteration.