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);
}
protected ChromosomeBase(IImmutableSeq <TGene> genes)
{
if (genes.Empty())
{
throw new ArgumentException("The genes sequence must contain at least one gene.");
}
Genes = genes;
}
public override IChromosome <AnyGene <TAllele> > NewInstance(IImmutableSeq <AnyGene <TAllele> > genes)
{
return(new AnyChromosome <TAllele>(
genes,
_supplier,
_alleleValidator,
_alleleSeqValidator
));
}
public static ICodec <IImmutableSeq <T>, BitGene> OfSubSet <T>(IImmutableSeq <T> basicSet)
{
Positive(basicSet.Length);
return(Codec.Of(
() => Genotype.Of(BitChromosome.Of(basicSet.Length)),
gt => ((BitChromosome)gt.GetChromosome()).Ones().Select(i => basicSet[i]).ToImmutableSeq()
));
}
protected internal AnyChromosome(
IImmutableSeq <AnyGene <TAllele> > genes,
Func <TAllele> supplier,
Func <TAllele, bool> alleleValidator,
Func <IImmutableSeq <TAllele>, bool> alleleSeqValidator
) : base(genes)
{
_supplier = NonNull(supplier);
_alleleValidator = NonNull(alleleValidator);
_alleleSeqValidator = NonNull(alleleSeqValidator);
}
public static ICodec <IImmutableSeq <T>, EnumGene <T> > OfSubSet <T>(
IImmutableSeq <T> basicSet,
int size
)
{
NonNull(basicSet);
Base.CheckSubSet(basicSet.Length, size);
return(Codec.Of(
() => Genotype.Of(PermutationChromosome.Of(basicSet, size)),
gt => gt.GetChromosome()
.Select(g => g.Allele)
.ToImmutableSeq()));
}
public EnumGene(int alleleIndex, IImmutableSeq <TAllele> validAlleles)
{
if (validAlleles.IsEmpty)
{
throw new ArgumentException(
"Array of valid alleles must be greater than zero."
);
}
if (alleleIndex < 0 || alleleIndex >= validAlleles.Length)
{
throw new IndexOutOfRangeException($"Allele index is not in range [0, {alleleIndex}).");
}
_validAlleles = validAlleles;
_alleleIndex = alleleIndex;
}
private DoubleChromosome(IImmutableSeq <DoubleGene> genes) : base(genes)
{
}
public override IChromosome <DoubleGene> NewInstance(IImmutableSeq <DoubleGene> genes)
{
return(new DoubleChromosome(genes));
}
public CharacterChromosome(IImmutableSeq <CharacterGene> genes) : base(genes)
{
_validCharacters = genes[0].GetValidCharacters();
}
public override IChromosome <CharacterGene> NewInstance(IImmutableSeq <CharacterGene> genes)
{
return(new CharacterChromosome(genes));
}
public override IChromosome <IntegerGene> NewInstance(IImmutableSeq <IntegerGene> genes)
{
return(new IntegerChromosome(genes));
}
public abstract IChromosome <TGene> NewInstance(IImmutableSeq <TGene> genes);
private Genotype(IImmutableSeq <IChromosome <TGene> > chromosomes, int ngenes)
{
_chromosomes = chromosomes;
_ngenes = ngenes;
}
public IHash And <T>(IImmutableSeq <T> values)
{
_hash += values.GetHashCode();
return(this);
}
public PermutationChromosome(IImmutableSeq <EnumGene <T> > genes, bool?valid = null) : base(genes)
{
_validAlleles = genes[0].GetValidAlleles();
Valid = valid;
}
public override IChromosome <EnumGene <T> > NewInstance(IImmutableSeq <EnumGene <T> > genes)
{
return(new PermutationChromosome <T>(genes));
}
private static int Ngenes(IImmutableSeq <IChromosome <TGene> > chromosomes)
{
return(chromosomes.Select(c => c.Length).Sum());
}
internal Genotype <TGene> NewInstance(IImmutableSeq <IChromosome <TGene> > chromosomes)
{
return(new Genotype <TGene>(chromosomes, _ngenes));
}
private LongChromosome(IImmutableSeq <LongGene> genes) : base(genes)
{
}
public Genotype(IImmutableSeq <IChromosome <TGene> > chromosomes) : this(chromosomes, Ngenes(chromosomes))
{
}
public Record(string name, double price, IImmutableSeq <string> songs)
{
Name = NonNull(name);
Price = price;
Songs = NonNull(songs);
}
private SubsetSum(IImmutableSeq <int> basicSet, int size)
{
_basicSet = NonNull(basicSet);
_size = size;
}
private Springsteen(IImmutableSeq <Record> records, double maxPricePerUniqueSong)
{
_records = NonNull(records);
_maxPricePerUniqueSong = maxPricePerUniqueSong;
}
private IntegerChromosome(IImmutableSeq <IntegerGene> genes) : base(genes)
{
}
private Knapsack(IImmutableSeq <Item> items, double knapsackSize)
{
_codec = Codecs.OfSubSet(items);
_knapsackSize = knapsackSize;
}
protected BoundedChromosomeBase(IImmutableSeq<TGene> genes) : base(genes)
{
Min = genes[0].Min;
Max = genes[0].Max;
}
public override IChromosome <LongGene> NewInstance(IImmutableSeq <LongGene> genes)
{
return(new LongChromosome(genes));
}
