On the construction of weighted time-optimal B-trees

B-trees have been popular data structures since their definition. Their success is due to the fact that a B-tree containingn keys is balanced with a height ofO(logn). However, for a given set of elements and their access frequencies, one can construct many B-trees (possibly with different heights). The average access costs of these trees may vary significantly. An algorithm to construct a weighted time-optimal B-tree is presented. A weighted time-optimal B-tree is one in which the weighted access cost is minimized. A dynamic programming algorithm is used to construct a weighted time-optimal B-tree givenn elements and their weights. The algorithm runs in timeO(mn ³ logn) and has a storage requirement ofO(mn ² logn) wherem is the order of the B-tree andn is the number of keys.This research was supported in part by Texas Advanced Research Grant 1080 and NASA Grant NAG 5–739.     

A simple GAP-canceling algorithm for the generalized maximum flow problem

We give a simple primal algorithm for the generalized maximum flow problem that repeatedly finds and cancels generalized augmenting paths (GAPs). We use ideas of Wallacher (A generalization of the minimum-mean cycle selection rule in cycle canceling algorithms, 1991) to find GAPs that have a good trade-off between the gain of the GAP and the residual capacity of its arcs; our algorithm may be viewed as a special case of Wayne’s algorithm for the generalized minimum-cost circulation problem (Wayne in Math Oper Res 27:445–459, 2002). Most previous algorithms for the generalized maximum flow problem are dual-based; the few previous primal algorithms (including Wayne in Math Oper Res 27:445–459, 2002) require subroutines to test the feasibility of linear programs with two variables per inequality (TVPIs). We give an O(mn) time algorithm for finding negative-cost GAPs which can be used in place of the TVPI tester. This yields an algorithm with O(m log(mB/ε)) iterations of O(mn) time to compute an ε-optimal flow, or O(m ² log (mB)) iterations to compute an optimal flow, for an overall running time of O(m ³ nlog(mB)). The fastest known running time for this problem is , and is due to Radzik (Theor Comput Sci 312:75–97, 2004), building on earlier work of Goldfarb et al. (Math Oper Res 22:793–802, 1997). David P. Williamson is supported in part by an IBM Faculty Partnership Award and NSF grant CCF-0514628.     

The amortized complexity of Henriksen's algorithm

Henriksen's algorithm is a priority queue implementation that has been proposed for the event list found in discrete event simulations. It offers several practical advantages over heaps and tree structures.Although individual insertions ofO(n) complexity can easily be demonstrated to exist, the self-adjusting nature of the data structure seems to ensure that these will be rare. For this reason, a better measure of total running time is theamortized complexity: the worst case over a sequence of operations, rather than for a single operation.We show that Henriksen's algorithm has an amortized complexity of(n ^1/2) per insertion,O(1) per extract_min operation, andO(logn) for isolated deletions.     

Improved asymptotic analysis of the average number of steps performed by the self-dual simplex algorithm

In this paper we analyze the average number of steps performed by the self-dual simplex algorithm for linear programming, under the probabilistic model of spherical symmetry. The model was proposed by Smale. Consider a problem ofn variables withm constraints. Smale established that for every number of constraintsm, there is a constantc(m) such that the number of pivot steps of the self-dual algorithm,(m, n), is less thanc(m)(lnn) ^m(m+1) . We improve upon this estimate by showing that(m, n) is bounded by a function ofm only. The symmetry of the function inm andn implies that(m, n) is in fact bounded by a function of the smaller ofm andn. Parts of this research were done while the author was visiting Stanford University, XEROX- PARC, Carnegie-Mellon University and Northwestern University and was supported in part by the National Science Foundation under Grants MCS-8300984, ECS-8218181 and ECS-8121741.     

Bestimmung der Eigenwerte und Eigenvektoren einer Matrix mit Hilfe des Quotienten-Differenzen-Algorithmus

Summary Two previous papers (in Vol. V) describe theory and some applications of the quotient-difference (=QD-) algorithm. Here we give an extension which allows the determination of the eigenvectors of a matrix. Letx ₍₀₎ ¹ , ...,x ₍₀₎ ⁿ be a coordinate system in whichA has Jacobi form (such a system may be constructed with methods ofC. Lanczos orW. Givens). Then the QD-algorithm allows the construction of a sequence of coordinate systemsx ₍₂₎ ¹ , ...,x ₍₂₎ ⁿ , (=0, 1, 2, ...) which converge for to the system of the eigenvectors ofA.     

