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)); }