long decimatorCost = SCALE_FACTOR * (popCount > 1 ? 4 * cols : 0);
long decimatorCost = SCALE_FACTOR * (popCount > 1 ? 100 + 4 * cols : 0);
    public long getFrequencyCost() {	// Multiply by factor of 4 because above we count multilies 3	// times and adds once.  Even though we only add N-1 times for	// a column of N, we add again for the constant vector, so	// it's not off by one.  Then add the rows to represent the	// overhead of copying input items, and of doing the FFT (it	// might actually be rows*log(rows) or something, but	// disregard this.)  Finally, multiply by the pop count since	// we have to duplicate the whole effort for every item that	// we pop.	// okay.  this works by taking the fft cost, adding 1 as a	// constant overhead per node, adding a small percentage of	// the rows cost to indicate copying overhead (if you don't	// divide by 100, then this completely dominates and will	// distort the partitioning), then multiply by popcount since	// the node has to be repeated, redundantly, if some of its	// outputs are useless.	double nodeCost = ((double)SCALE_FACTOR) * (getFrequencyComputationCost() + 1.0 + ((float)(2*cols))) * ((double)Math.max(popCount,1));	// just count the pushing since popping is almost free, all at	// once.  count it twice since you have to read it and write	// it.	long decimatorCost = SCALE_FACTOR * (popCount > 1 ? 4 * cols : 0);	if (LinearPartitioner.DEBUG) { System.err.println("Returning linear cost of " + ((long)nodeCost + decimatorCost) + " with: \n"							  + "  frequencyComputationCost=" + getFrequencyComputationCost() + "\n"							  + "  nodeCost=" + nodeCost + "\n"							  + "  decimatorCost=" + decimatorCost + "\n"							  + "  rows=" + rows + "\n"							  + "  cols=" + cols + "\n"							  + "  popCount=" + popCount); }	return (long)nodeCost + decimatorCost;    }