Effects of Flow Update Strategies on Implementation of the Frank ...

132

■ Transportation Research Record 1771 Paper No. 01- 2385

Effects of Flow Update Strategies on Implementation of the Frank–Wolfe Algorithm for the Traffic Assignment Problem Anthony Chen The Frank–Wolfe (FW) algorithm is the predominant algorithm used to solve traffic assignment problems in transportation planning studies. Despite its slow convergence, it remains the most popular choice among practitioners and researchers. One reason for its popularity is that it requires very modest memory storage, which allows planners to solve networks of realistic sizes. Computer random-access memory storage has become extremely cheap, and it is possible to store more information in the FW algorithm to improve the speed of convergence. This information may be required anyway in certain applications, such as optimal routing in route guidance systems, analysis of environmental impact, nonadditive traffic equilibrium problems, and origin-destination matrix estimation. Different flow update strategies are used to examine how to effectively utilize the additional information to improve the performance of the FW algorithm. Implementation of three flow update strategies in the FW algorithm is discussed. Numerical experiments are performed on four test networks of various sizes.

Given travel demand between origin-destination (O-D) pairs and travel cost functions for each link of a network, the traffic assignment problem (static or dynamic) is to determine the flow pattern in the network. It is an important component in transportation planning and real-time applications in optimal routing, signal control, congestion pricing, and traffic prediction in traffic networks. The most widely used algorithm for solving the traffic assignment problem is the Frank–Wolfe (FW) algorithm, which was developed in 1956 to solve a convex quadratic program (1). Depending on the interpretations of the algorithm, FW is also known as linearization, conditional gradient, flow deviation, and convex combinations (2). Despite its known drawbacks (for example, sublinear rate of convergence), FW is easy to implement and requires very modest memory. With a column generation method to implicitly generate paths in the solution, FW can solve the traffic assignment problem with just two vectors of link flows. There is no need to store paths even though path-flow variables existed in the formulation (3). This is a significant benefit because it allows solution of large-scale network problems for which memory requirement was a main concern in the past. However, the computing power and availability of random-access memory that have improved tremendously over the past few years open up the possibility of storing more information in the FW algorithm to improve the speed of convergence. Moreover, this additional information, such as origin-based link flows or path flows, may be Department of Civil and Environmental Engineering, Utah State University, Logan, UT 84322-4110.

required anyway in some applications. Examples of these applications include optimal routing in route guidance systems, analysis of environmental impact, nonadditive traffic equilibrium problems, and O-D matrix estimation. One naive strategy is to simply store the detailed solutions within a standard implementation of the FW algorithm. However, this is not a viable alternative because of the excessive number of iterations (hence more storage requirements) and computational times required to reach a satisfactory convergence. Recently, Chen et al. (4) described a method to accelerate the performance of the FW algorithm by storing path flows to perform a one-O-D-at-a-time flow update. Here, another flow update strategy is described that stores link f lows by origin or destination to update flow one origin at a time. This f low update strategy is an intermediate approach between the traditional FW algorithm, which uses an all-atonce flow update strategy, and the one-O-D-at-a-time flow update strategy. It has more storage requirements than the all-at-once strategy but much less than the one-O-D-at-a-time strategy. Implementation of the FW algorithm with three flow updates is presented. Numerical comparisons of the three the FW variants were done with four networks: two small networks used as a benchmark, one medium-sized realistic network in the city of Anaheim, California, and one large-scale network as the test network in the advanced driver and vehicle advisory navigation concept (ADVANCE) project. Finally, conclusions and suggestions for further study are presented. FLOW UPDATE STRATEGIES For a multicommodity flow problem (more than one origin and one O-D pair), it is possible to implement the traffic assignment algorithm in three different flow update strategies. These three flow update strategies are as follows: • All at once, • One origin at a time, and • One O-D at a time. The traditional FW algorithm uses the all-at-once flow update strategy; that is, all the O-D pairs are processed simultaneously during an iteration by using the link flow pattern obtained at the end of the preceding iteration. In other words, the link cost pattern is updated only once after the flow assignment of all O-D pairs. This strategy is similar to the Jacobi algorithm used in the classic iterative technique for solving systems of linear equations (5). In the one-origin-at-a-time flow update strategy, the origins are processed sequentially in a cyclic

