// ************************************************************************
private int RunTest()
{
try
{
bool canRun = false;
lock (_lockObj)
{
if (!IsTestRunning)
{
canRun = true;
IsTestRunning = true;
}
}
if (!canRun)
{
MessageBox.Show("Already running test. Please try later.");
return(0);
}
Action <IEnumerable <int> > actionToDoOnPermutation = null;
Predicate <int[]> funcToDoOnPermutation = null; // Direct function for Sam to be fair (I do not want to add an additional indirection)
switch (EnumAction)
{
case EnumAction.Nothing_BestForPerformanceTest:
actionToDoOnPermutation = DoNothing;
funcToDoOnPermutation = DoNothingFunc;
break;
case EnumAction.CountItemWithBugWithMultithreadedCode:
actionToDoOnPermutation = IncreaseCount;
funcToDoOnPermutation = IncreaseCountFunc;
break;
case EnumAction.CountItemSafeInterlockedIncrement:
actionToDoOnPermutation = IncreaseCountSafeInterlockedIncrement;
funcToDoOnPermutation = IncreaseCountSafeInterlockedIncrementFunc;
break;
case EnumAction.CountItemSafeSpinLock:
actionToDoOnPermutation = IncreaseCountSafeSpinLock;
funcToDoOnPermutation = IncreaseCountSafeSpinLockFunc;
break;
case EnumAction.DumpPermutatedValuesAndCount:
actionToDoOnPermutation = DumpValues;
funcToDoOnPermutation = DumpValuesFunc;
if (CountOfElementsToPermute > 5)
{
var result = MessageBox.Show(
"The count of item to permute is greater than 5, it could take long to dump every items, are you sure you want to continue?",
"Warning",
MessageBoxButton.OKCancel);
if (result == MessageBoxResult.Cancel)
{
return(0);
}
}
break;
}
EnumAlgoPermutation algoPermutation = AlgoPermutation;
EnumAlgoPermutation algoPermutationActive;
_testCount++;
WriteLine($"Test {_testCount} started. Count {CountOfElementsToPermute}!. Action: {EnumUtil.GetEnumDescription(EnumAction)}.");
int[] values;
Stopwatch stopwatch = new Stopwatch();
// Eric OuelletHeap Algorithm
algoPermutationActive = EnumAlgoPermutation.OuelletHeap;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
PermutationOuellet.ForAllPermutation(values, (vals) =>
{
actionToDoOnPermutation?.Invoke(vals);
return(false);
});
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
// Eric OuelletHeap indexed Algorithm
algoPermutationActive = EnumAlgoPermutation.OuelletIndexed;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
var permutationGenerator = new PermutationOuelletLexico <int>(values);
// int[] result = new int[values.Length];
for (long i = 0; i < permutationGenerator.MaxIndex; i++)
{
permutationGenerator.GetSortedValuesFor(i);
{
actionToDoOnPermutation?.Invoke(permutationGenerator.Result);
}
}
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
// Eric OuelletHeap indexed Algorithm v2
algoPermutationActive = EnumAlgoPermutation.OuelletIndexedv2;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
var permutationGenerator = new PermutationOuelletLexico2 <int>(values);
// int[] result = new int[values.Length];
for (long i = 0; i < permutationGenerator.MaxIndex; i++)
{
permutationGenerator.GetSortedValuesFor(i);
{
actionToDoOnPermutation?.Invoke(permutationGenerator.Result);
}
}
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
// Eric OuelletHeap indexed Algorithm v3
algoPermutationActive = EnumAlgoPermutation.OuelletIndexedv3;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
var permutationGenerator = new PermutationOuelletLexico3 <int>(values);
// int[] result = new int[values.Length];
for (long i = 0; i < permutationGenerator.MaxIndex; i++)
{
permutationGenerator.GetValuesForIndex(i);
{
actionToDoOnPermutation?.Invoke(permutationGenerator.Result);
}
}
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
//// Eric OuelletHeap indexed Algorithm v4
//algoPermutationActive = EnumAlgoPermutation.OuelletIndexedv4;
//if (algoPermutation.HasFlag(algoPermutationActive))
//{
// _count = 0;
// values = GetValues();
// stopwatch.Reset();
// stopwatch.Start();
// var permutationGenerator = new PermutationOuelletLexico4<int>(values);
// // int[] result = new int[values.Length];
// for (int i = 0; i < permutationGenerator.MaxIndex; i++)
// {
// permutationGenerator.GetValuesForIndex(i);
// {
// actionDumpValues?.Invoke(permutationGenerator.Result);
// }
// }
// stopwatch.Stop();
// WriteResult(algoPermutationActive, stopwatch);
//}
algoPermutationActive = EnumAlgoPermutation.SaniSinghHuttunen;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
do
{
actionToDoOnPermutation?.Invoke(values);
}while (PermutationSaniSinghHuttunen.NextPermutation(values));
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
algoPermutationActive = EnumAlgoPermutation.OuelletIndexedv3HuttunenST;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
PermutationMixOuelletSaniSinghHuttunen mix = new PermutationMixOuelletSaniSinghHuttunen(values);
mix.ExecuteForEachPermutation(actionToDoOnPermutation);
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
algoPermutationActive = EnumAlgoPermutation.SimpleVar;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
do
{
actionToDoOnPermutation?.Invoke(values);
}while (!PermutationSimpleVar.NextPermutation(values));
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
algoPermutationActive = EnumAlgoPermutation.SimpleVarUnsafe;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
PermutationSimpleVarUnsafe permutations = new PermutationSimpleVarUnsafe();
permutations.Permutate(0, values.Length, (int[] vals) =>
{
actionToDoOnPermutation?.Invoke(vals);
});
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
// ErezRobinson Algorithm
algoPermutationActive = EnumAlgoPermutation.ErezRobinson;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
foreach (var vals in PermutationErezRobinson.QuickPerm(values))
{
actionToDoOnPermutation?.Invoke(vals);
}
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
algoPermutationActive = EnumAlgoPermutation.Sam;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
var pf = new PermutationFinder <int>();
pf.Evaluate(values, funcToDoOnPermutation);
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
algoPermutationActive = EnumAlgoPermutation.Ziezi;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
PermutationZiezi.EnumeratePermutation(values, actionToDoOnPermutation);
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
// Pengyang linq algorithm
algoPermutationActive = EnumAlgoPermutation.Pengyang;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
foreach (var vals in PermutationPengyang.GetPermutations(values, values.Length))
{
actionToDoOnPermutation?.Invoke(vals);
}
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
algoPermutationActive = EnumAlgoPermutation.OuelletIndexedMT;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
int[] result = new int[values.Length];
Parallel.For <PermutationOuelletLexico <int> >
(
0,
Factorial.GetFactorial(values.Length),
() => new PermutationOuelletLexico <int>(GetValues()),
(index, state, permutationOuellet) =>
{
permutationOuellet.GetSortedValuesFor(index);
actionToDoOnPermutation?.Invoke(permutationOuellet.Result);
return(permutationOuellet);
},
(permutationOuellet) => { }
);
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
algoPermutationActive = EnumAlgoPermutation.OuelletIndexedv3MT;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
int[] result = new int[values.Length];
Parallel.For <PermutationOuelletLexico3 <int> >
(
0,
Factorial.GetFactorial(values.Length),
() => new PermutationOuelletLexico3 <int>(GetValues()),
(index, state, permutationOuellet) =>
{
permutationOuellet.GetValuesForIndex(index);
actionToDoOnPermutation?.Invoke(permutationOuellet.Result);
return(permutationOuellet);
},
(permutationOuellet) => { }
);
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
algoPermutationActive = EnumAlgoPermutation.OuelletHuttunenMT;
if (algoPermutation.HasFlag(algoPermutationActive))
{
WriteIntro(algoPermutationActive);
_count = 0;
values = GetValues();
stopwatch.Reset();
stopwatch.Start();
PermutationMixOuelletSaniSinghHuttunen.ExecuteForEachPermutationMT(values, actionToDoOnPermutation);
stopwatch.Stop();
WriteResult(algoPermutationActive, stopwatch);
}
WriteLine("Test " + _testCount + " ended.");
WriteLine("---------------------------------------------------------------");
return(_count);
}
finally
{
IsTestRunning = false;
}
}
/// <summary>
/// Func to show how to call. It does a little test for an array of 4 items.
/// </summary>
public static void Test()
{
PermutationOuellet.ForAllPermutation("123".ToCharArray(), (vals) =>
{
Console.WriteLine(String.Join("", vals));
return(false);
});
int[] values = new int[] { 0, 1, 2, 4 };
Console.WriteLine("OuelletHeap heap's algorithm implementation");
PermutationOuellet.ForAllPermutation(values, (vals) =>
{
Console.WriteLine(String.Join("", vals));
return(false);
});
Console.WriteLine("Linq algorithm");
foreach (var v in PermutationPengyang.GetPermutations(values, values.Length))
{
Console.WriteLine(String.Join("", v));
}
// Performance Heap's against Linq version : huge differences
int count = 0;
values = new int[10];
for (int n = 0; n < values.Length; n++)
{
values[n] = n;
}
Stopwatch stopWatch = new Stopwatch();
PermutationOuellet.ForAllPermutation(values, (vals) =>
{
foreach (var v in vals)
{
count++;
}
return(false);
});
stopWatch.Stop();
Console.WriteLine($"OuelletHeap heap's algorithm implementation {count} items in {stopWatch.ElapsedMilliseconds} millisecs");
count = 0;
stopWatch.Reset();
stopWatch.Start();
foreach (var vals in PermutationPengyang.GetPermutations(values, values.Length))
{
foreach (var v in vals)
{
count++;
}
}
stopWatch.Stop();
Console.WriteLine($"Linq {count} items in {stopWatch.ElapsedMilliseconds} millisecs");
}