public IChromosome <BitGene> NewInstance(IImmutableSeq <BitGene> genes)
{
if (genes.IsEmpty)
{
throw new ArgumentException("The genes sequence must contain at least one gene.");
}
var chromosome = new BitChromosome(Bits.NewArray(genes.Length), genes.Length);
var ones = 0;
if (genes is BitGeneImmutableSeq seq)
{
var iseq = seq;
iseq.CopyTo(chromosome._genes);
ones = Bits.Count(chromosome._genes);
}
else
{
for (var i = genes.Length; --i >= 0;)
{
if (genes[i].BooleanValue())
{
Bits.Set(chromosome._genes, i);
++ones;
}
}
}
// TODO: do not match in copy, arrays do (see ChromosomeTester)
chromosome._seq = BitGeneMutableSeq.Of(_genes, Length).ToImmutableSeq();
chromosome._p = ones / (double)genes.Length;
return(chromosome);
}
public void SeqTypes()
{
var c = BitChromosome.Of(100, 0.3);
Assert.Equal(typeof(BitGeneImmutableSeq), c.ToSeq().GetType());
Assert.Equal(typeof(BitGeneMutableSeq), c.ToSeq().Copy().GetType());
Assert.Equal(typeof(BitGeneImmutableSeq), c.ToSeq().Copy().ToImmutableSeq().GetType());
}
public void ToCanonicalString()
{
var c = BitChromosome.Of(new BigInteger(234902));
var value = c.ToCanonicalString();
var sc = BitChromosome.Of(value);
Assert.Equal(c, sc);
}
public void Zeros()
{
var c = BitChromosome.Of(1000, 0.5);
var zeros = c.Zeros().Count();
Assert.Equal(zeros, c.Length - c.BitCount());
Assert.True(c.Zeros().All(i => !c.Get(i)));
}
public void Ones()
{
var c = BitChromosome.Of(1000, 0.5);
var ones = c.Ones().Count();
Assert.Equal(ones, c.BitCount());
Assert.True(c.Ones().All(i => c.Get(i)));
}
public void ToBigInteger()
{
var data = new byte[1056];
RandomRegistry.GetRandom().NextBytes(data);
var value = new BigInteger(data);
var chromosome = BitChromosome.Of(value);
Assert.Equal(chromosome.ToBigInteger(), value);
}
public void TestGenotypeGenotypeOfT()
{
var c1 = BitChromosome.Of(12);
var c2 = BitChromosome.Of(12);
var g2 = Genotype.Of(c1, c2, c2);
var g4 = g2;
Assert.Equal(g4, g2);
Assert.Equal(g4.GetHashCode(), g2.GetHashCode());
}
public void ToBitSet()
{
var c1 = BitChromosome.Of(34);
var c2 = BitChromosome.Of(c1.ToBitSet(), 34);
for (var i = 0; i < c1.Length; ++i)
{
Assert.Equal(c1.GetGene(i).GetBit(), c2.GetGene(i).GetBit());
}
}
public void ChromosomeProbability()
{
var data = new byte[1234];
RandomRegistry.GetRandom().NextBytes(data);
var c = new BitChromosome(data);
Assert.Equal(Bits.Count(data) / (double)(data.Length * 8), c.GetOneProbability());
}
public void BitSetBitCount(double p)
{
const int size = 1000;
var @base = BitChromosome.Of(size, p);
for (var i = 0; i < 1000; ++i)
{
var other = @base.NewInstance();
Assert.Equal(other.BitCount(), other.ToBitSet().OfType <bool>().Count(bit => bit));
}
}
public void NumValue()
{
var c1 = BitChromosome.Of(10);
var value = c1.IntValue();
Assert.Equal((short)value, c1.ShortValue());
Assert.Equal(value, c1.LongValue());
Assert.Equal(value, c1.FloatValue());
Assert.Equal((double)value, c1.DoubleValue());
}
public void FromByteArrayBitSet()
{
var random = RandomRegistry.GetRandom();
var bytes = new byte[234];
random.NextBytes(bytes);
var bits = new BitArray(bytes);
var c = BitChromosome.Of(bits);
Assert.Equal(bytes, c.ToByteArray());
Assert.Equal(bytes, bits.ToByteArray());
}
public void ToByteArray()
{
var random = RandomRegistry.GetRandom();
var data = new byte[16];
for (var i = 0; i < data.Length; ++i)
{
data[i] = (byte)(random.Next() * 256);
}
var bc = new BitChromosome(data);
Assert.Equal(data, bc.ToByteArray());
}
public void NewInstance()
{
const int size = 50000;
var @base = BitChromosome.Of(size, 0.5);
for (var i = 0; i < 100; ++i)
{
var other = @base.NewInstance();
Assert.NotEqual(@base, other);
Assert.True(Math.Abs(1 - other.BitCount() / (size / 2.0)) < 0.02);
}
}
public void FromBitSet()
{
var random = RandomRegistry.GetRandom();
var bits = new BitArray(2343);
for (var i = 0; i < bits.Count; ++i)
{
bits[i] = random.NextBoolean();
}
var c = BitChromosome.Of(bits);
Assert.Equal(bits.ToByteArray(), c.ToByteArray());
}
public void BitCount(double p)
{
const int size = 1000;
var @base = BitChromosome.Of(size, p);
for (var i = 0; i < 1000; ++i)
{
var other = @base.NewInstance();
var bitCount = other.Count(gene => gene.BooleanValue());
Assert.Equal(bitCount, other.BitCount());
}
}
public void Invert()
{
var c1 = BitChromosome.Of(100, 0.3);
var c3 = c1.Invert();
for (var i = 0; i < c1.Length; ++i)
{
Assert.True(c1.GetGene(i).GetBit() != c3.GetGene(i).GetBit());
}
var c4 = c3.Invert();
Assert.Equal(c1, c4);
}
public void IntProbability()
{
var c = BitChromosome.Of(10, 0);
foreach (var g in c)
{
Assert.False(g.GetBit());
}
c = BitChromosome.Of(10, 1);
foreach (var g in c)
{
Assert.True(g.GetBit());
}
}
public void BitChromosomeBitSet()
{
var bits = new BitArray(10);
for (var i = 0; i < 10; ++i)
{
bits[i] = i % 2 == 0;
}
var c = BitChromosome.Of(bits);
for (var i = 0; i < bits.Length; ++i)
{
Assert.Equal(c.GetGene(i).GetBit(), i % 2 == 0);
}
}
public int CompareTo(BitChromosome other)
{
return(ToBigInteger().CompareTo(other.ToBigInteger()));
}
protected override Factory <IChromosome <BitGene> > Factory()
{
return(() => BitChromosome.Of(500, 0.3));
}