Chen

manner and, following the iteration of one origin, the link flow pattern (hence the link cost pattern) is adjusted to reflect the results of the iteration before carrying out an iteration for the next origin. The oneO-D-at-a-time flow update strategy follows a strategy similar to the one-origin-at-a-time case. The assignment is also carried out sequentially but at one O-D pair at a time with readjustment of link flow and link cost patterns after each O-D pair. These two strategies are sometimes called one-at-a-time flow update and can also be considered a variation of the cyclic coordinate method in nonlinear programming (6) or a special case of the Gauss–Seidel algorithm in the general iterative technique (5). The one-at-a-time flow update strategy is known to converge faster than the all-at-once flow update strategy. Reasons for the faster convergence include the following: (a) it incorporates the latest information resulting from the previous origin (or O-D pair) to update the current origin (or O-D pair), (b) it accounts for the interaction between flows of different origins (O-D pairs), and (c) it approximates the objective function better because of fewer flow variations between the iterations. The core storage requirements for each flow update strategy are as follows: • All at once: 2 × Na; • One origin at a time: 2 × Na + No × Na; and • One O-D at a time: Ni × No × Nn. where Nn, No, and Na are the number of nodes, origins, and links in the network and Ni is the number of iterations to reach convergence. Other minor storage requirements are ignored. As is well known, the traditional FW algorithm, which is implemented with an all-at-once flow update strategy, requires just two vectors of link flows (2 × Na). The one-origin-at-a-time flow update strategy requires 2 × Na + No × Na vectors of which 2 × Na is the same as the all-at-once case. The additional memory requirement is Na × No, which is needed to store the origin-based link flow vectors. The dominant storage in the oneO-D-at-a-time flow update strategy is the path storage. With a predecessor arc list to store the shortest path trees generated for each origin at each iteration, the total path storage amounts to Ni × No × Nn. Alternatively, one can store only the distinct paths generated by the column generation procedure. The storage requirement is at most Np × Nn, where Np is the total number of distinct paths for all O-D pairs. This calculation makes a conservative assumption that, on the average, each path has Nn links. If the number of distinct paths is low, this alternative is useful and has better access time. However, for most realistic networks with many O-D pairs, this alternative is likely to store a great amount of duplicate information because many paths share common stretches of links. Note that Nn, No, and Na are readily fixed by the network topology, but Ni depends on the performance of the algorithm. Therefore, for the one-O-D-at-a-time implementation of the FW algorithm to be of practical use, it is critical that it be able to achieve fast convergence. Based on the computational experiments described in the section on numerical experiments, running the one-O-D-at-a-time FW more than 30 iterations is not recommended. IMPLEMENTATION OF FW ALGORITHM WITH THREE FLOW UPDATE STRATEGIES The popularity of the FW algorithm among practitioners as well as researchers is that it is relatively simple and requires very modest memory. Basically, FW iterates between an all-or-nothing (AON)

Paper No. 01- 2385

133

assignment problem (solving a shortest path problem and loading all the O-D demand to the shortest path) to determine the search direction and a one-dimensional line search problem to find the optimal step size. In this section, detailed steps on implementing the FW algorithm with three flow update strategies are provided. These three FW implementations are denoted ABFW, OBFW, and ODBFW, which correspond to the all-at-once FW, one-origin-at-a-time FW, and one-O-D-at-a-time FW, respectively. The purpose in providing such details of the implementation is twofold: (a) it facilitates the discussion as the flow update strategies are compared and contrasted and (b) it provides sufficient explanations to readers who are interested in coding the algorithms. Notations xa ya za va wa ua ta(xa) qrs δ rska – k rs Krs f ra h ar rs fk rs – hkrs α O  E

