public void SwapIntIntMSeqInt(IMutableSeq <BitGene> seq)
{
for (var start = 0; start < seq.Length - 3; ++start)
{
var random = new Random();
var other = NewSeq(seq.Length);
var otherCopy = NewSeq(seq.Length);
for (var j = 0; j < other.Length; ++j)
{
other[j] = BitGene.Of(random.NextBoolean());
otherCopy[j] = other[j];
}
var copy = seq.ToArray(new BitGene[0]);
var end = start + 2;
const int otherStart = 1;
seq.Swap(start, end, other, otherStart);
for (var j = start; j < end; ++j)
{
Assert.Equal(seq[j], otherCopy[j + otherStart - start]);
}
for (var j = 0; j < end - start; ++j)
{
Assert.Equal(other[j + otherStart], copy[j + start]);
}
}
}
protected internal override int Crossover(IMutableSeq <TGene> v, IMutableSeq <TGene> w)
{
var random = RandomRegistry.GetRandom();
var min = v[0].Min;
var max = v[0].Max;
for (int i = 0, n = Math.Min(v.Length, w.Length); i < n; ++i)
{
var vi = v[i].DoubleValue();
var wi = w[i].DoubleValue();
dynamic t, s;
do
{
var a = NextDouble(random, -_p, 1 + _p);
var b = NextDouble(random, -_p, 1 + _p);
t = a * vi + (1 - a) * wi;
s = b * wi + (1 - b) * vi;
} while (t < min || s < min || t >= max || s >= max);
v[i] = v[i].NewInstance(t);
w[i] = w[i].NewInstance(s);
}
return(2);
}
public static void Swap <T>(this IMutableSeq <T> seq, int i, int j)
{
var temp = seq[i];
seq[i] = seq[j];
seq[j] = temp;
}
protected internal override int Crossover(IMutableSeq <TGene> v, IMutableSeq <TGene> w)
{
var random = RandomRegistry.GetRandom();
var min = v[0].Min.ToDouble(null);
var max = v[0].Max.ToDouble(null);
var a = Internal.Math.random.NextDouble(random, -_p, 1 + _p);
var b = Internal.Math.random.NextDouble(random, -_p, 1 + _p);
var changed = false;
for (int i = 0, n = Math.Min(v.Length, w.Length); i < n; ++i)
{
var vi = v[i].DoubleValue();
var wi = w[i].DoubleValue();
dynamic t = a * vi + (1 - a) * wi;
dynamic s = b * wi + (1 - b) * vi;
if (t >= min && s >= min && t < max && s < max)
{
v[i] = v[i].NewInstance(t);
w[i] = w[i].NewInstance(s);
changed = true;
}
}
return(changed ? 2 : 0);
}
private static IMutableSeq <TGene> Mean(IMutableSeq <TGene> a, ISeq <TGene> b)
{
for (var i = a.Length; --i >= 0;)
{
a[i] = a[i].Mean(b[i]);
}
return(a);
}
public static IMutableSeq <T> Shuffle <T>(this IMutableSeq <T> seq, Random randomSource)
{
for (var j = seq.Length - 1; j > 0; --j)
{
seq.Swap(j, randomSource.NextInt(j + 1));
}
return(seq);
}
public static IMutableSeq <T> Fill <T>(this IMutableSeq <T> seq, Func <T> supplier)
{
for (int i = 0, n = seq.Length; i < n; ++i)
{
seq[i] = supplier();
}
return(seq);
}
protected override int Mutate(IMutableSeq <TGene> genes, double p)
{
var random = RandomRegistry.GetRandom();
return(Internal.Math.random.Indexes(random, genes.Length, p)
.Peek(i => genes[i] = Mutate(genes[i], random))
.Count());
}
protected internal override int Crossover(IMutableSeq <TGene> that, IMutableSeq <TGene> other)
{
var random = RandomRegistry.GetRandom();
var index = random.NextInt(Math.Min(that.Length, other.Length));
SinglePointCrossover.Crossover(that, other, index);
return(2);
}
protected internal override int Crossover(IMutableSeq <TGene> that, IMutableSeq <TGene> other)
{
var length = Math.Min(that.Length, other.Length);
return(random
.Indexes(RandomRegistry.GetRandom(), length, _swapProbability)
.Peek(i => Swap(i, that, other))
.Count());
}
public static IMutableSeq <T> SetAll <T>(this IMutableSeq <T> seq, IEnumerable <T> values)
{
var i = 0;
foreach (var value in values)
{
seq[i++] = value;
}
return(seq);
}
private static void Swap <T>(
int index,
IMutableSeq <T> that,
IMutableSeq <T> other
)
{
var temp = that[index];
that[index] = other[index];
other[index] = temp;
}
protected internal override int Crossover(IMutableSeq <TGene> that, IMutableSeq <TGene> other)
{
var n = Math.Min(that.Length, other.Length);
var k = Math.Min(n, _n);
var random = RandomRegistry.GetRandom();
var points = k > 0 ? Base.Subset(n, k, random) : new int[0];
MultiPointCrossover.Crossover(that, other, points);
return(2);
}
protected override int Mutate(IMutableSeq <TGene> genes, double p)
{
var random = RandomRegistry.GetRandom();
if (genes.Length > 1)
{
return(Internal.Math.random.Indexes(random, genes.Length, p)
.Peek(i => genes.Swap(i, random.NextInt(genes.Length)))
.Count());
}
return(0);
}
protected int Mutate(IMutableSeq <IChromosome <TGene> > c, int i, double p)
{
var chromosome = c[i];
var genes = MutableSeq.Of <TGene>(chromosome.ToSeq());
var mutations = Mutate(genes, p);
if (mutations > 0)
{
c[i] = chromosome.NewInstance(genes.ToImmutableSeq());
}
return(mutations);
}
public static void Swap <T>(this IMutableSeq <T> seq, int start, int end, IMutableSeq <T> other, int otherStart)
{
if (otherStart < 0 || otherStart + (end - start) > seq.Length)
{
throw new IndexOutOfRangeException(
$"Invalid index range: [{otherStart}, {otherStart + (end - start)})");
}
if (start < end)
{
for (var i = end - start; --i >= 0;)
{
var temp = seq[start + i];
seq[start + i] = other[otherStart + i];
other[otherStart + i] = temp;
}
}
}
protected internal override int Crossover(IMutableSeq <EnumGene <TGene> > that, IMutableSeq <EnumGene <TGene> > other)
{
if (that.Length != other.Length)
{
throw new ArgumentException($"Required chromosomes with same length: {that.Length} != {other.Length}");
}
if (that.Length >= 2)
{
var random = RandomRegistry.GetRandom();
var points = Base.Subset(that.Length, 2, random);
that.Swap(points[0], points[1], other, points[0]);
Repair(that, other, points[0], points[1]);
Repair(other, that, points[0], points[1]);
}
return(1);
}
private static void Repair <TT>(IMutableSeq <TT> that, IMutableSeq <TT> other, int begin, int end)
{
for (var i = 0; i < begin; ++i)
{
var index = that.IndexOf(that[i], begin, end);
while (index != -1)
{
that[i] = other[index];
index = that.IndexOf(that[i], begin, end);
}
}
for (int i = end, n = that.Length; i < n; ++i)
{
var index = that.IndexOf(that[i], begin, end);
while (index != -1)
{
that[i] = other[index];
index = that.IndexOf(that[i], begin, end);
}
}
}
public void SwapIntInt(IMutableSeq <BitGene> seq)
{
for (var i = 0; i < seq.Length - 3; ++i)
{
var copy = seq.ToArray(new BitGene[0]);
var j = i + 2;
var vi = seq[i];
var vj = seq[j];
seq.Swap(i, j);
Assert.Equal(vj, seq[i]);
Assert.Equal(vi, seq[j]);
for (var k = 0; k < seq.Length; ++k)
{
if (k != i && k != j)
{
Assert.Equal(copy[k], seq[k]);
}
}
}
}
protected internal abstract int Crossover(IMutableSeq <TGene> that, IMutableSeq <TGene> other);
protected virtual int Mutate(IMutableSeq <TGene> genes, double p)
{
return(Indexes(RandomRegistry.GetRandom(), genes.Length, p)
.Select(i => genes[i] = genes[i].NewInstance())
.Count());
}
public static IMutableSeq <T> Shuffle <T>(this IMutableSeq <T> seq)
{
return(Shuffle(seq, RandomRegistry.GetRandom()));
}