A select and insert sorting algorithm

A general sorting algorithm, having the well knownO(n ²) algorithmsStraight Insertion Sort andSelection Sort as special cases, is described. This algorithm is analyzed in the case that certain choices in the algorithm are done randomly, and this yields an algorithm that has an average complexity ofO(n ^1.5) and a worst case complexity ofO(n ²). However, making random choices (by some random number generator) is time consuming, and a simple quasi-random scheme is therefore implemented. Test runs indicate that also this version has average complexity ofO(n ^1.5), and it even seems to perform better than the version using real random choices (even if we disregard the time used for the random choices). This version also needs very little administrative overhead, and it therefore compares favourably to many other sorting algorithms for small and medium sized arrays.     

The upper envelope of piecewise linear functions and the boundary of a region enclosed by convex plates: Combinatorial analysis

Letf ₁, ...,f _m be (partially defined) piecewise linear functions ofd variables whose graphs consist ofn d-simplices altogether. We show that the maximal number ofd-faces comprising the upper envelope (i.e., the pointwise maximum) of these functions isO(n ^d (n)), where(n) denotes the inverse of the Ackermann function, and that this bound is tight in the worst case. If, instead of the upper envelope, we consider any single connected componentC enclosed byn d-simplices (or, more generally, (d – 1)-dimensional compact convex sets) in ^d+1 , then we show that the overall combinatorial complexity of the boundary ofC is at mostO(n ^d+1–(d+1) ) for some fixed constant(d+1)>0.Work on this paper has been supported by Office of Naval Research Grant N00014-82-K-0381, by National Science Foundation Grant NSF-DCR-83-20085, by grants from the Digital Equipment Corporation, and the IBM Corporation, and by a research grant from the NCRD—the Israeli National Council for Research and Development.     

Absolute monotonicity of rational functions occurring in the numerical solution of initial value problems

Summary This paper deals with rational functions ø(z) approximating the exponential function exp(z) related to numerical procedures for solving initial value problems. Motivated by positivity and contractivity requirements imposed on these numerical procedures we study the greatest nonnegative numberR, denoted byR(ø), such that ø is absolutely monotonic on (–R, 0]. An algorithm for the computation ofR(ø) is presented. Application of this algorithm yields the valueR(ø) for the well-known Padé approximations to exp(z). For some specific values ofm, n andp we determine the maximum ofR(ø) when ø varies over the class of all rational functions ø with degree of the numerator m, degree of the denominator n and ø(z)=exp(z)+(z ^p+1 ) (forz0).     

Separating two simple polygons by a sequence of translations

LetP andQ be two disjoint simple polygons havingm andn sides, respectively. We present an algorithm which determines whetherQ can be moved by a sequence of translations to a position sufficiently far fromP without colliding withP, and which produces such a motion if it exists. Our algorithm runs in timeO(mn(mn) logm logn) where (k) is the extremely slowly growing inverse Ackermann's function. Since in the worst case (mn) translations may be necessary to separateQ fromP, our algorithm is close to optimal.Work on this paper by the first author has been supported by National Science Foundation Grant No. DMS-8501947. Work on this paper by the second author has been supported by Office of Naval Research Grant No. N00014-82-K-0381, National Science Foundation Grant No. NSP-DCR-83-20085, and by grants from the Digital Equipment Corporation, and the IBM Corporation. Work by the second and third authors has also been supported by a grant from the joint Ramot-Israeli Ministry of Industry Foundation. Part of the work on this paper has been carried out at the Workshop on Movable Separability of Sets at the Bellairs Research Institute of McGill University, Barbados, February 1986.     

Generating combinations in parallel

A parallel algorithm for generating all combinations ofm out ofn items in lexicographic order is presented. The algorithm usesm processors and runs inO(nCm) time. The cost of the algorithm, which is the parallel running time multiplied by the number of processors used, is optimal to within a constant multiplicative factor in view of the (ncm*m) lower bound on the number of operations required to solve this problem using a sequential computer.This work was supported by the Natural Sciences and Engineering Research Council of Canada under Grant NSERC-A3336.     

An interior point method, based on rank-1 updates, for linear programming