= flow on link a, = auxiliary flow on link a, = temporary flow on link a, = background flow on link a, = flow on link a from demand of one O-D pair, = flow on link a from previously assigned path flows of one O-D pair, = travel time on link a, = demand between origin r and destination s, = path-link incidence indicator, = shortest path between origin r and destination s, = path set between origin r and destination s, = flow on link a from origin r, = auxiliary flow on link a from origin r, = flow on path k between origin r and destination s, – = flow on shortest path krs between origin r and destination s, = step size, = objective value, = tolerance, and = maximum percentage change in link flow.

All-at-Once Flow Update Implementation Initialization 1. Set xa (0) = 0 ta(0) = ta[xa (0)] ∀a. 2. Set iteration counter → n = 1. – 3. Solve the shortest path problem for origin r → k rs(n) ∀a.

∀s.

rs 4. Perform an AON assignment → xa (n) = xa (n) + ∑ qrsδ krs ( n ) a s ∈S

5. If origin r is the last origin, then go to the ABFW solver. Otherwise, update link travel time ta(n) = ta[xa(n)], ∀a, and go to Step 3 to solve the shortest path problem for the next origin. ABFW Solver Increment iteration counter → n = n + 1. Update link travel time → ta(n) = ta[xa(n − 1)] ∀a. – Solve shortest path problem for all origins →k rs(n) ∀r, s. Perform an AON assignment to yield an auxiliary link flow rs ∀a. vector → ya (n) = ya (n) + ∑ ∑ qrsδ krs ( n ) a 6. 7. 8. 9.

r ∈R s ∈S

10. Perform line search → min O{x (n) + α[ y (n) − x (n)]}.. 0 ≤ a ≤1

134

Paper No. 01- 2385

Transportation Research Record 1771

11. Update link flows → xa(n) = xa(n − 1) + α[ ya(n) − xa(n − 1)] ∀a. 12. Determine maximum percent change of link flow difference xa (n) − xa (n − 1) × 100 . xa (n − 1)

→ E = max a

4. Perform an AON assignment → f k–rs(n) = qrs rs

∀s.

5. Assign path flows to links → xa (n) = xa (n) +

∑f s ∈S

rs krs ( n )

(n)δ rskrs ( n ) a

∀a.

13. Check convergence → If E ≤ , then stop. Otherwise, go to Step 6.

6. If origin r is the last origin, then go to the ODBFW solver. Otherwise, go to Step 3 and solve the shortest path problem for the next origin.

One-Origin-at-a-Time Flow Update Implementation

ODBFW Solver

Initialization

7. Increment iteration counter → n = n + 1. 8. Set temporary link flows → za (n) = xa (n − 1) ∀a. 9. Update link travel time → ta (n) = ta[za(n)] ∀a. – 10. Solve shortest path problem for origin r → k rs(n) ∀s. – 11. Determine whether krs (n) exists in the path set Krs (n − 1) or not – – if k rs(n) ∉Krs(n − 1), then Krs(n) = Krs(n − 1) ∪ k rs(n). Otherwise, – tag the shortest path among the paths in Krs(n − 1) as k rs(n) and set Krs(n) = Krs(n − 1). rs 12. Perform an AON assignment of one O-D pair → hk–rs (n) = qrs. 13. Assign the AON path flow of one O-D pair to links rs rs → wa(n) = hk–rs (n) δ k–rs (n)a ∀a. 14. Remove previously assigned path flows of the same O-D pair from the link flow pattern = → ua (n) = ∑ f krs (n − 1)δ rska ∀a.

1. Set xa(0) = 0, ta(0) = ta[xa(0)] ∀a and f ar (0) = 0 ∀r,a. 2. Set iteration counter → n = 1. – 3. Solve the shortest path problem for origin r → k rs(n) ∀a.

4. Perform an AON assignment → f (n) = f (n) + r a

r a

∀s.

∑q δ rs

s ∈S

rs krs ( n ) a

5. Sum origin-based link flows to obtain aggregate link flows → xa(n) = xa(n) + f ar (n) ∀a. 6. If origin r is the last origin, then go to the OBFW solver. Otherwise, update link travel time ta (n) = ta[xa(n)] ∀a, and go to Step 3 to solve the shortest path problem for the next origin.

