///<param name="onlyNonTrivialZeros">
///If true, only empty expansion lists will be returned,
///and of those none will correspond to z values that are divisible by 3.
///</param>
public static IEnumerable <KeyValuePair <BigInteger, BigInteger> > IterateExpansionCounts(BigInteger maxZ, bool onlyNonTrivialZeros = false, Action <ExpansionTerm> currentPathStartingPointPrinter = null)
{
var termOptions = new TermOptionsMatrix(maxZ);
var foundExpansionCounts = new Dictionary <BigInteger, BigInteger>();
BigInteger prevStartingPointEval = BigInteger.Zero; //Starts lower than any evaluated starting point
foreach (ExpansionTerm pathStartingPoint in EnumerateSortedTermOptions())
{
currentPathStartingPointPrinter?.Invoke(pathStartingPoint);
BigInteger startingPointEval = pathStartingPoint.Evaluate();
if (startingPointEval > maxZ)
{
//If gone past end of requested range, return all remaining stored values
//up to end of requested range, then stop enumerating.
for (BigInteger i = prevStartingPointEval + 1; i <= maxZ; i++)
{
BigInteger countToYield;
if (TryGetExpansionCountToYield(foundExpansionCounts, i, onlyNonTrivialZeros, out countToYield))
{
yield return(new KeyValuePair <BigInteger, BigInteger>(i, countToYield));
}
}
yield break;
}
foreach (BigInteger summedPath in termOptions.EnumerateSummedExpansionPaths(pathStartingPoint, capToMaximum: true))
{
BigInteger existingCount;
if (foundExpansionCounts.TryGetValue(summedPath, out existingCount))
{
if (!onlyNonTrivialZeros)
{
foundExpansionCounts[summedPath] = existingCount + 1;
}
}
else
{
foundExpansionCounts.Add(summedPath, 1);
}
}
for (BigInteger i = prevStartingPointEval + 1; i <= startingPointEval; i++)
{
BigInteger countToYield;
if (TryGetExpansionCountToYield(foundExpansionCounts, i, onlyNonTrivialZeros, out countToYield))
{
yield return(new KeyValuePair <BigInteger, BigInteger>(i, countToYield));
}
}
prevStartingPointEval = startingPointEval;
}
}
///<param name="onlyNonTrivialZeros">
///If true, only empty expansion lists will be returned,
///and of those none will correspond to z values that are divisible by 3.
///</param>
public static IEnumerable <KeyValuePair <int, int> > IterateExpansionCounts_array(int maxZ, bool onlyNonTrivialZeros = false, Action <ExpansionTerm> currentPathStartingPointPrinter = null)
{
var termOptions = new TermOptionsMatrix(maxZ);
var expansionCounts = new int[maxZ + 1];
int prevStartingPointEval = 0; //Starts lower than any evaluated starting point
foreach (ExpansionTerm pathStartingPoint in EnumerateSortedTermOptions())
{
currentPathStartingPointPrinter?.Invoke(pathStartingPoint);
int startingPointEval = (int)pathStartingPoint.Evaluate();
if (startingPointEval > maxZ)
{
//If gone past end of requested range, return all remaining stored values
//up to end of requested range, then stop enumerating.
for (int i = prevStartingPointEval + 1; i <= maxZ; i++)
{
int countToYield;
if (TryGetExpansionCountToYield_array(expansionCounts, i, onlyNonTrivialZeros, out countToYield))
{
yield return(new KeyValuePair <int, int>(i, countToYield));
}
}
yield break;
}
foreach (BigInteger summedPath in termOptions.EnumerateSummedExpansionPaths(pathStartingPoint, capToMaximum: true))
//foreach (var expansionPath in termOptions.EnumerateExpansionPaths(pathStartingPoint, capToMaximum: true))
{
//int intSummedPath = (int)expansionPath.Sum;
int intSummedPath = (int)summedPath;
int existingCount = expansionCounts[intSummedPath];
if (!onlyNonTrivialZeros || existingCount == 0)
{
expansionCounts[intSummedPath] = existingCount + 1;
}
}
for (int i = prevStartingPointEval + 1; i <= startingPointEval; i++)
{
int countToYield;
if (TryGetExpansionCountToYield_array(expansionCounts, i, onlyNonTrivialZeros, out countToYield))
{
yield return(new KeyValuePair <int, int>(i, countToYield));
}
}
prevStartingPointEval = startingPointEval;
}
}
public static IEnumerable <BigInteger> IterateNonTrivialZeros_bitarray(int maxZ, Action <ExpansionTerm> currentPathStartingPointPrinter = null)
{
var termOptions = new TermOptionsMatrix(maxZ);
var eliminatedPoints = new BitArray(length: maxZ + 1);
int prevStartingPointEval = 0; //Starts lower than any evaluated starting point
foreach (ExpansionTerm pathStartingPoint in EnumerateSortedTermOptions())
{
currentPathStartingPointPrinter?.Invoke(pathStartingPoint);
int startingPointEval = (int)pathStartingPoint.Evaluate();
if (startingPointEval > maxZ)
{
//If gone past end of requested range, return all remaining stored values
//up to end of requested range, then stop enumerating.
for (int i = prevStartingPointEval + 1; i <= maxZ; i++)
{
if (i % 3 != 0 && eliminatedPoints[i] == false)
{
yield return(i);
}
}
yield break;
}
foreach (BigInteger summedPath in termOptions.EnumerateSummedExpansionPaths(pathStartingPoint, capToMaximum: true))
{
int intSummedPath = (int)summedPath;
eliminatedPoints[intSummedPath] = true;
}
for (int i = prevStartingPointEval + 1; i <= startingPointEval; i++)
{
if (i % 3 != 0 && eliminatedPoints[i] == false)
{
yield return(i);
}
}
prevStartingPointEval = startingPointEval;
}
}
public static IEnumerable <BigInteger> IterateNonTrivialZeros(BigInteger maxZ, Action <ExpansionTerm> currentPathStartingPointPrinter = null)
{
var termOptions = new TermOptionsMatrix(maxZ);
// var sortedEliminatedRanges = new List<BigIntRange>();
var eliminatedRanges = new RangeSet();
BigInteger prevStartingPointEval = BigInteger.Zero; //Starts lower than any evaluated starting point
foreach (ExpansionTerm pathStartingPoint in EnumerateSortedTermOptions())
{
currentPathStartingPointPrinter?.Invoke(pathStartingPoint);
// Console.WriteLine("#25 current starting point: " + pathStartingPoint);
// //Debugging:
// eliminatedRanges.DebugBounds();
// foreach (var range in eliminatedRanges.IncludedRanges) {
// Console.WriteLine("#40: " + range.Start + " to " + range.End);
// }
// Console.WriteLine("#41: " + eliminatedRanges.Count);
BigInteger startingPointEval = pathStartingPoint.Evaluate();
if (startingPointEval > maxZ)
{
//If gone past end of requested range, return all remaining stored values
//up to end of requested range, then stop enumerating.
var gaps = eliminatedRanges.EnumerateExcludedValues(
searchRange: BigIntRange.CreateStartEnd(
start: prevStartingPointEval + 1,
end: maxZ
)
);
foreach (BigInteger gap in gaps)
{
yield return(gap);
}
// foreach (var range in eliminatedRanges.IncludedRanges) {
// Console.WriteLine("#42: " + range.Start + " to " + range.End);
// }
// Console.WriteLine("#43: " + eliminatedRanges.Count);
yield break;
}
foreach (BigInteger summedPath in termOptions.EnumerateSummedExpansionPaths(pathStartingPoint, capToMaximum: true))
{
// Console.WriteLine("#44: " + summedPath + ", " + expansionPath.ToString(includeSpaces: false));
BigInteger newRangeMax = summedPath;
BigInteger newRangeMin = summedPath;
// Console.WriteLine("#44.1: " + newRangeMin + ", " + newRangeMax);
//Exclude adjacent trivial zeros (multiples of 3) as well
if ((newRangeMax + 1) % 3 == 0)
{
newRangeMax += 1;
}
if ((newRangeMin - 1) % 3 == 0)
{
newRangeMin -= 1;
}
// Console.WriteLine("#44.2: " + newRangeMin + ", " + newRangeMax);
// Console.WriteLine("#45: " + eliminatedRanges.Count);
eliminatedRanges.AddRange(BigIntRange.CreateStartEnd(newRangeMin, newRangeMax));
// Console.WriteLine("#46: " + eliminatedRanges.Count);
}
{
// Console.WriteLine("#47: " + eliminatedRanges.Count);
var gaps = eliminatedRanges.EnumerateExcludedValues(
searchRange: BigIntRange.CreateStartEnd(
start: prevStartingPointEval + 1,
end: startingPointEval
)
);
foreach (BigInteger gap in gaps)
{
yield return(gap);
}
// Console.WriteLine("#48");
}
prevStartingPointEval = startingPointEval;
}
}