protected static bool[] GetVector(CountDictionary primeFactorizationDict, BigInteger maxValue)
{
int primeIndex = PrimeFactory.GetIndexFromValue(maxValue);
bool[] result = new bool[primeIndex];
if (primeFactorizationDict.Any())
{
foreach (KeyValuePair <BigInteger, BigInteger> kvp in primeFactorizationDict)
{
if (kvp.Key > maxValue)
{
continue;
}
if (kvp.Key == -1)
{
continue;
}
if (kvp.Value % 2 == 0)
{
continue;
}
int index = PrimeFactory.GetIndexFromValue(kvp.Key);
result[index] = true;
}
}
return(result);
}
int RawDamageFromParticipatingAttackers(CountDictionary <HealthToken> participatingAttacker)
{
return(participatingAttacker.Keys
.OfType <HealthToken>()
.Where(x => x.StrifeCount == 0)
.Select(attacker => cfg.DamageFromAttacker(attacker) * participatingAttacker[attacker]).Sum());
}
/// <returns>([Key][count]) ordered alphabetically or '[none]' if empty</returns>
/// <example>1C@3,1E@1,1T@2</example>
static public string TokenSummary <T>(this CountDictionary <T> dict)
{
return(dict.Count == 0 ? "[none]"
: dict
.OrderBy(p => p.Key.ToString())
.Select(p => p.Value + p.Key.ToString())
.Join(","));
}
CountDictionary <HealthToken> GetParticipantCounts(Func <HealthToken, bool> filter)
{
var participants = new CountDictionary <HealthToken>();
foreach (var token in Tokens.Keys.OfType <HealthToken>().Where(filter))
{
participants[token] = Math.Max(0, Tokens[token] - cfg.NotParticipating[token]);
}
return(participants);
}
public CountDictionary <K> Clone()
{
var clone = new CountDictionary <K>();
foreach (var invader in Keys)
{
clone[invader] = this[invader];
}
return(clone);
}
/// <summary>
/// Defend has already been applied.
/// </summary>
public int GetDamageInflictedByAttackers()
{
int rawDamageFromAttackers = RawDamageFromParticipatingAttackers(@event.startingAttackers);
this.currentAttackers = FromEachStrifed_RemoveOneStrife(@event.startingAttackers); // does not change start state, modifies gs.Tokens[...] instead
// Defend
@event.defend = Tokens.Defend.Count;
int damageInflictedFromAttackers = Math.Max(rawDamageFromAttackers - @event.defend, 0);
return(damageInflictedFromAttackers);
}
/// <summary>
/// Set-like operation. Returns a new CountDictionary containing current items less other items
/// </summary>
public CountDictionary <K> Except(IDictionary <K, int> other)
{
var result = new CountDictionary <K>();
foreach (var key in this.Keys)
{
int missing = this[key] - other[key];
if (missing > 0)
{
result[key] = missing;
}
}
return(result);
}
public static ulong Solve_SortedSet(ulong[] arr, ulong m)
{
// 10000000 - ??? ms
var sumsLeft = new ulong[arr.Length];
sumsLeft[0] = arr[0] % m;
for (var i = 1; i < arr.Length; i++)
{
sumsLeft[i] = (sumsLeft[i - 1] + arr[i]) % m;
}
var sumsSorted = new SortedSet <ulong>(sumsLeft);
var sumsCount = new CountDictionary <ulong>(sumsLeft);
var max = arr[0] % m;
for (var i = 0; i < arr.Length; i++)
{
var left = i == 0 ? 0ul : sumsLeft[i - 1];
var searchme = left == 0 ? (m - 1) : (left - 1);
var searchResult = sumsSorted.GetViewBetween(0, searchme);
if (searchResult.Count > 0)
{
max = Math.Max(max, (searchResult.Max + m - left) % m);
}
var removeMe = sumsLeft[i];
sumsCount.Decrement(removeMe);
if (sumsCount.Stat(removeMe) == 0)
{
sumsSorted.Remove(removeMe);
}
}
return(max);
}
/// <returns>New attacker finvaders</returns>
CountDictionary <HealthToken> FromEachStrifed_RemoveOneStrife(CountDictionary <HealthToken> participatingInvaders)
{
var newAttackers = participatingInvaders.Clone();
var strifed = participatingInvaders.Keys
.OfType <HealthToken>()
.Where(x => x.StrifeCount > 0)
.OrderBy(x => x.StrifeCount) // smallest first
.ToArray();
foreach (var orig in strifed)
{
// update tracking counts
int count = Tokens[orig];
newAttackers[orig] -= count;
newAttackers[orig.AddStrife(-1)] += count;
// update real tokens
Tokens.RemoveStrife(orig, Tokens[orig]);
}
return(newAttackers);
}
static HealthToken PickSmartInvaderToDamage(CountDictionary <HealthToken> participatingInvaders, int availableDamage)
{
return(PickItemToKill(participatingInvaders.Keys, availableDamage)
?? PickItemToDamage(participatingInvaders.Keys));
}
public int GetDamageInflictedByDefenders()
{
CountDictionary <HealthToken> participants = GetDefenders();
return(participants.Sum(pair => pair.Key.Class.Attack * pair.Value));
}
public TokenCountDictionary(Space space, CountDictionary <Token> counts, IIslandTokenApi tokenApi)
{
this.Space = space;
this.counts = counts;
this.tokenApi = tokenApi;
}
public static void GaussianSolve(CancellationToken cancelToken, GNFS gnfs)
{
Serialization.Save.Relations.Smooth.Append(gnfs); // Persist any relations not already persisted to disk
// Because some operations clear this collection after persisting unsaved relations (to keep memory usage light)...
// We completely reload the entire relations collection from disk.
// This ensure that all the smooth relations are available for the matrix solving step.
Serialization.Load.Relations.Smooth(ref gnfs);
List <Relation> smoothRelations = gnfs.CurrentRelationsProgress.SmoothRelations.ToList();
int smoothCount = smoothRelations.Count;
BigInteger requiredRelationsCount = gnfs.CurrentRelationsProgress.SmoothRelationsRequiredForMatrixStep;
gnfs.LogFunction($"Total relations count: {smoothCount}");
gnfs.LogFunction($"Relations required to proceed: {requiredRelationsCount}");
while (smoothRelations.Count >= requiredRelationsCount)
{
// Randomly select n relations from smoothRelations
List <Relation> selectedRelations = new List <Relation>();
while (
selectedRelations.Count < requiredRelationsCount
||
selectedRelations.Count % 2 != 0 // Force number of relations to be even
)
{
int randomIndex = StaticRandom.Next(0, smoothRelations.Count);
selectedRelations.Add(smoothRelations[randomIndex]);
smoothRelations.RemoveAt(randomIndex);
}
GaussianMatrix gaussianReduction = new GaussianMatrix(gnfs, selectedRelations);
gaussianReduction.TransposeAppend();
gaussianReduction.Elimination();
int number = 1;
int solutionCount = gaussianReduction.FreeVariables.Count(b => b) - 1;
List <List <Relation> > solution = new List <List <Relation> >();
while (number <= solutionCount)
{
List <Relation> relations = gaussianReduction.GetSolutionSet(number);
number++;
BigInteger algebraic = relations.Select(rel => rel.AlgebraicNorm).Product();
BigInteger rational = relations.Select(rel => rel.RationalNorm).Product();
CountDictionary algCountDict = new CountDictionary();
foreach (var rel in relations)
{
algCountDict.Combine(rel.AlgebraicFactorization);
}
bool isAlgebraicSquare = algebraic.IsSquare();
bool isRationalSquare = rational.IsSquare();
gnfs.LogFunction("---");
gnfs.LogFunction($"Relations count: {relations.Count}");
gnfs.LogFunction($"(a,b) pairs: {string.Join(" ", relations.Select(rel => $"({rel.A},{rel.B})"))}");
gnfs.LogFunction($"Rational ∏(a+mb): IsSquare? {isRationalSquare} : {rational}");
gnfs.LogFunction($"Algebraic ∏ƒ(a/b): IsSquare? {isAlgebraicSquare} : {algebraic}");
gnfs.LogFunction($"Algebraic (factorization): {algCountDict.FormatStringAsFactorization()}");
if (isAlgebraicSquare && isRationalSquare)
{
solution.Add(relations);
gnfs.CurrentRelationsProgress.AddFreeRelationSolution(relations);
}
if (cancelToken.IsCancellationRequested)
{
break;
}
}
if (cancelToken.IsCancellationRequested)
{
break;
}
}
}