k ∈Krs ( n −1)

OBFW Solver 7. 8. 9. 10. 11.

Increment iteration counter → n = n + 1. Set temporary link flows → za (n) = xa (n − 1) ∀a. Update link travel time → ta (n) = ta[za (n)] ∀a. – ∀s. Solve shortest path problem for origin r → k rs (n) Perform an AON assignment to yield an auxiliary link flow

vector for origin r → h ra(n) =

∑q δ rs

rs krs ( n ) a

∀a.

s ∈S

∀a. 12. Find background traffic → va(n) = za (n) − f ar (n − 1) 13. Add auxiliary link flow vector for origin r to the background traffic to form a feasible auxiliary link flow pattern → ya(n) = va (n) + h ar (n) ∀a. 14. Perform line search → min O{z(n) + α[ y(n) − z(n)]}. 0 ≤ a ≤1

15. Update link flows → za (n) = za (n) + α [ya(n) − za(n)] ∀a. 16. Update link flows for origin r → f ar (n) = f ar (n − 1) + α[har (n) − f ar (n − 1)] ∀a. 17. If this is not the last origin, then increment origin and go to Step 9. Otherwise, go to Step 18. 18. Set xa(n) = za(n) and determine maximum percentage change of link flow difference → E = max a

xa (n) − xa (n − 1) × 100. xa (n − 1)

19. Check convergence → If E ≤ , then stop. Otherwise, go to Step 7. One-O-D-at-a-Time Flow Update Implementation Initialization 1. Set xa (0) = 0 ta(0) = ta[xa(0)] ∀a and Krs (0) = φ ∀r, s. 2. Set iteration counter → n = 1. – 3. Solve the shortest path problem for origin r → k rs (n), – Krs(n) = Krs(n − 1) ∪ k rs(n) ∀s.

15. Find the background traffic → va(n) = za(n) − ua(n) ∀a. 16. Add the one O-D auxiliary link flows to the background traffic to form a feasible auxiliary link flow pattern → ya (n) = va (n) + wa (n) ∀a. 17. Perform line search → min O{z(n) + α[ y(n) − z(n)]}. 0 ≤ a ≤1

18. Update link flows → za (n) = za (n) + α [ ya(n) − za (n)] ∀a. rs 19. Update path flows → f rsk (n) = f rsk (n − 1) − α [h k–rs (n) − f rsk(n − 1)] ∀k. 20. If this is not the last O-D pair of the origin, then go to Step 11 and solve the next O-D pair of the same origin; if this is the last O-D pair of the origin, then move to the next origin and go to Step 9; if this is the last origin, then go to Step 21. 21. Set xa (n) = za (n) and determine maximum percent change of xa (n) − xa (n − 1) × 100. xa (n − 1) 22. Check convergence → if E ≤ , then stop. Otherwise, go to Step 7.

link flow difference → E = max a