We propose a polynomial time primal—dual potential reduction algorithm for linear programming. The algorithm generates sequencesd ^k andv ^k rather than a primal—dual interior point (x ^k ,s ^k ), where and fori = 1, 2,,n. Only one element ofd ^k is changed in each iteration, so that the work per iteration is bounded by O(mn) using rank-1 updating techniques. The usual primal—dual iteratesx ^k ands ^k are not needed explicitly in the algorithm, whereasd ^k andv ^k are iterated so that the interior primal—dual solutions can always be recovered by aforementioned relations between (x ^k, s^k) and (d ^k, v^k) with improving primal—dual potential function values. Moreover, no approximation ofd ^k is needed in the computation of projection directions. © 1998 The Mathematical Programming Society, Inc. Published by Elsevier Science B.V.     

A compound matrix algorithm for the computation of the Smith form of a polynomial matrix

In the present paper is presented a numerical method for the exact reduction of a singlevariable polynomial matrix to its Smith form without finding roots and without applying unimodular transformations. Using the notion of compound matrices, the Smith canonical form of a polynomial matrixM(s)^nxn[s] is calculated directly from its definition, requiring only the construction of all thep-compound matricesC _p (M(s)) ofM(s), 1<pn. This technique produces a stable and accurate numerical algorithm working satisfactorily for any polynomial matrix of any degree.     

Finite activation energy reactions Part II: A reactive ridge

Summary The effect is determined of a large,O( ^–2),1, activation energy on the thermal stability of a reactant in the form of a two-dimensional ridge, undergoing a steady zero-order exothermic reaction. The reactive ridge decreases in depth at a rate ofO( ²) from a maximum ofO(1). The Biot number of the uniform lower surface of the reactant is taken to be zero and of the upper surface to beO( ^–2). The critical Frank-Kamenetskii parameter is determined toO( ²).     

Applications of random sampling in computational geometry,II

We use random sampling for several new geometric algorithms. The algorithms are Las Vegas, and their expected bounds are with respect to the random behavior of the algorithms. These algorithms follow from new general results giving sharp bounds for the use of random subsets in geometric algorithms. These bounds show that random subsets can be used optimally for divide-and-conquer, and also give bounds for a simple, general technique for building geometric structures incrementally. One new algorithm reports all the intersecting pairs of a set of line segments in the plane, and requiresO(A+n logn) expected time, whereA is the number of intersecting pairs reported. The algorithm requiresO(n) space in the worst case. Another algorithm computes the convex hull ofn points inE ^d inO(n logn) expected time ford=3, andO(n ^[d/2]) expected time ford>3. The algorithm also gives fast expected times for random input points. Another algorithm computes the diameter of a set ofn points inE ³ inO(n logn) expected time, and on the way computes the intersection ofn unit balls inE ³. We show thatO(n logA) expected time suffices to compute the convex hull ofn points inE ³, whereA is the number of input points on the surface of the hull. Algorithms for halfspace range reporting are also given. In addition, we give asymptotically tight bounds for (k)-sets, which are certain halfspace partitions of point sets, and give a simple proof of Lee's bounds for high-order Voronoi diagrams.     

A new continuation method for complementarity problems with uniformP-functions

The complementarity problem with a nonlinear continuous mappingf from the nonnegative orthantR ₊ ⁿ ofR ⁿ intoR ⁿ can be written as the system of equationsF(x, y) = 0 and(x, y) R ₊ ²ⁿ , whereF denotes the mapping from the nonnegative orthantR ₊ ²ⁿ ofR ²ⁿ intoR ₊ ⁿ × Rⁿ defined byF(x, y) = (x ₁y₁,,x_ny_n, f₁(x) – y₁,, f_n(x) – y_n) for every(x, y) R ₊ ²ⁿ . Under the assumption thatf is a uniformP-function, this paper establishes that the mappingF is a homeomorphism ofR ₊ ²ⁿ ontoR ₊ ⁿ × Rⁿ. This result provides a theoretical basis for a new continuation method of tracing the solution curve of the one parameter family of systems of equationsF(x, y) = tF(x ⁰, y⁰) and(x, y) R ₊ ²ⁿ from an arbitrary initial point(x ⁰, y⁰) R ₊ ²ⁿ witht = 1 until the parametert attains 0. This approach is an extension of the one used in the polynomially bounded algorithm recently given by Kojima, Mizuno and Yoshise for solving linear complementarity problems with positive semi-definite matrices.     

