ldforge: comparison src/ringFinder.cpp

-:12f9ea615cbc
+:314e12e23c3a
 RingFinder::RingFinder() {}
 // =============================================================================
 //
-bool RingFinder::findRingsRecursor (double r0, double r1, Solution& currentSolution)
+bool RingFinder::findRingsRecursor(double r0, double r1, Solution& currentSolution)
 {
 	// Don't recurse too deep.
 	if (m_stack >= 5 or r1 < r0)
 		return false;
 	// Find the scale and number of a ring between r1 and r0.
 	double scale = r1 - r0;
 	double num = r0 / scale;
 	// If the ring number is integral, we have found a fitting ring to r0 -> r1!
-	if (isInteger (num))
+	if (isInteger(num))
 	{
 		Component cmp;
 		cmp.scale = scale;
-		cmp.num = (int) round (num);
+		cmp.num = (int) round(num);
-		currentSolution.addComponent (cmp);
+		currentSolution.addComponent(cmp);
 		// If we're still at the first recursion, this is the only
 		// ring and there's nothing left to do. Guess we found the winner.
 		if (m_stack == 0)
 		{
-			m_solutions.push_back (currentSolution);
+			m_solutions.push_back(currentSolution);
 			return true;
 		}
 	}
 	else
 	{
 		// Try find solutions by splitting the ring in various positions.
-		if (isZero (r1 - r0))
+		if (isZero(r1 - r0))
 			return false;
 		double interval;
 		// Determine interval. The smaller delta between radii, the more precise
 		for (double r = r0 + interval; r < r1; r += interval)
 		{
 			Solution sol = currentSolution;
 			m_stack++;
-			bool res = findRingsRecursor (r0, r, sol) and findRingsRecursor (r, r1, sol);
+			bool res = findRingsRecursor(r0, r, sol) and findRingsRecursor(r, r1, sol);
 			m_stack--;
 			if (res)
 			{
 				// We succeeded in finding radii for this segment. If the stack is 0, this
 				//
 				// If not, when this function ends, it will be called again with more arguments.
 				// Accept the solution to this segment by setting currentSolution to sol, and
 				// return true to continue processing.
 				if (m_stack == 0)
-					m_solutions.push_back (sol);
+					m_solutions.push_back(sol);
 				else
 				{
 					currentSolution = sol;
 					return true;
 				}
 	return true;
 }
 //
 // This is the main algorithm of the ring finder. It tries to use math
-// to find the one ring between r0 and r1. If it fails (the ring number
+// to find the one ring between r0 and r1. If it fails(the ring number
-// is non-integral), it finds an intermediate radius (ceil of the ring
+// is non-integral), it finds an intermediate radius(ceil of the ring
 // number times scale) and splits the radius at this point, calling this
 // function again to try find the rings between r0 - r and r - r1.
 //
 // This does not always yield into usable results. If at some point r ==
 // r0 or r == r1, there is no hope of finding the rings, at least with
 // this algorithm, as it would fall into an infinite recursion.
 //
-bool RingFinder::findRings (double r0, double r1)
+bool RingFinder::findRings(double r0, double r1)
 {
 	m_solutions.clear();
 	Solution sol;
 	// If we're dealing with fractional radii, try upscale them into integral
 	// ones. This should yield in more reliable and more optimized results.
 	// For instance, using r0=1.5, r1=3.5 causes the algorithm to fail but
-	// r0=3, r1=7 (scaled up by 2) yields a 2-component solution. We can then
+	// r0=3, r1=7(scaled up by 2) yields a 2-component solution. We can then
 	// downscale the radii back by dividing the scale fields of the solution
 	// components.
 	double scale = 1.0;
-	if (not isZero (scale = r0 - floor (r0)) or not isZero (scale = r1 - floor (r1)))
+	if (not isZero(scale = r0 - floor(r0)) or not isZero(scale = r1 - floor(r1)))
 	{
 		double r0f = r0 / scale;
 		double r1f = r1 / scale;
-		if (isInteger (r0f) and isInteger (r1f))
+		if (isInteger(r0f) and isInteger(r1f))
 		{
 			r0 = r0f;
 			r1 = r1f;
 		}
 		// If the numbers are both at most one-decimal fractions, we can use a scale of 10
-		else if (isInteger (r0 * 10) and isInteger (r1 * 10))
+		else if (isInteger(r0 * 10) and isInteger(r1 * 10))
 		{
 			scale = 0.1;
 			r0 *= 10;
 			r1 *= 10;
 		}
 	{
 		scale = 1.0;
 	}
 	// Recurse in and try find solutions.
-	findRingsRecursor (r0, r1, sol);
+	findRingsRecursor(r0, r1, sol);
 	// If we had upscaled our radii, downscale back now.
 	if (scale != 1.0)
 	{
 		for (Solution& sol : m_solutions)
-			sol.scaleComponents (scale);
+			sol.scaleComponents(scale);
 	}
 	// Compare the solutions and find the best one. The solution class has an operator>
 	// overload to compare two solutions.
 	m_bestSolution = nullptr;
 	for (Solution const& sol : m_solutions)
 	{
-		if (m_bestSolution == nullptr or sol.isSuperiorTo (m_bestSolution))
+		if (m_bestSolution == nullptr or sol.isSuperiorTo(m_bestSolution))
 			m_bestSolution = &sol;
 	}
 	return (m_bestSolution);
 }
 // yield less new primitives and cleaner definitions.
 //
 // The solution which is found superior to every other solution
 // will be the one returned by RingFinder::bestSolution().
 //
-bool RingFinder::Solution::isSuperiorTo (const Solution* other) const
+bool RingFinder::Solution::isSuperiorTo(const Solution* other) const
 {
 	// If one solution has less components than the other one, it is definitely
 	// better.
 	if (getComponents().size() != other->getComponents().size())
 		return getComponents().size() < other->getComponents().size();
 	int maxA = 0,
 		maxB = 0;
 	for (int i = 0; i < getComponents().size(); ++i)
 	{
-		maxA = qMax (getComponents()[i].num, maxA);
+		maxA = qMax(getComponents()[i].num, maxA);
-		maxB = qMax (other->getComponents()[i].num, maxB);
+		maxB = qMax(other->getComponents()[i].num, maxB);
 	}
 	if (maxA != maxB)
 		return maxA < maxB;
 	// just say this one is better, at this point it does not matter which
 	// one is chosen.
 	return true;
 }
-void RingFinder::Solution::scaleComponents (double scale)
+void RingFinder::Solution::scaleComponents(double scale)
 {
 	for (Component& cmp : m_components)
 		cmp.scale *= scale;
 }

Mercurial > ldforge / file comparison

comparison: src/ringFinder.cpp

src/ringFinder.cpp