//public static IEnumerable<ISorterStage> ReplaceAtIndex(this IEnumerable<ISorterStage> source, int index,
// ISorterStage replacement)
//{
// var lst = source.ToList();
// lst[index] = replacement;
// return lst;
//}
public static Tuple <bool, IPermutation> Sort(this ISorterStage stage, IPermutation perm)
{
var aRet = new uint[stage.Order];
for (uint i = 0; i < stage.Order; i++)
{
aRet[i] = perm[i];
}
var wasUsed = false;
for (uint i = 0; i < stage.Order; i++)
{
var m = stage[i];
if (m > i)
{
var llv = perm[i];
var hlv = perm[m];
if (llv > hlv)
{
aRet[m] = llv;
aRet[i] = hlv;
wasUsed = true;
}
}
}
return(new Tuple <bool, IPermutation>(wasUsed, PermutationEx.MakePermutation(aRet)));
}
public static IStageVm ToStageVm
(
this ISorterStage <ISwitchEval> sorterStage,
int useMax,
double switchWidth,
double lineThickness,
Brush lineBrush,
Brush backgroundBrush,
IReadOnlyList <Brush> switchBrushes
)
{
return(new StageVmImpl
(
keyCount: sorterStage.KeyCount,
keyPairVms: sorterStage.ToStageLayouts()
.Select(
sl => new KeyPairVm
(
keyPair: sl.Item2,
switchBrush: BrushFactory.LogBrushOfInt
(
value: (int)sl.Item2.UseCount,
max: useMax,
brushList: switchBrushes
),
position: sl.Item1
)
).ToList(),
switchWidth: switchWidth,
lineThickness: lineThickness,
lineBrush: lineBrush,
backgroundBrush: backgroundBrush
));
}
public static IStageVm ToStageVm
(
this ISorterStage <IKeyPair> sorterStage,
double switchWidth,
double lineThickness,
Brush lineBrush,
Brush backgroundBrush,
Brush switchBrush
)
{
return(new StageVmImpl
(
keyCount: sorterStage.KeyCount,
keyPairVms: sorterStage.ToStageLayouts()
.Select(
sl => new KeyPairVm
(
keyPair: sl.Item2,
switchBrush: switchBrush,
position: sl.Item1
)
).ToList(),
switchWidth: switchWidth,
lineThickness: lineThickness,
lineBrush: lineBrush,
backgroundBrush: backgroundBrush
));
}
public static ISorter Mutate(this ISorter sorter, IRando rando, StageReplacementMode stageReplacementMode)
{
var mutantIndex = rando.NextUint(sorter.StageCount);
var stageToReplace = sorter[(int)mutantIndex];
ISorterStage mutantStage = null;
switch (stageReplacementMode)
{
case StageReplacementMode.RandomReplace:
mutantStage = rando.ToFullSorterStage(order: sorter.Order, stageNumber: mutantIndex);
break;
case StageReplacementMode.RandomRewire:
mutantStage = rando.RewireSorterStage(stageToReplace);
break;
case StageReplacementMode.RandomConjugate:
mutantStage = stageToReplace.ConjugateByRandomPermutation(rando).ToSorterStage(mutantIndex);
break;
case StageReplacementMode.RCTC:
mutantStage = stageToReplace.ConjugateByRandomSingleTwoCycle(rando).ToSorterStage(mutantIndex);
break;
default:
throw new Exception($"{stageReplacementMode.ToString()}");
}
return(sorter.SorterStages.ReplaceAtIndex(mutantIndex, mutantStage)
.ToSorter(id: Guid.NewGuid(), genomeId: Guid.Empty));
}
public static ISorterStage RewireSorterStage(this IRando rando, ISorterStage sorterStage)
{
if (sorterStage.Order % 2 == 1)
{
return(rando.MutateSorterStageOdd(sorterStage));
}
return(rando.MutateSorterStageEven(sorterStage));
}
public static IEnumerable <Tuple <int, T> > ToStageLayouts <T>(this ISorterStage <T> sorterStage)
where T : IKeyPair
{
var stageLayoutImpl = new StageLayoutImpl <T>();
foreach (var keyPair in sorterStage.KeyPairs.OrderBy(kp => kp.Index))
{
stageLayoutImpl.AddKeyPair(keyPair);
}
return(stageLayoutImpl.StageLayouts);
}
static ISorterStage MutateSorterStageOdd(this IRando rando, ISorterStage sorterStage)
{
var map = sorterStage.GetMap();
var fv = map.FixedValue();
var rems = map.Select(i => true).ToArray();
rems[fv] = false;
var lv = rando.SelectFromRemaining(map, rems);
var hv = sorterStage[lv];
map[lv] = fv;
map[fv] = lv;
map[hv] = hv;
return(new SorterStage(
order: sorterStage.Order,
terms: map,
stageNumber: sorterStage.StageNumber));
}
public SorterStageVm
(
ISorterStage <ISwitchEval> sorterStage,
List <Brush> lineBrushes,
List <Brush> switchBrushes,
int width,
bool showUnusedSwitches,
int switchableGroupCount
)
{
_sorterStage = sorterStage;
_lineBrushes = lineBrushes;
_switchBrushes = switchBrushes;
_showUnusedSwitches = showUnusedSwitches;
_width = width;
_switchableGroupCount = switchableGroupCount;
for (var i = 0; i < SorterStage.KeyPairCount; i++)
{
var keyPair = SorterStage.KeyPair(i);
if ((keyPair.UseCount < 1) && !ShowUnusedSwitches)
{
continue;
}
var switchBrushIndex = Math.Ceiling(
(keyPair.UseCount * (SwitchBrushes.Count - 1))
/
SwitchableGroupCount
);
SwitchVms.Add(new SwitchGraphicVm(keyPair, SorterStage.KeyCount, LineBrushes, Width)
{
SwitchBrush = SwitchBrushes[(int)switchBrushIndex]
});
}
}
static ISorterStage MutateSorterStageEven(this IRando rando, ISorterStage sorterStage)
{
var map = sorterStage.GetMap();
var rems = map.Select(i => true).ToArray();
var aX = rando.SelectFromRemaining(map, rems);
var aY = map[aX];
rems[aY] = false;
var bX = rando.SelectFromRemaining(map, rems);
var bY = map[bX];
rems[bY] = false;
map[aX] = bY;
map[aY] = bX;
map[bX] = aY;
map[bY] = aX;
return(new SorterStage(
order: sorterStage.Order,
terms: map,
stageNumber: sorterStage.StageNumber));
}
public static int GetHashCode(this ISorterStage sorterStage)
{
return(PermutationEx.GetHashCode(sorterStage));
}
public SorterStagerImpl(ISorterStage previous, ISorterStage current)
{
_previous = previous;
_current = current;
}
