private void ComparePermutations(
bool expected,
ExprNode[] setOne,
ExprNode[] setTwo)
{
if (setTwo.Length == 0)
{
CompareSingle(expected, setOne, setTwo);
return;
}
var permuter = PermutationEnumerator.Create(setTwo.Length).GetEnumerator();
for (; permuter.MoveNext();)
{
var permutation = permuter.Current;
var copy = new ExprNode[setTwo.Length];
for (var i = 0; i < permutation.Length; i++)
{
copy[i] = setTwo[permutation[i]];
}
CompareSingle(expected, setOne, copy);
}
}
public override void Start(CancellationToken token, Action <double> action)
{
double minPathLength = double.MaxValue;
var representation = new GeneralRepresentation <int>(_startPermutation, _startPermutation.Length, _startPermutation.Length);
var permutationEnumerator = new PermutationEnumerator <int>(representation);
do
{
// Forcing delay for visualization
if (_config.UseDelay)
{
Thread.Sleep(_config.DelayTime);
}
var curPermuation = permutationEnumerator.CurrentPermutation.Elements;
double curMin = _euclideanPath.GetPathLength(curPermuation, ClosedPath);
if (curMin < minPathLength)
{
minPathLength = curMin;
action?.Invoke(minPathLength);
_optimalSequence.OnNext(curPermuation);
}
} while (permutationEnumerator.SetNext() && !token.IsCancellationRequested);
_optimalSequence.OnCompleted();
}
private static IEnumerable <IList <T> > PermutationsImpl <T>(IEnumerable <T> sequence)
{
using (var iter = new PermutationEnumerator <T>(sequence))
while (iter.MoveNext())
{
yield return(iter.Current);
}
}
/// <summary>
/// Generates a sequence of lists that represent the permutations of the original sequence.
/// </summary>
/// <remarks>
/// A permutation is a unique re-ordering of the elements of the sequence.<br/>
/// This operator returns permutations in a deferred, streaming fashion; however, each
/// permutation is materialized into a new list. There are N! permutations of a sequence,
/// where N => sequence.Count().<br/>
/// Be aware that the original sequence is considered one of the permutations and will be
/// returned as one of the results.
/// </remarks>
/// <typeparam name="T">The type of the elements in the sequence</typeparam>
/// <param name="sequence">The original sequence to permute</param>
/// <returns>A sequence of lists representing permutations of the original sequence</returns>
public static IEnumerable <IList <T> > Permutations <T>(this IEnumerable <T> sequence)
{
if (sequence == null)
{
throw new ArgumentNullException(nameof(sequence));
}
using (var iter = new PermutationEnumerator <T>(sequence))
while (iter.MoveNext())
{
yield return(iter.Current);
}
}
/// <summary>
/// Cria um cópia do enumerador.
/// </summary>
/// <returns>A cópia.</returns>
public PermutationEnumerator Clone()
{
PermutationEnumerator resultEnumerator = new PermutationEnumerator(this.thisFastAffector as PermutationAffector);
resultEnumerator.currentPointer = this.currentPointer;
resultEnumerator.isBeforeStart = this.isBeforeStart;
resultEnumerator.isAfterEnd = this.isAfterEnd;
resultEnumerator.affectedIndices = new int[this.affectedIndices.Length];
Array.Copy(this.affectedIndices, resultEnumerator.affectedIndices, this.affectedIndices.Length);
resultEnumerator.currentAffectationIndices = new int[this.currentAffectationIndices.Length];
Array.Copy(this.currentAffectationIndices, resultEnumerator.currentAffectationIndices, this.currentAffectationIndices.Length);
return(resultEnumerator);
}
public static object GetPermutations(BlockParam block, IList/*!*/ self, [DefaultProtocol, Optional]int? size) {
var enumerator = new PermutationEnumerator(self, size);
if (block == null) {
return new Enumerator(enumerator);
}
return enumerator.Each(null, block);
}
