;

				acGraph.x(orNode[vG]) = drawing.x(CP.copy(vG));
				acGraph.y(orNode[vG]) = drawing.y(CP.copy(vG));

				adjEntry adj;
				forall_adj(adj,vG)
				{
					if ((adj->index() & 1) == 0) continue;
					edge eG = adj->theEdge();

					edge orE = orEdge[eG];
					if (orE)
						drawing.computePolylineClear(CP,eG,acGraph.bends(orE));
				}//foralladj

			}//for

			//even assignment for all nodes is not enough, we need all clusters
			cluster c;
			forall_clusters(c, *workCG)
			{
				int clNumber = c->index();
				int orNumber = originalClId[c];

				if (c!= workCG->rootCluster())
				{
					OGDF_ASSERT(CA.isDefined(clNumber));
					acGraph.clusterHeight(orNumber) = CA[clNumber].m_height;
					acGraph.clusterWidth(orNumber) = CA[clNumber].m_width;
					acGraph.clusterYPos(orNumber) = CA[clNumber].m_miny;
					acGraph.clusterXPos(orNumber) = CA[clNumber].m_minx;
				}//if real cluster
			}//forallclusters

			// the width/height of the layout has been computed by the planar
			// layout algorithm; required as input to packing algorithm
			boundingBox[ikl] = m_planarLayouter.get().getBoundingBox();

	}//for connected components

	//postProcess(acGraph);
	//
	// arrange layouts of connected components
	//

	Array<DPoint> offset(numCC);

	m_packer.get().call(boundingBox,offset,m_pageRatio);

	// The arrangement is given by offset to the origin of the coordinate
	// system. We still have to shift each node, edge and cluster by the offset
	// of its connected component.

	for(int i = 0; i < numCC; ++i)
	{
		const List<node> &nodes = CP.nodesInCC(i);

		const double dx = offset[i].m_x;
		const double dy = offset[i].m_y;

		HashArray<int, bool> shifted(false);

		// iterate over all nodes in ith CC
		ListConstIterator<node> it;
		for(it = nodes.begin(); it.valid(); ++it)
		{
			node v = *it;

			acGraph.x(orNode[v]) += dx;
			acGraph.y(orNode[v]) += dy;

			// update cluster positions accordingly
			int clNumber = cGraph.clusterOf(orNode[v])->index();

			if ((clNumber > 0) &&!shifted[clNumber])
			{
				acGraph.clusterYPos(clNumber) += dy;
				acGraph.clusterXPos(clNumber) += dx;
				shifted[clNumber] = true;
			}//if real cluster

			adjEntry adj;
			forall_adj(adj,v) {
				if ((adj->index() & 1) == 0) continue;
				edge e = adj->theEdge();

				//edge eOr = orEdge[e];
				if (orEdge[e])
				{
					DPolyline &dpl = acGraph.bends(orEdge[e]);
					ListIterator<DPoint> it;
					for(it = dpl.begin(); it.valid(); ++it) {
						(*it).m_x += dx;
						(*it).m_y += dy;
					}//for
				}//if
			}//foralladj
		}//for nodes
	}//for numcc


	while (!connectEdges.empty())
			{
				G.delEdge(connectEdges.popFrontRet());
			}

	if (subGraph)
	{
		originalClId.init();
		orCluster.init();
		orNode.init();
		orEdge.init();
		delete workCG;
		delete workACG;
	}//if subgraph created

	acGraph.removeUnnecessaryBendsHV();

}//call


void ClusterPlanarizationLayout::computeClusterPositions(
	ClusterPlanRep& CP,
	Layout drawing,
	HashArray<int, ClusterPosition>& CA)
{
	edge e;
	forall_edges(e, CP)
	{
		if (CP.isClusterBoundary(e))
		{
			ClusterPosition cpos;
			//minimum vertex position values
			double minx, maxx, miny, maxy;
			minx = min(drawing.x(e->source()), drawing.x(e->target()));
			maxx = max(drawing.x(e->source()), drawing.x(e->target()));
			miny = min(drawing.y(e->source()), drawing.y(e->target()));
			maxy = max(drawing.y(e->source()), drawing.y(e->target()));

			//check if x,y of lower left corner have to be updated
			if (CA.isDefined(CP.ClusterID(e)))
			{
				cpos = CA[CP.ClusterID(e)];

				double preValmaxx = cpos.m_maxx;
				double preValmaxy = cpos.m_maxy;

				if (cpos.m_minx > minx) cpos.m_minx = minx;
				if (cpos.m_miny > miny) cpos.m_miny = miny;
				if (preValmaxx < maxx) cpos.m_maxx = maxx;
				if (preValmaxy < maxy) cpos.m_maxy = maxy;

			}//if
			else
			{
				cpos.m_minx = minx;
				cpos.m_maxx = maxx;
				cpos.m_miny = miny;
				cpos.m_maxy = maxy;
			}//else

			//not necessary for all boundary edges, but we only have the ids
			//to adress, they may have holes
			cpos.m_width = cpos.m_maxx - cpos.m_minx;
			cpos.m_height = cpos.m_maxy - cpos.m_miny;

			//write values back
			CA[CP.ClusterID(e)] = cpos;

		}//if is Boundary
	}//foralledges
}//computeClusterPositions

} // end namespace ogdf
How to get people on to planes is something we have covered many times on this blog. However, it is always interesting when some airline tries something new. That gets us to Delta’s Early Valet (Airlines try to save time with speedier boarding process, Associated Press, Jun 1).
What would you expect to be the most popular post on this blog? Something on lean operations? One of those posts on managing queues? Nope. The most popular post by a wide margin (more than 13,000 page views than the next most popular post) is something Gad wrote in 2011 on how airline ticket prices vary by day of week. The conclusion of that analysis was that Tuesdays are the best day to buy. The story behind this rests on how airlines manage their pricing. While airline revenue management systems are largely automated closing out fare classes on flights as fill up, they do require some human intervention. That intervention tends to happen early in the week as managers evaluate how well leisure fares sold over the weekend.
But is that still true? According to the Wall Street Journal, no (The Best Day to Buy Airline Tickets, Oct 22).
A new deep dive into airline fares suggests Sunday is the best day to find low fares. This is a departure from the conventional wisdom of recent years, when Tuesday was considered the best bet.
Airlines Reporting Corp., which processes tickets for travel agencies and handles about half of all tickets sold, tallied up ticket sales. Over a 19-month period ending in July, 130 million domestic and international round-trip tickets worth $94 billion showed the lowest average price, of $432, was on Sunday. At $439, Saturday’s average is also lower than Tuesday, which averages $497.
Airlines compete, in part, by offering lots of origin-destination pairs. Not matter in which backwater burg you reside, they strive to get you to every equally lonely outpost. That might overstate the case, but most airlines try to offer options that connect most reasonably sized cities. Most airlines consequently favor hub-and-spoke configurations for their networks that funnel passengers