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())); }