On accelerating PL continuation algorithms by predictor—corrector methods

We consider path following methods designed to trace the zeroes of a continuous or differentiable mapF:R ⁿ⁺¹ R ⁿ . These methods are applicable e.g. in the numerical study of nonlinear eigenvalue and bifurcation problems. Traditionally a simplicial algorithm is based on a fixed triangulationT ofR ⁿ⁺¹ and a corresponding piecewise linear approximationF _T :R ⁿ⁺¹ R ⁿ .4 A fixed triangulation algorithm then traces the zeroes ofF _T via a complementary pivoting procedure. We present two kinds of hybrid algorithms that have the structure of a predictor—corrector method using simplicial methods to carry out the corrector steps. Numerical experience is reported showing the improvement in efficiency as compared to the fixed triangulation algorithm.     

Milnor numbers and the topology of polynomial hypersurfaces

Summary LetF: n + 1 be a polynomial. The problem of determining the homology groupsH _q (F ^–1 (c)), c , in terms of the critical points ofF is considered. In the best case it is shown, for a certain generic class of polynomials (tame polynomials), that for allc,F ^–1 (c) has the homotopy type of a bouquet of - ^c n-spheres. Here is the sum of all the Milnor numbers ofF at critical points ofF and ^c is the corresponding sum for critical points lying onF ^–1 (c). A second best case is also discussed and the homology groupsH _q (F ^–1 (c)) are calculated for genericc. This case gives an example in which the critical points at infinity ofF must be considered in order to determine the homology groupsH _q (F ^–1 (c)).     

A pivoting algorithm for convex hulls and vertex enumeration of arrangements and polyhedra

We present a new pivot-based algorithm which can be used with minor modification for the enumeration of the facets of the convex hull of a set of points, or for the enumeration of the vertices of an arrangement or of a convex polyhedron, in arbitrary dimension. The algorithm has the following properties:

Karmarkar's linear programming algorithm and Newton's method

This paper describes a full-dimensional version of Karmarkar's linear programming algorithm, theprojective scaling algorithm, which is defined for any linear program in ⁿ having a bounded, full-dimensional polytope of feasible solutions. If such a linear program hasm inequality constraints, then it is equivalent under an injective affine mappingJ: ^{n m} to Karmarkar's original algorithm for a linear program in ^m havingm—n equality constraints andm inequality constraints. Karmarkar's original algorithm minimizes a potential functiong(x), and the projective scaling algorithm is equivalent to that version of Karmarkar's algorithm whose step size minimizes the potential function in the step direction.The projective scaling algorithm is shown to be a global Newton method for minimizing a logarithmic barrier function in a suitable coordinate system. The new coordinate system is obtained from the original coordinate system by a fixed projective transformationy = (x) which maps the hyperplaneH _opt ={x:c, x =c ₀} specified by the optimal value of the objective function to the hyperplane at infinity. The feasible solution set is mapped under to anunbounded polytope. Letf _LB(y) denote the logarithmic barrier function associated to them inequality constraints in the new coordinate system. It coincides up to an additive constant with Karmarkar's potential function in the new coordinate system. Theglobal Newton method iterate y ^* for a strictly convex functionf(y) defined on a suitable convex domain is that pointy ^* that minimizesf(y) on the search ray {y+ v _N(y): 0} wherev _N(y) =–(² f(y))^–1(f(y)) is the Newton's method vector. If {x ^(k)} are a set of projective scaling algorithm iterates in the original coordinate system andy ^(k) =(x ^(k)) then {y ^(k)} are a set of global Newton method iterates forf _LB(y) and conversely.Karmarkar's algorithm with step size chosen to minimize the potential function is known to converge at least at a linear rate. It is shown (by example) that this algorithm does not have a superlinear convergence rate.     

An implicit function theorem

Suppose thatF:DR ⁿ×R^mRⁿ, withF(x ⁰,y ⁰)=0. The classical implicit function theorem requires thatF is differentiable with respect tox and moreover that ₁ F(x ⁰,y ⁰) is nonsingular. We strengthen this theorem by removing the nonsingularity and differentiability requirements and by replacing them with a one-to-one condition onF as a function ofx.