Discussions of Results All three implementations use a one-origin-at-a-time flow update in the initialization step to yield a better starting solution. However, this one-at-a-time flow update strategy cannot be used during the iteration process of the FW algorithm unless additional information (for example, origin-based link flows or path flows) is stored. The reason is that the line search step requires the auxiliary link flow vector resulting from the AON assignment of one origin (or O-D pair) to be compatible with the current link flow vector, which is composed of network demand from all origins (or all O-D pairs). Without storing additional information, it is not possible to remove the background traffic from the current link flow vector and add them to the one origin (or O-D pair) auxiliary link flow vector to form a feasible auxiliary link flow vector (see Steps 11–13 in the OBFW algorithm and Steps 12–16 in the

Chen

Paper No. 01- 2385

ODBFW algorithm). This is the key behind the one-at-a-time flow update strategy in the FW algorithm. However, the efficiency of one-at-a-time flow update implementation likely depends on the number of commodities (origins or O-D pairs) because a separate line search is required for each commodity. Chen et al. (4) introduced several heuristics to streamline the computational requirements for the ODBFW algorithm. These heuristics include (a) skipping the flow update for the O-D pairs with only one path, (b) skipping the line search step if the O-D pair does not lead to a decrease in the objective value, and (c) using only the set of links that are on the paths of the O-D pair to perform the line search step because all other links in the network have no effect on the calculation. These heuristics not only accelerate the convergence by reducing the computational time but also avoid assigning trips to undesired paths that are not likely to be part of an optimal solution. In particular, heuristic b has the ability to eliminate the cyclic flow problem that tends to retard the convergence of the FW algorithm (7 ). More details about the ODBFW algorithm can be found elsewhere (4). NUMERICAL EXPERIMENTS The FW algorithm was tested with three different flow update implementations on four test networks. The basic data for these networks are presented in Table 1. • Network 1: Link characteristics and O-D demands can be found elsewhere (8). • Network 2: This network is the classic Sioux Falls network that has been used as a benchmark for many studies. The details of this network are given elsewhere (9). • Network 3: This is a medium-sized network located in the city of Anaheim, California. It was used elsewhere (10, 11) to test the path-based gradient projection algorithm. • Network 4: This is a large-scale network located in the northwestern suburbs of Chicago. It was used as the test network for the ADVANCE project (12). The results of the three flow update implementations of the FW algorithm reported in the following sections were tested with a PC with Pentium III processor (500 MHz). For each network, the objective values of the 10 first iterations are reported for the three flow update implementations. For Network 1 and Network 2, the computational times are not reported because these are small toy networks. The purpose is to compare with known results reported in the transportation literature. For the larger networks, the computational performance of the three FW variants is also reported.

TABLE 1

135

Results for Network 1 The objective values of the first 10 iterations are presented in Figure 1 for the three FW variants. The objective value at the 10th iteration for ODBFW is lower than that of OBFW, and the objective value for OBFW is less than that of ABFW. The converged objective value reported elsewhere (8) is 85,028. ODBFW obtains the same value at the 18th iteration. Both OBFW and ABFW terminate at the maximum iterations without reaching the converged objective value. OBFW terminates at 500 iterations with an objective value of 85,042, whereas ABFW terminates at 1,000 iterations with an objective value 85,035. Results for Network 2 Network 2 is a well-known numerical example often used in the transportation literature as a benchmark for comparison. Figure 2 clearly indicates that both one-origin-a-time and one-O-D-at-atime FW are better than the traditional all-at-once FW and that oneO-D-at-a-time is slightly better than one-origin-at-a-time in the first 10 iterations. At termination, ODBFW yields an objective value of 42.3144 at the 14th iteration, whereas both OBFW and ABFW did not obtain the same objective value at the preset maximum number of iterations. OBFW terminates at the 500th iteration with an objective value of 42.3156, and ABFW attains an objective value of 42.3179 at the 1,000th iteration. Results for Network 3 The results from the two small networks indicate that both oneorigin-at-a-time and one-O-D-at-a-time FW algorithms converge faster than the traditional all-at-once FW algorithm. How do they perform on real networks? Similar results are delineated for the Anaheim network, as indicated in Figure 3. Both one-at-a-time FW algorithms show a distinct advantage over the all-at-once FW algorithm. A typical objective value in the 5th iteration of the ODBFW algorithm would correspond to the objective values in the 40th and 250th iterations of OBFW and ABFW, respectively. As the algorithm approaches the neighborhood of the optimal solution, ABFW performs extremely poorly because of the zigzagging behavior (sublinear rate of convergence). OBFW and

Data for Test Networks

FIGURE 1

Results for Network 1.

136

Paper No. 01- 2385

Transportation Research Record 1771

FIGURE 2

Results for Network 2.

FIGURE 3

Results for Network 3.

