IEnumerable <IKeyPair> TestKeyPairs()
{
yield return(KeyPairRepository.ForKeys(0, 1));
yield return(KeyPairRepository.ForKeys(10, 11));
yield return(KeyPairRepository.ForKeys(3, 9));
yield return(KeyPairRepository.ForKeys(10, 12));
yield return(KeyPairRepository.ForKeys(3, 5));
yield return(KeyPairRepository.ForKeys(0, 5));
yield return(KeyPairRepository.ForKeys(1, 5));
yield return(KeyPairRepository.ForKeys(2, 4));
yield return(KeyPairRepository.ForKeys(7, 8));
yield return(KeyPairRepository.ForKeys(0, 5));
yield return(KeyPairRepository.ForKeys(8, 9));
yield return(KeyPairRepository.ForKeys(4, 7));
yield return(KeyPairRepository.ForKeys(2, 6));
yield return(KeyPairRepository.ForKeys(6, 8));
yield return(KeyPairRepository.ForKeys(5, 7));
yield return(KeyPairRepository.ForKeys(1, 11));
}
public void TestMethod2()
{
const int keyCount = 13;
for (var numKeyPairs = 4; numKeyPairs < 30; numKeyPairs += 2)
{
for (var numSwitchables = 10; numSwitchables < 100; numSwitchables += 10)
{
var rando = Rando.Fast(numSwitchables + 377);
IReadOnlyList <IKeyPair> sorterStage = KeyPairRepository.RandomKeyPairs(13, numKeyPairs, rando.NextInt()).ToList();
for (var rep = 0; rep < 10; rep++)
{
var reducedSorterStage =
sorterStage.ToReducedSorterStage(
rando.Spawn().ToSwitchableGroup <uint>(Guid.NewGuid(), keyCount, numSwitchables)
);
//if (reducedSorterStage.KeyPairs.Count > 6)
//{
// System.Diagnostics.Debug.WriteLine(sorterStage.Aggregate("\n", (o, n) => o + " [" + n.LowKey + "," + n.HiKey + "]"));
// System.Diagnostics.Debug.WriteLine(reducedSorterStage.KeyPairs.Aggregate(String.Empty, (o,n)=> o + " [" + n.LowKey + "," + n.HiKey + "]" ));
//}
System.Diagnostics.Debug.WriteLine(String.Format("{0}\t{1}\t{2}\t{3}\t{4}",
numKeyPairs,
numSwitchables,
reducedSorterStage.KeyPairs.Count,
sorterStage.Aggregate("", (o, n) => o + " [" + n.LowKey + "," + n.HiKey + "]"),
reducedSorterStage.KeyPairs.Aggregate(String.Empty, (o, n) => o + " [" + n.LowKey + "," + n.HiKey + "]")
));
}
}
}
}
public void TestIntArraySwitchSetFunctionsAreNotNull()
{
var keyCount = 7;
var intArraySwitchSet = KeyPairSwitchSet.Make <int[]>(keyCount);
var keyPairs = KeyPairRepository.KeyPairsForKeyCount(keyCount).ToList();
foreach (var keyPair in keyPairs)
{
Assert.IsNotNull(intArraySwitchSet.SwitchFunction(keyPair));
}
keyCount = 16;
intArraySwitchSet = KeyPairSwitchSet.Make <int[]>(keyCount);
keyPairs = KeyPairRepository.KeyPairsForKeyCount(keyCount).ToList();
foreach (var keyPair in keyPairs)
{
Assert.IsNotNull(intArraySwitchSet.SwitchFunction(keyPair));
}
keyCount = 33;
intArraySwitchSet = KeyPairSwitchSet.Make <int[]>(keyCount);
keyPairs = KeyPairRepository.KeyPairsForKeyCount(keyCount).ToList();
foreach (var keyPair in keyPairs)
{
Assert.IsNotNull(intArraySwitchSet.SwitchFunction(keyPair));
}
}
void MakeSwitchFuncs()
{
var combo = new StringBuilder();
foreach (var keyPair in KeyPairRepository.KeyPairsForKeyCount(KeyCount))
{
combo.AppendLine(SwitchMaskDefinition(SwitchableDataType.Name, keyPair));
}
Session.Execute(combo.ToString());
combo.Clear();
for (var i = 0; i < KeyCount; i++)
{
combo.AppendLine(ShiftDefinition(SwitchableDataType.Name, i));
}
Session.Execute(combo.ToString());
combo.Clear();
combo.AppendLine(String.Format("new Func<{0}, Tuple<{0}, bool>>[] {{", SwitchableDataType.Name));
foreach (var keyPair in KeyPairRepository.KeyPairsForKeyCount(KeyCount))
{
combo.AppendLine((keyPair.Index == 0) ? string.Empty : ",");
combo.AppendLine(SwitchExpression(SwitchableDataType.Name, keyPair));
}
combo.AppendLine("}");
//System.Diagnostics.Debug.WriteLine(combo.ToString());
_switchFuncs = (Func <T, Tuple <T, bool> >[])Session.Execute(combo.ToString());
}
public void TestKeyPairsCount()
{
Assert.AreEqual
(
KeyPairRepository.KeyPairsForKeyCount(KeyPairRepository.MaxKeyCount).Count(),
KeyPairRepository.KeyPairSetSizeForKeyCount(KeyPairRepository.MaxKeyCount)
);
}
public static IEnumerable <IKeyPair> Reduce(this IReadOnlyList <DependentKeyPair> dependentKeyPairs)
{
for (var i = 0; i < dependentKeyPairs.Count; i++)
{
if (dependentKeyPairs[i].IsUsed)
{
yield return(KeyPairRepository.AtIndex(dependentKeyPairs[i].Index));
}
}
}
public static ISorter ToSorter(this ISorterGenome sorterGenome)
{
return(KeyPairRepository.KeyPairSet(sorterGenome.KeyCount)
.KeyPairs.ToSorter
(
keyPairChoices: sorterGenome.Chromosome.Sequence,
keyCount: sorterGenome.KeyCount,
guid: sorterGenome.Guid
));
}
public void TestKeyPairAssignment()
{
foreach (var keyPair in KeyPairRepository.KeyPairsForKeyCount(KeyPairRepository.MaxKeyCount))
{
Assert.AreEqual
(
keyPair.Index,
KeyPairRepository.KeyPairIndex(keyPair.LowKey, keyPair.HiKey)
);
}
}
void MakeSwitchFuncs()
{
var returnValueType = string.Format("Tuple<{0}, bool>", SwitchableDataType.Name);
foreach (var keyPair in KeyPairRepository.KeyPairsForKeyCount(KeyCount).ToList())
{
var strInitializer = string.Format(
"new Func<{0}, {1}>(a => (a[{3}]{2}a[{4}]) ? new {1}({5}, true) : new {1}(a, false))",
SwitchableDataType.Name,
returnValueType,
OperatorName,
keyPair.LowKey,
keyPair.HiKey,
ArrayBuilder("a", keyPair, KeyCount)
);
_switchFuncs[keyPair.Index] = (Func <T, Tuple <T, bool> >)Session.Execute(strInitializer);
}
}
public static ISorter ToSorter2(this ISorterGenome sorterGenome)
{
IList <IReadOnlyList <IKeyPair> > keyPairGroups = sorterGenome.Chromosome.Sequence
.Select(i => KeyPairRepository.AtIndex((int)i))
.Slice(18)
.ToList();
var sorter = StagedSorter.Make
(
guid: sorterGenome.Guid,
keyCount: sorterGenome.KeyCount,
sorterStages: Enumerable.Range(0, 77)
.Select(
i => keyPairGroups[i].ToReducedSorterStage(SwitchableGroups[i])
).ToList()
);
return(sorter);
}
public void TestBitArraySwitchSetFunctionsSwitchTheRightIndexes()
{
var keyCount = 64;
var bitArraySwitchSet = KeyPairSwitchSet.Make <bool[]>(keyCount);
var keyPairs = KeyPairRepository.KeyPairsForKeyCount(keyCount).ToList();
foreach (var keyPair in keyPairs)
{
var preSwitch = BitArrayUtils.SetTrueBitInArray(keyPair.LowKey, keyCount);
var postSwitch = BitArrayUtils.SetTrueBitInArray(keyPair.HiKey, keyCount);
var switchResult = bitArraySwitchSet.SwitchFunction(keyPair)(preSwitch);
Assert.IsTrue(switchResult.Item2);
Assert.AreEqual(0, postSwitch.CompareDict(switchResult.Item1));
Assert.IsNotNull(bitArraySwitchSet.SwitchFunction(keyPair));
}
}
public void ConvertSorterTest()
{
const int keyCount = 16;
const int sequenceLength = 100;
var keyPairSet = KeyPairRepository.KeyPairSet(keyCount);
var guid = Guid.NewGuid();
var keyPairs = Enumerable.Range(0, KeyPairRepository.KeyPairSetSizeForKeyCount(keyCount))
.Select(i => keyPairSet[i])
.ToArray();
var sorter = keyPairs.ToSorter(guid: guid, keyCount: keyCount);
var serialized = JsonConvert.SerializeObject(sorter.ToJsonAdapter(), Formatting.Indented);
var newSorter = serialized.ToSorter();
Assert.AreEqual(newSorter.Guid, guid);
Assert.AreEqual(newSorter.KeyCount, keyCount);
Assert.IsTrue(newSorter.KeyPairs.IsSameAs(keyPairs));
}
public void TestIntArraySwitchSetFunctionsSwitchTheRightIndexes()
{
var keyCount = 7;
var intArraySwitchSet = KeyPairSwitchSet.Make <int[]>(keyCount);
var keyPairs = KeyPairRepository.KeyPairsForKeyCount(keyCount).ToList();
foreach (var keyPair in keyPairs)
{
var preSwitch = new int[keyCount];
preSwitch[keyPair.LowKey] = 33;
var postSwitch = new int[keyCount];
postSwitch[keyPair.HiKey] = 33;
var switchResult = intArraySwitchSet.SwitchFunction(keyPair)(preSwitch);
Assert.IsTrue(switchResult.Item2);
Assert.AreEqual(0, postSwitch.CompareDict(switchResult.Item1));
Assert.IsNotNull(intArraySwitchSet.SwitchFunction(keyPair));
}
}
public static ISorterGenome ToSorterGenome(
this IRando randy,
int keyCount,
int keyPairCount)
{
var keyPairSetSize = (uint)KeyPairRepository.KeyPairSetSizeForKeyCount(keyCount);
return(new SorterGenomeImpl
(
guid: randy.NextGuid(),
parentGuid: Guid.Empty,
chromosome: randy
.ToUintEnumerator(keyPairSetSize)
.Take(keyPairCount)
.ToList()
.ToChromosomeUint
(
maxVal: keyPairSetSize
),
keyCount: keyCount,
keyPairCount: keyPairCount
));
}
protected void OnConvertToGenomesCommand()
{
foreach (var sorterVm in SorterGridVm.SorterVms)
{
SorterGenomeGridVm.SorterGenomeVms.Add
(
new SorterGenomeVm
(
SorterGenome.Make
(
guid: sorterVm.Guid,
parentGuid: Guid.Empty,
chromosome: ChromosomeUint.Make
(
sequence: sorterVm.Sorter.KeyPairs.Select(kp => (uint)kp.Index).ToArray(),
maxVal: (uint)KeyPairRepository.KeyPairSetSizeForKeyCount(sorterVm.Sorter.KeyCount)
),
keyCount: sorterVm.Sorter.KeyCount,
keyPairCount: sorterVm.Sorter.KeyPairCount
)
)
);
}
}
public static IEnumerable <ISorter> Mutate(this ISorter sorter, IRando rando, double mutationRate)
{
var randoK = rando.Spawn();
var keyPairList = KeyPairRepository.KeyPairSet(sorter.KeyCount).KeyPairs;
var newb = randoK.Pick(keyPairList).ToMoveNext();
while (true)
{
yield return(new SorterImpl
(
keyPairs: sorter.KeyPairs.MutateInsertDelete
(
rando.Spawn().ToBoolEnumerator(mutationRate),
rando.Spawn().ToBoolEnumerator(mutationRate),
rando.Spawn().ToBoolEnumerator(mutationRate),
T => newb.Next(),
T => newb.Next(),
T => newb.Next()
),
guid: randoK.NextGuid(),
keyCount: sorter.KeyCount
));
}
}
protected ArraySwitchSet(int keyCount)
{
_keyCount = keyCount;
_switchFuncs = new Func <T, Tuple <T, bool> > [KeyPairRepository.KeyPairSetSizeForKeyCount(KeyCount)];
MakeSwitchFuncs();
}
void Serialize()
{
Serialized = SwitchEditVms.Select(
vm => KeyPairRepository.KeyPairFromKeys(vm.LowKey.Value, vm.HiKey.Value))
.ToSerialized();
}
public static ISorter ToSorter2(this IRando rando, int keyCount, int keyPairCount, Guid guid)
{
var keyPairSet = KeyPairRepository.KeyPairSet(keyCount);
return(rando.ToSorter2(keyPairSet.KeyPairs, keyPairCount, keyCount, guid));
}
