protected override IEvolvable crossover(IEvolvable other) { if (other is SelectMutateCrossoverPopulation) { SelectMutateCrossoverPopulation mate = (SelectMutateCrossoverPopulation)other; return(new SelectMutateCrossoverPopulation( this.ParentPopulation, Evolution.RandomInterpolation(random, this.MutationRate, mate.MutationRate), Evolution.RandomInterpolation(random, this.EliteClonePercentage, mate.EliteClonePercentage), Evolution.RandomInterpolation(random, this.SelectedPercentage, mate.SelectedPercentage), Evolution.RandomInterpolation(random, this.NewPopulationSize, mate.NewPopulationSize), 0, (int)Evolution.RandomInterpolation(random, this.Resources, mate.Resources), (int)Evolution.RandomInterpolation(random, this.Feedings, mate.Feedings), Evolution.RandomInterpolation(random, this.EnoughFeedingsForBreeding, mate.EnoughFeedingsForBreeding), random, random.NextDouble() < 0.5 ? this.Creator : mate.Creator, 0, 0, 0, this.Fitness > mate.Fitness ? this.FitnessHistory.Select(a => a).ToList() : mate.FitnessHistory.Select(a => a).ToList(), this.individuals.Union(mate.individuals).OrderByDescending(a => a.Fitness).Take((int)Evolution.RandomInterpolation(random, this.PopulationSize, mate.PopulationSize)).ToList(), this.BestOfAllTime.Fitness > mate.BestOfAllTime.Fitness ? this.BestOfAllTime : mate.BestOfAllTime, 0, 0, Mutations + mate.Mutations, Crossovers + mate.Crossovers, FitnessEvaluations + mate.FitnessEvaluations, 0 )); } else { return(base.crossover(other)); } }
/// <summary> /// Encode and write a binary representation of the given /// <b>IMessage</b> to the given <see cref="DataWriter"/>. /// </summary> /// <remarks> /// Using the passed <see cref="IChannel"/>, the Codec has access to /// both the <see cref="IMessageFactory"/> for the <b>IChannel</b> /// and the underlying <see cref="IConnection"/>. /// </remarks> /// <param name="channel"> /// The <b>IChannel</b> object through which the binary-encoded /// <b>IMessage</b> was passed. /// </param> /// <param name="message"> /// The <b>IMessage</b> to encode. /// </param> /// <param name="writer"> /// The <b>DataWriter</b> to write the binary representation of the /// <b>IMessage</b> to. /// </param> /// <exception cref="IOException"> /// If an error occurs encoding or writing the <b>IMessage</b>. /// </exception> /// <seealso cref="ICodec.Encode"/> public virtual void Encode(IChannel channel, IMessage message, DataWriter writer) { Debug.Assert(channel is IPofContext); Debug.Assert(message is IPortableObject); IPofContext context = (IPofContext)channel; PofStreamWriter pofwriter = new PofStreamWriter.UserTypeWriter(writer, context, message.TypeId, 0); ISerializer serializer = channel.Serializer; if (serializer is ConfigurablePofContext) { ConfigurablePofContext pofCtx = (ConfigurablePofContext)serializer; if (pofCtx.IsReferenceEnabled) { pofwriter.EnableReference(); } } // set the version identifier bool isEvolvable = message is IEvolvable; IEvolvable evolvable = null; if (isEvolvable) { evolvable = (IEvolvable)message; pofwriter.VersionId = Math.Max(evolvable.DataVersion, evolvable.ImplVersion); } // write the Message properties ((IPortableObject)message).WriteExternal(pofwriter); // write the future properties pofwriter.WriteRemainder(isEvolvable ? evolvable.FutureData : null); }
/// <summary> /// Serialize a user type instance to a POF stream by writing its /// state using the specified <see cref="IPofWriter"/> object. /// </summary> /// <remarks> /// An implementation of <b>IPofSerializer</b> is required to follow /// the following steps in sequence for writing out an object of a /// user type: /// <list type="number"> /// <item> /// <description> /// If the object is evolvable, the implementation must set the /// version by calling <see cref="IPofWriter.VersionId"/>. /// </description> /// </item> /// <item> /// <description> /// The implementation may write any combination of the properties of /// the user type by using the "write" methods of the /// <b>IPofWriter</b>, but it must do so in the order of the property /// indexes. /// </description> /// </item> /// <item> /// <description> /// After all desired properties of the user type have been written, /// the implementation must terminate the writing of the user type by /// calling <see cref="IPofWriter.WriteRemainder"/>. /// </description> /// </item> /// </list> /// </remarks> /// <param name="writer"> /// The <b>IPofWriter</b> with which to write the object's state. /// </param> /// <param name="o"> /// The object to serialize. /// </param> /// <exception cref="IOException"> /// If an I/O error occurs. /// </exception> public virtual void Serialize(IPofWriter writer, object o) { // set the version identifier bool isEvolvable = o is IEvolvable; IEvolvable evolvable = null; if (isEvolvable) { evolvable = (IEvolvable)o; writer.VersionId = Math.Max(evolvable.DataVersion, evolvable.ImplVersion); } // POF Annotation processing for (IEnumerator enmr = m_tmd.GetAttributes(); enmr.MoveNext();) { IAttributeMetadata <object> attr = (IAttributeMetadata <object>)enmr.Current; attr.Codec.Encode(writer, attr.Index, attr.Get(o)); } // write out any future properties Binary remainder = null; if (isEvolvable) { remainder = evolvable.FutureData; } writer.WriteRemainder(remainder); }
/// <summary> /// Deserialize a user type instance from a POF stream by reading its /// state using the specified <see cref="IPofReader"/> object. /// </summary> /// <remarks> /// An implementation of <b>IPofSerializer</b> is required to follow /// the following steps in sequence for reading in an object of a /// user type: /// <list type="number"> /// <item> /// <description> /// If the object is evolvable, the implementation must get the /// version by calling <see cref="IPofWriter.VersionId"/>. /// </description> /// </item> /// <item> /// <description> /// The implementation may read any combination of the /// properties of the user type by using "read" methods of the /// <b>IPofReader</b>, but it must do so in the order of the property /// indexes. /// </description> /// </item> /// <item> /// <description> /// After all desired properties of the user type have been read, /// the implementation must terminate the reading of the user type by /// calling <see cref="IPofReader.ReadRemainder"/>. /// </description> /// </item> /// </list> /// </remarks> /// <param name="reader"> /// The <b>IPofReader</b> with which to read the object's state. /// </param> /// <returns> /// The deserialized user type instance. /// </returns> /// <exception cref="IOException"> /// If an I/O error occurs. /// </exception> public virtual object Deserialize(IPofReader reader) { ITypeMetadata <object> tmd = m_tmd; object value = tmd.NewInstance(); // set the version identifier bool isEvolvable = value is IEvolvable; IEvolvable evolvable = null; if (isEvolvable) { evolvable = (IEvolvable)value; evolvable.DataVersion = reader.VersionId; } // POF Annotation processing for (IEnumerator enmr = tmd.GetAttributes(); enmr.MoveNext();) { IAttributeMetadata <object> attr = (IAttributeMetadata <object>)enmr.Current; attr.Set(value, attr.Codec.Decode(reader, attr.Index)); } // read any future properties Binary remainder = reader.ReadRemainder(); if (isEvolvable) { evolvable.FutureData = remainder; } return(value); }
public IEvolvable Crossover(IEvolvable other) { StencilSpeciesArr mate = (StencilSpeciesArr)other; if (this.Equals(mate)) { var result = this.Clone(); result.Mutate(); return(result); } else { int[] cPerProcessor = (int[])cellsPerProcessor.Clone(); int freeCells = this.Field.Length; // initialize field with -1 or cells that are equal in both mates Arr <int> field = new Arr <int>(this.Field.SizeX, this.Field.SizeY); freeCells -= fillWithEqualGenesOrMinusOne(field, this.Field, mate.Field, cPerProcessor); while (freeCells > 0) { int position = field.FreePosition(random.Next(0, freeCells), -1); int processor = suitableValue(random, freeCells, this.Field, mate.Field, position, cPerProcessor); field[position] = processor; cPerProcessor[processor]--; freeCells--; } StencilSpeciesArr result = new StencilSpeciesArr(this, field); result.Optimize(3); return(result); } }
/// <summary> /// Reads a binary-encoded <b>IMessage</b> from the passed /// <see cref="DataReader"/> object. /// </summary> /// <remarks> /// Using the passed <see cref="IChannel"/>, the Codec has access to /// both the <see cref="IMessageFactory"/> for the <b>IChannel</b> /// and the underlying <see cref="IConnection"/>. /// </remarks> /// <param name="channel"> /// The <b>IChannel</b> object through which the binary-encoded /// <b>IMessage</b> was passed. /// </param> /// <param name="reader"> /// The <b>DataReader</b> containing the binary-encoded /// <b>IMessage</b>. /// </param> /// <returns> /// The <b>IMessage</b> object encoded in the given /// <b>DataReader</b>. /// </returns> /// <exception cref="IOException"> /// If an error occurs reading or decoding the <b>IMessage</b>. /// </exception> public virtual IMessage Decode(IChannel channel, DataReader reader) { Debug.Assert(channel is IPofContext); IPofContext context = (IPofContext)channel; int typeId = reader.ReadPackedInt32(); int versionId = reader.ReadPackedInt32(); IPofReader pofreader = new PofStreamReader.UserTypeReader(reader, context, typeId, versionId); IMessage message = channel.MessageFactory.CreateMessage(typeId); Debug.Assert(message is IPortableObject); // set the version identifier bool isEvolvable = message is IEvolvable; IEvolvable evolvable = null; if (isEvolvable) { evolvable = (IEvolvable)message; evolvable.DataVersion = versionId; } // read the Message properties ((IPortableObject)message).ReadExternal(pofreader); // read the future properties Binary binFuture = pofreader.ReadRemainder(); if (isEvolvable) { evolvable.FutureData = binFuture; } return(message); }
private void set(IEvolvable[] population, int index, IEvolvable value) { while (contains(population, index, value)) { value.Mutate(); } population[index] = value; }
public IEvolvable Crossover(IEvolvable mate) { if (ParentPopulation != null) { ParentPopulation.NoteCrossovers(); } EvolveCrossovers++; return(crossover(mate)); }
public IEvolvable Crossover(IEvolvable other) { TestEvolvable result = new TestEvolvable(random, chromosomes.Length); for (int i = 0; i < chromosomes.Length; i++) { result.chromosomes[i] = random.NextDouble() < 0.5 ? this.chromosomes[i] : (other as TestEvolvable).chromosomes[i]; } return(result); }
public double DifferenceTo(IEvolvable other) { double result = 0; for (int i = 0; i < chromosomes.Length; i++) { result += Math.Abs(this.chromosomes[i] - (other as TestEvolvable).chromosomes[i]); } return(result); }
/// <summary> /// Deserialize a user type instance from a POF stream by reading its /// state using the specified <see cref="IPofReader"/> object. /// </summary> /// <remarks> /// An implementation of <b>IPofSerializer</b> is required to follow /// the following steps in sequence for reading in an object of a /// user type: /// <list type="number"> /// <item> /// <description> /// If the object is evolvable, the implementation must get the /// version by calling <see cref="IPofReader.VersionId"/>. /// </description> /// </item> /// <item> /// <description> /// The implementation may read any combination of the /// properties of the user type by using "read" methods of the /// <b>IPofReader</b>, but it must do so in the order of the property /// indexes. Additionally, the implementation must call /// {@link IPofReader#RegisterIdentity} with the new instance prior /// to reading any properties which are user type instances /// themselves. /// </description> /// </item> /// <item> /// <description> /// After all desired properties of the user type have been read, /// the implementation must terminate the reading of the user type by /// calling <see cref="IPofReader.ReadRemainder"/>. /// </description> /// </item> /// </list> /// </remarks> /// <param name="pofReader"> /// The <b>IPofReader</b> with which to read the object's state. /// </param> /// <returns> /// The deserialized user type instance. /// </returns> /// <exception cref="IOException"> /// If an I/O error occurs. /// </exception> public Object Deserialize(IPofReader pofReader) { try { IPortableObject po = (IPortableObject) Activator.CreateInstance(GetTypeForTypeId(pofReader.PofContext, m_nTypeId)); CacheFactory.Log("Deserializing " + po.GetType(), CacheFactory.LogLevel.Max); bool fEvolvable = po is IEvolvableObject; IEvolvableObject et = fEvolvable ? (IEvolvableObject)po : null; int typeId = ((PofStreamReader.UserTypeReader)pofReader).NextPropertyIndex; while (typeId > 0) { IEvolvable e = null; IPofReader reader = pofReader.CreateNestedPofReader(typeId); if (fEvolvable) { e = et.GetEvolvable(typeId); e.DataVersion = reader.VersionId; } po.ReadExternal(reader); Binary binRemainder = reader.ReadRemainder(); if (fEvolvable) { e.FutureData = binRemainder; } typeId = ((PofStreamReader.UserTypeReader)pofReader).NextPropertyIndex; } pofReader.ReadRemainder(); return(po); } catch (Exception e) { String sClass = null; try { sClass = pofReader.PofContext.GetTypeName(m_nTypeId); } catch (Exception) { } throw new IOException( "An exception occurred instantiating a IPortableObject" + " user type from a POF stream: type-id=" + m_nTypeId + (sClass == null ? "" : ", class-name=" + sClass) + ", exception=\n" + e, e); } }
public IEvolvable FindMate(IEvolvable evolvable) { // return IndividualsSortedByFitness.Take(10).MaxElement(a => evolvable.DifferenceTo(a)); // sort by difference and then take the best out of the top 10! :D return(Individuals.OrderByDescending(a => evolvable.DifferenceTo(a)).Take(10).OrderByDescending(a => a.Fitness).First()); //return IndividualsSortedByFitness.Take(3).MaxElement(a => evolvable.DifferenceTo(a)); //return Best; //return IndividualsSortedByFitness.MaxElement(a => evolvable.DifferenceTo(a)); }
private bool contains(List <IEvolvable> list, IEvolvable value) { for (int i = 0; i < list.Count; i++) { if (list[i].Equals(value)) { return(true); } } return(false); }
protected virtual IEvolvable crossover(IEvolvable other) { EvolvablePopulation mate = (EvolvablePopulation)other; EvolvablePopulation child = (EvolvablePopulation)(this.Fitness > mate.Fitness ? this.Clone() : other.Clone()); foreach (IEvolvable individual in mate.individuals) { child.individuals.Add(individual.Clone()); } return(child); }
public override IEvolvable Create() { IEvolvable result = base.Create(); if ((result as Evolver).Evolvable is EvolvablePopulation) { ((result as Evolver).Evolvable as EvolvablePopulation).ParentPopulation = this; } return(result); }
private bool contains(IEvolvable[] population, int index, IEvolvable value) { for (int i = 0; i < index; i++) { if (population[i].Equals(value)) { return(true); } } return(false); }
public virtual IEvolvable GetEvolvable(int nTypeId) { if (m_evolvable == null) { m_evolvable = new SimpleEvolvable(1); } if (3 == nTypeId) { return(m_evolvable); } return(GetEvolvableHolder().GetEvolvable(nTypeId)); }
/// <summary> /// Serialize a user type instance to a POF stream by writing its /// state using the specified <see cref="IPofWriter"/> object. /// </summary> /// <remarks> /// An implementation of <b>IPofSerializer</b> is required to follow /// the following steps in sequence for writing out an object of a /// user type: /// <list type="number"> /// <item> /// <description> /// If the object is evolvable, the implementation must set the /// version by calling <see cref="IPofWriter.VersionId"/>. /// </description> /// </item> /// <item> /// <description> /// The implementation may write any combination of the properties of /// the user type by using the "write" methods of the /// <b>IPofWriter</b>, but it must do so in the order of the property /// indexes. /// </description> /// </item> /// <item> /// <description> /// After all desired properties of the user type have been written, /// the implementation must terminate the writing of the user type by /// calling <see cref="IPofWriter.WriteRemainder"/>. /// </description> /// </item> /// </list> /// </remarks> /// <param name="writer"> /// The <see cref="IPofWriter"/> with which to write the object's /// state. /// </param> /// <param name="o"> /// The object to serialize. /// </param> /// <exception cref="IOException"> /// If an I/O error occurs. /// </exception> public virtual void Serialize(IPofWriter writer, object o) { IPortableObject portable; try { portable = (IPortableObject)o; } catch (InvalidCastException e) { string typeName = null; try { typeName = writer.PofContext.GetTypeName(m_typeId); } catch (Exception) {} string actual = o.GetType().FullName; throw new IOException( "An exception occurred writing an IPortableObject" + " user type to a POF stream: type-id=" + m_typeId + (typeName == null ? "" : ", class-name=" + typeName) + (actual == null ? "" : ", actual class-name=" + actual) + ", exception=\n" + e); } // set the version identifier bool isEvolvable = portable is IEvolvable; IEvolvable evolvable = null; if (isEvolvable) { evolvable = (IEvolvable)portable; writer.VersionId = Math.Max(evolvable.DataVersion, evolvable.ImplVersion); } // write out the object's properties portable.WriteExternal(writer); // write out any future properties Binary remainder = null; if (isEvolvable) { remainder = evolvable.FutureData; } writer.WriteRemainder(remainder); }
protected virtual IPresentable AsDetailPresentable(string title, IEvolvable evolvable) { if (evolvable is IPopulation) { new Presentable("Population", new Label() { Content = evolvable.ToString() }); } if (evolvable is IPresentable) { return(new Presentable(title, (evolvable as IPresentable).PresentableControl)); } return(new Presentable(title, new Label() { Content = evolvable.ToString() })); }
protected static void orderedIndividualsTest(IPopulation population) { IEvolvable latest = population.Best; foreach (IEvolvable next in population.IndividualsSortedByFitness) { AssertEx.IsLessThanOrEqualTo(next.Fitness, latest.Fitness); latest = next; } foreach (IEvolvable evolvable in population.Individuals) { Assert.IsNotNull(evolvable); } foreach (var individual in population.Individuals) { if (individual is IPopulation) { orderedIndividualsTest(individual as IPopulation); } } }
/// <summary> /// Initialize the specified (newly instantiated) PortableObject instance /// using the specified reader. /// </summary> /// <param name="portable">The object to initialize.</param> /// <param name="reader"> /// The PofReader with which to read the object's state. /// </param> public void Initialize(IPortableObject portable, IPofReader reader) { // set the version identifier bool isEvolvable = portable is IEvolvable; IEvolvable evolvable = null; if (isEvolvable) { evolvable = (IEvolvable)portable; evolvable.DataVersion = reader.VersionId; } // read the object's properties portable.ReadExternal(reader); // read any future properties Binary remainder = reader.ReadRemainder(); if (isEvolvable) { evolvable.FutureData = remainder; } }
public void Feed(double resources) { FoodConsumedInLifetime += resources; FoodForMutation += resources; FoodForReproduction += resources; if (FoodForMutation >= FoodNeededForMutation) { (population as IndividualMutateAndCrossoverPopulation).AddChild(this.clone()); Mutate(); FoodForMutation -= FoodNeededForMutation; FoodNeededForMutation = mutate(random, FoodNeededForMutation, 1, 100, 10); FoodNeededForReproduction = mutate(random, FoodNeededForReproduction, 1, 100, 10); } if (FoodForReproduction >= FoodNeededForReproduction) { IEvolvable mate = (population as IndividualMutateAndCrossoverPopulation).FindMate(this); IEvolvable child = this.Crossover(mate); (population as IndividualMutateAndCrossoverPopulation).AddChild(child); FoodForReproduction -= FoodNeededForReproduction; } }
protected override IEvolvable crossover(IEvolvable other) { if (other is IndividualMutateAndCrossoverPopulation) { IndividualMutateAndCrossoverPopulation mate = (IndividualMutateAndCrossoverPopulation)other; return(new IndividualMutateAndCrossoverPopulation( this.ParentPopulation, Evolution.RandomInterpolation(random, this.MaxSize, mate.MaxSize), new List <IEvolvable>(), (int)Evolution.RandomInterpolation(random, this.FoodForPopulation, mate.FoodForPopulation), random, random.NextDouble() < 0.5 ? this.Creator : mate.Creator, 0, 0, 0, this.Fitness > mate.Fitness ? this.FitnessHistory.Select(a => a).ToList() : mate.FitnessHistory.Select(a => a).ToList(), this.individuals.Union(mate.individuals).OrderByDescending(a => a.Fitness).Take((int)Evolution.RandomInterpolation(random, this.PopulationSize, mate.PopulationSize)).ToList(), this.BestOfAllTime.Fitness > mate.BestOfAllTime.Fitness ? this.BestOfAllTime : mate.BestOfAllTime, 0, 0, Mutations + mate.Mutations, Crossovers + mate.Crossovers, FitnessEvaluations + mate.FitnessEvaluations, 0 )); } else { return(base.crossover(other)); } }
protected override double differenceTo(IEvolvable other) { return(other is Evolver?Evolvable.DifferenceTo((other as Evolver).Evolvable) : Evolvable.DifferenceTo(other)); }
protected override IEvolvable crossover(IEvolvable mate) { return(new Evolver(population, mate is Evolver ? Evolvable.Crossover((mate as Evolver).Evolvable) : Evolvable.Crossover(mate))); }
public Evolver(IPopulation population, IEvolvable evolvable) : base(population) { Evolvable = evolvable; }
protected Population(ICreator creator, Random random, List <IEvolvable> individuals, IEvolvable bestOfAllTime, int populationSize, long generations, long mutations, long crossovers, long fitnessEvaluations, double foodConsumedInLifetime) : base(foodConsumedInLifetime) { construct(creator, random, individuals, bestOfAllTime, populationSize, generations, mutations, crossovers, fitnessEvaluations); }
protected SelectMutateCrossoverPopulation(IPopulation population, double mutationRate, double eliteClonePercentage, double selectedPercentage, double newPopulationSize, int breedingsSoFar, double resources, int feedings, double enoughFeedingsForBreeding, Random random, ICreator creator, int evolvableMutations, int evolvableCrossovers, int evolvableFitnessEvaluations, List <double> fitnessHistory, List <IEvolvable> individuals, IEvolvable bestOfAllTime, int populationSize, long generations, long mutations, long crossovers, long fitnessEvaluations, double foodConsumedInLifetime) : base(population, random, creator, evolvableMutations, evolvableCrossovers, evolvableFitnessEvaluations, fitnessHistory, individuals, bestOfAllTime, populationSize, generations, mutations, crossovers, fitnessEvaluations, foodConsumedInLifetime) { construct(mutationRate, eliteClonePercentage, selectedPercentage, newPopulationSize, breedingsSoFar, resources, feedings, enoughFeedingsForBreeding); }
public override double DifferenceTo(IEvolvable other) { throw new NotImplementedException(); }
protected virtual void breed() { IEvolvable[] newPopulation = new IEvolvable[(int)NewPopulationSize]; int newPopulationIndex = 0; measureFitness(); var orderedPopulation = individuals.OrderByDescending(a => a.Fitness).ToArray(); // clone the elite for (; newPopulationIndex < (int)Math.Min(PopulationSize, NewPopulationSize * EliteClonePercentage); newPopulationIndex++) { newPopulation[newPopulationIndex] = orderedPopulation[newPopulationIndex].Clone(); } // mutate some for (int i = 0; i < PopulationSize; i++) { if (random.NextDouble() <= MutationRate) { individuals[i].Mutate(); } } orderedPopulation = individuals.OrderByDescending(a => a.Fitness).ToArray(); // select the best for (int oldPopulationIndex = 0; newPopulationIndex < (int)Math.Min(PopulationSize, NewPopulationSize * SelectedPercentage); newPopulationIndex++, oldPopulationIndex++) { set(newPopulation, newPopulationIndex, orderedPopulation[oldPopulationIndex]); } if (newPopulationIndex <= 1) { for (; newPopulationIndex < (int)NewPopulationSize; newPopulationIndex++) { set(newPopulation, newPopulationIndex, orderedPopulation[0].Clone()); } } else { int parents = newPopulationIndex; // crossover to repopulate for (; newPopulationIndex < (int)NewPopulationSize; newPopulationIndex++) { int parentIndex1 = random.Next(0, parents); int parentIndex2 = random.Next(0, parents - 1); if (parentIndex1 <= parentIndex2) { parentIndex2++; } set(newPopulation, newPopulationIndex, newPopulation[parentIndex1].Crossover(newPopulation[parentIndex2])); } } this.individuals = newPopulation.OrderByDescending(a => a.Fitness).ToList(); Generations++; invalidateCaches(); }