ODBFW can correct some of the zigzagging problem by performing more frequent flow updates. This is evident from the terminating objective values of the three algorithms. ODBFW terminates at the 10th iteration with an objective value of 1,205,626. OBFW requires 409 iterations to yield the same objective value, whereas ABFW cannot reach that value at the maximum number of iterations. Its terminating objective value at the 1,000th iteration was 1,205,629. In terms of the computational times presented in Figure 4, the objective values of ODBFW, OBFW, and ABFW corresponding to about 10 s are 1,205,625, 1,205,645, and 1,205,632, respectively. In this instance, it appears that OBFW performs worse than ABFW. However, as noted previously, OBFW takes fewer than half the number of iterations as ABFW to converge to the same objective value of ODBFW. The ODBFW algorithm is surprising. It outperforms ABFW even in the early iterations. It is suspected that the heuristics discussed previously have helped to significantly reduce

FIGURE 4 Comparison of model convergence for Network 3 (CPU = central processing unit).

Chen

Paper No. 01- 2385

137

Results for Network 4

FIGURE 5 All-at-once FW with and without path storage for Network 3.

the number of O-D pairs required for flow update in this network. The results indicate that the average number of line searches for the first 10 iterations is fewer than 300 of 1,406 O-D pairs, and the average number of links used in the line search step is fewer than 30 (about 3.3 percent of 914 links in the network). These simple heuristics prove to be useful in streamlining the efficiency of the one-O-D-at-a-time FW algorithm. Figure 5 compares the computational times in each iteration between the all-at-once FW algorithm with and without path storage (ABFWP and ABFW). The time required for storing and processing paths in ABFWP is quite significant (about three times that of ABFW) because there are many more redundant paths to be filtered out. It is much more difficult to access the distinct paths when many shortest path trees exist, and many of the paths are repeated over these trees. Also, the memory requirements to store the trees built during all iterations are much higher than for ODBFW because it is proportional to the number of iterations taken to reach convergence. Figure 6 compares the computational time saving between a naive implementation of the FW algorithm with path storage (ABFWP) and the ODBFW that takes advantage of the path information to speed up the convergence. The speed-up ratio between ABFWP and ODBFW is more than five times.

FIGURE 6

Comparison of ABFWP and ODBFW for Network 3.

The last network is taken from the ADVANCE project. This largescale network covers about 300 mi2 (777 km2) in the northwestern suburbs of Chicago. The convergence behavior of the three FW variants is similar to the results presented for Network 3. As indicated in Figure 7, both ODBFW and OBFW attain a much lower objective value on a logarithmic scale compared with that in ABFW. At the 10th iteration, the objective values on a logarithmic scale of ODBFW, OBFW, and ABFW are 4.0964, 4.0974, and 4.1079, respectively. Figure 8 presents the convergence of three FW variants for 1000 s. Despite the fact that ODBFW requires the most computational time per iteration, its objective value is lower than that of OBFW and ABFW. The actual objective values of ODBFW, OBFW, and ABFW are 4.096698, 4.096743, and 4.096823, respectively. For the first 10 iterations of the ODBFW algorithm, the average number of O-D pairs required a separate line search, for each O-D pair is 50,441 (about 36.71 percent of 137,417 O-D pairs), and the average number of links performed in each line search step is 80 (about 1.02 percent of 7,850 links in the network). The importance of these simple heuristics should be emphasized. Without them, the computational time would be significantly higher. As the network size increases, the amount of time required for storing and processing paths also increases tremendously. As indicated in Figure 9, the computational time difference between ABFWP and ABFW (all-at-once FW with and without storing paths) is about tenfold. It is easy to see why ODBFW is more practical when detailed solutions such as path flows are needed in a FW-based solution algorithm. Figure 10 indicates that ODBFW can achieve a better solution (lower objective value) with less computational time than ABFWP. The speed-up ratio between ABFWP and ODBFW is at least four times. In addition, it should be noted that ODBFW takes much fewer iterations to reach a satisfactory convergence (hence less storage requirements) and clearly is a better alternative to the naive implementation of FW with path storage.

