public void BenchUshortForSorted()
{
const int maxKeyCount = 16;
var stopwatch = new Stopwatch();
const int keyCount = 16;
var switchSet = KeyPairSwitchSet.Make <ushort>(keyCount);
var testResults = 0;
stopwatch.Start();
for (var j = 0; j < 1000; j++)
{
for (ushort i = 0; i < ushort.MaxValue; i++)
{
var testNum = i;
// testNum >>= (maxKeyCount - keyCount);
testResults += switchSet.IsSorted(testNum) ? 1 : 0;
}
}
stopwatch.Stop();
Debug.WriteLine("Time(ms): {0}", stopwatch.ElapsedMilliseconds);
}
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));
}
}
public void TestCtor()
{
const int keyCount = 16;
var switchSet = KeyPairSwitchSet.Make <ushort>(keyCount);
var t = typeof(int[]);
var dater = new[] { 1, 2, 3 };
}
IEnumerable <ISorterEval> SorterOnSwitchableGroupTests(ISorter sorter)
{
KeyPairSwitchSet.Make <uint>(sorter.KeyCount);
foreach (var switchableGroupResult in SwitchableGroupGridVm.SwitchableGroupVms.Select(v => v.SwitchableGroupJson.ToSwitchableGroup())
.AsParallel().Select(g => sorter.Sort((ISwitchableGroup <uint>)g)))
{
yield return(switchableGroupResult);
}
//SwitchableGroupGridVm.SwitchableGroupVms.Select(v => v.SwitchableGroupJson.ToSwitchableGroup())
// .AsParallel().Select(g => sorter.Sort((ISwitchableGroup<uint>)g));
}
public IEnumerable <IEnumerable <ISorterEval> > RandomSorterTests(int seed, int keyCount,
int switchLength)
{
KeyPairSwitchSet.Make <uint>(keyCount);
var testSet = Switchable.AllSwitchablesForKeyCount(keyCount).ToSwitchableGroup(
guid: SwitchableGroup.GuidOfAllSwitchableGroupsForKeyCount(keyCount),
keyCount: keyCount);
foreach (var chunk in RandomSorters(seed, keyCount, switchLength).Chunk(16))
{
yield return(chunk.AsParallel().Select(s => s.Sort(testSet)));
}
}
public void TestIntArraySwitchSetFunctionIsSorted()
{
const int keyCount = 7;
var intArraySwitchSet = KeyPairSwitchSet.Make <int[]>(keyCount);
var sortedArray = Enumerable.Range(0, keyCount).ToArray();
Assert.IsTrue(intArraySwitchSet.IsSorted(sortedArray));
sortedArray = Enumerable.Range(1, keyCount).ToArray();
Assert.IsFalse(intArraySwitchSet.IsSorted(sortedArray));
}
//public static ICompPool ToCompPoolParallel(
// this IEnumerable<ISorter> sorters
//)
//{
// var sortersList = sorters.ToList();
// var keyCount = sortersList[0].KeyCount;
// KeyPairSwitchSet.Make<uint>(keyCount);
// var switchables = Switchable.AllSwitchablesForKeyCount(keyCount).ToSwitchableGroup
// (
// guid: SwitchableGroup.GuidOfAllSwitchableGroupsForKeyCount(keyCount),
// keyCount: keyCount
// );
// return new CompPoolImpl(
// sorterEvals: sortersList.AsParallel().Select(s => s.Sort(switchables)),
// keyCount: keyCount
// );
//}
public static ICompPool AddSorterEvalsParallel(this ICompPool compPool,
IEnumerable <ISorter> sorters)
{
KeyPairSwitchSet.Make <uint>(compPool.KeyCount);
var switchables = Switchable.AllSwitchablesForKeyCount(compPool.KeyCount).ToSwitchableGroup
(
guid: SwitchableGroup.GuidOfAllSwitchableGroupsForKeyCount(compPool.KeyCount),
keyCount: compPool.KeyCount
);
return(new CompPoolImpl(
sorterEvals: compPool.SorterEvals.Concat(sorters.AsParallel().Select(s => s.Sort(switchables))),
keyCount: compPool.KeyCount
));
}
public static ICompParaPool ToCompParaPoolParallel <T>
(
this IEnumerable <ISorter> sorters,
IEnumerable <ISwitchableGroup <T> > switchableGroups
)
{
var switchableGroupList = switchableGroups.ToList();
var sortersList = sorters.ToList();
KeyPairSwitchSet.Make <T>(switchableGroupList.First().KeyCount);
return(new CompParaPoolImpl(
sortersList,
switchableGroupList,
sortersList.AsParallel().Select(t => t.MakeSorterOnSwitchableGroups(switchableGroupList))));
}
public static ISorterEval Sort <T>
(
this ISorter sorter,
ISwitchableGroup <T> switchableGroup
)
{
var switchUseList = Enumerable.Repeat(0.0, sorter.KeyPairCount).ToList();
var totalSuccess = true;
var switchSet = KeyPairSwitchSet.Make <T>(switchableGroup.KeyCount);
foreach (var switchable in switchableGroup.Switchables)
{
var current = switchable.Item;
var sortSuccess = false;
for (var i = 0; i < sorter.KeyPairCount; i++)
{
if (switchSet.IsSorted(current))
{
sortSuccess = true;
break;
}
var res = switchSet.SwitchFunction(sorter.KeyPair(i))(current);
current = res.Item1;
if (res.Item2)
{
switchUseList[i]++;
if (switchSet.IsSorted(current))
{
sortSuccess = true;
break;
}
}
}
totalSuccess &= sortSuccess;
}
return(SorterEval.Make(
sorter: sorter,
switchableGroupGuid: switchableGroup.Guid,
success: totalSuccess,
switchUseList: switchUseList,
coveringSet: null
));
}
public void TestRandomUintForSorted()
{
const int maxKeyCount = 32;
var randy = Rando.Fast(322);
for (var keyCount = 2; keyCount < maxKeyCount + 1; keyCount++)
{
var switchSet = KeyPairSwitchSet.Make <uint>(keyCount);
for (var i = 0; i < 100; i++)
{
var testNum = (uint)randy.NextInt();
testNum >>= (maxKeyCount - keyCount);
var testArray = testNum.ToBits().Take(keyCount).ToArray();
Assert.AreEqual(switchSet.IsSorted(testNum), testArray.IsSorted());
}
}
}
public void TestULongIsOrdered()
{
const int maxKeyCount = 64;
for (var keyCount = 2; keyCount < maxKeyCount; keyCount++)
{
var ushortSwitchSet = KeyPairSwitchSet.Make <ulong>(keyCount);
for (var i = 0; i < keyCount; i++)
{
var bitArray = Enumerable.Repeat(false, i)
.Concat(Enumerable.Repeat(true, keyCount - i))
.ToArray();
var testNum = bitArray.ToULong();
Assert.IsTrue(ushortSwitchSet.IsSorted(testNum));
}
}
}
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 static ISorterStage ToReducedSorterStage <T>(this IReadOnlyList <IKeyPair> keyPairs,
ISwitchableGroup <T> switchableGroup)
{
var switchSet = KeyPairSwitchSet.Make <T>(switchableGroup.KeyCount);
var dependentKeyPairs = keyPairs.ToDependentKeyPairs().ToList();
foreach (var switchable in switchableGroup.Switchables)
{
var currentItem = switchable.Item;
for (var i = 0; i < dependentKeyPairs.Count; i++)
{
var currentDp = dependentKeyPairs[i];
if (currentDp.IsDisabled)
{
continue;
}
if (switchSet.IsSorted(currentItem))
{
break;
}
var res = switchSet.SwitchFunction(currentDp)(currentItem);
currentItem = res.Item1;
if (res.Item2)
{
if (!currentDp.IsUsed)
{
currentDp.IsUsed = true;
currentDp.DisableDependentKeyPairs();
}
if (switchSet.IsSorted(currentItem))
{
break;
}
}
}
}
IReadOnlyList <IKeyPair> reducedKeyPairs = dependentKeyPairs.Reduce().ToList();
return(SorterStage.Make(switchableGroup.KeyCount, reducedKeyPairs));
}
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 void TestImplementationAssignment()
{
const int keyCount = 16;
var impla = KeyPairSwitchSet.Make <ushort>(keyCount);
Assert.AreEqual(impla.KeyCount, keyCount);
var implb = KeyPairSwitchSet.Make <uint>(keyCount);
Assert.AreEqual(implb.KeyCount, keyCount);
var imple = KeyPairSwitchSet.Make <ulong>(keyCount);
Assert.AreEqual(implb.KeyCount, keyCount);
var implc = KeyPairSwitchSet.Make <bool[]>(keyCount);
Assert.AreEqual(implc.KeyCount, keyCount);
var impld = KeyPairSwitchSet.Make <int[]>(keyCount);
Assert.AreEqual(impld.KeyCount, keyCount);
}