CONCLUSIONS The implementation of the FW algorithm with three flow update strategies has been presented here. The three flow update strategies are all-at-once, one-origin-at-a-time, and one-O-D-at-a-time. These variants of the FW algorithm were also tested on four networks, ranging from two small networks, commonly used in the transportation literature for comparisons, to a medium-sized network and a large-scale network of actual cities in the United States. The results indicate that a FW implementation with a one-at-a-time flow update strategy indeed takes less iteration to reach convergence but requires more computational time per iteration. This is understandable because the one-at-a-time flow update strategy requires a separate line search for each origin (or O-D pair). We have designed some heuristics to streamline the efficiency of the one-O-D-at-a-time FW algorithm by cutting down the number of line searches and by reducing the computational effort of performing the line search step with only a small subset of network links (4). One unique feature of these heuristics is that it avoids assigning flows to undesired paths that may introduce cyclic flows and retard convergence (7). Variations of these heuristics can also be incorporated in the one-origin-at-a-time FW algorithm. The advantages of the one-at-a-time FW algorithms are faster convergence, better computational time (in some cases), and more output results such as origin-based link flows or path flows that are increasingly important in many applications such as optimal routing,

FIGURE 7

Results for Network 4.

FIGURE 8

Comparison of model convergence for Network 4.

FIGURE 9 All-at-once FW with and without path storage for Network 4.

FIGURE 10

Comparison of ABFWP and ODBFW for Network 4.

Chen

nonadditive traffic equilibrium problems, O-D matrix estimation, and sensitivity-based algorithm for bilevel programs. Finally, these flow update strategies may be useful in other algorithms used to solve different classes of traffic assignment problems.

REFERENCES 1. Frank, M., and P. Wolfe. An Algorithm for Quadratic Programming. Naval Research Logistics Quarterly, Vol. 3, 1956, pp. 95–110. 2. Patriksson, M. The Traffic Assignment Problem: Models and Methods. VNU Science Press, Utrecht, Netherlands, 1994. 3. Sheffi, Y. Urban Traffic Networks: Equilibrium Analysis with Mathematical Programming Methods. Prentice Hall, Englewood Cliffs, N.J., 1985. 4. Chen, A., R. Jayakrishnan, and W. K. Tsai. Accelerating the Convergence of the Frank–Wolfe Algorithm for the Traffic Assignment Problem with One-at-a-Time Flow Update Strategy. Journal of Transportation Engineering (in press). 5. Bertsekas, D., and J. Tsitsiklis. Parallel and Distributed Computation— Numerical Methods. Prentice Hall, Englewood Cliffs, N.J., 1989.

Paper No. 01- 2385

139

6. Bazaraa, M., and C. Shetty. Nonlinear Programming: Theory and Algorithms. John Wiley & Sons, New York, 1979. 7. Janson, B. N., and C. Zozaya-Gorostiza. An Efficient Approach to Solving the Road Network Equilibrium Traffic Assignment Problem. Transportation Research B, Vol. 21, 1987, pp. 309–318. 8. Nguyen, S., and C. Dupuis. An Efficient Method for Computing Traffic Equilibria in Networks with Asymmetric Transportation Costs. Transportation Science, Vol. 18, No. 1, 1984, pp. 185–202. 9. LeBlanc, L. J., E. K. Morlok, and W. P. Pierskalla. An Efficient Approach to Solving the Road Network Equilibrium Traffic Assignment Problem. Transportation Research, Vol. 9, 1975, pp. 309–318. 10. Jayakrishnan, R., W. K. Tsai, J. N. Prashker, and S. Rajadhyaksha. Faster Path-Based Algorithm for Traffic Assignment. In Transportation Research Record 1443, TRB, National Research Council, Washington, D.C., 1994, pp. 75–83. 11. Chen, A., and R. Jayakrishnan. A Path-Based Gradient Projection Algorithm: Effects of Equilibration with Restricted Path Set Under Two Flow Update Policies. Presented at 77th Annual Meeting of the Transportation Research Board, Washington, D.C., 1998. 12. Zhang, Y., J. Hicks, and D. E. Boyce. Trip Data Fusion in ADVANCE. ADVANCE Working Paper No. 43. Urban Transportation Center, University of Illinois, Chicago, 1994.