Performance enhancements and improved BottlesOfBeerFitness.

Author: primaryobjects

AIProgrammer.Fitness/Base/FitnessBase.cs

@@ -71,10 +71,7 @@ public double GetFitness(double[] weights)
             // Append any functions to the program.
             if (_appendFunctions != null)
             {
-                StringBuilder s = new StringBuilder(Program);
-                s.Append("!");
-                s.Append(_appendFunctions);
-                Program = s.ToString();
+                Program += "!" + _appendFunctions;
             }
 
             // Get the fitness.

AIProgrammer.Fitness/Concrete/BottlesOfBeerFitness.cs

@@ -20,15 +20,14 @@ public class BottlesOfBeerFitness : FitnessBase
     {
         private static byte[][] _trainingExamples = { new byte[] { 5, 4, 3, 2, 1, 0 },
                                       new byte[] { 3, 2, 1, 0 },
-                                      new byte[] { 2, 1, 0 }/*,
-                                      new byte[] { 6, 5, 4, 3, 2, 1, 0 }*/ };
-        private static string _targetString = "b";
+                                      new byte[] { 2, 1, 0 } };
+        private static string _targetString = "bottles of beer";
 
         /// <summary>
-        /// Previously generated BrainPlus functions for outputting the terms: bottles,of,beer,on,the,wall. This includes a 7th generated function that calls the other generated functions to output "bottles of beer". Generated using StrictStringFitness with StringFunction.
+        /// Previously generated BrainPlus functions for outputting the terms: bottles,of,beer,bottles of beer. Generated using StrictStringFitness with StringFunction.
         /// To use, set _appendCode = BottlesOfBeerFitness.BottlesOfBeerFunctions in main program.
         /// </summary>
-        public static string BottlesOfBeerFunctions = "&6++.+++++++++++++[.+++[++..--------.-------.++++++++++++++.-%&[]7[[-.---------.[][.+>[t[-]-[,]+>,>++<]<]],>[]><]],-<]++,><%&6++.+++..7++.[6+[+<>[>>-]>><>-.+.><><-]<.<].+]..+-<+]+.[...,%&+8[+[+]7-.-.>[22+[[-..[[<-...][,.,<<>,>,,.,,]+<<++,]+>+,+]>+%&6+t+++i++[++-+[+++++[+++++++.-----[-[--[--[--.[-+----+.-[[[>%&7++++++[+.------[--------[--------.+++++++-+++++..[+>+>[++[<%&1+++++++++++++>a---<+++.>.---------.<.c[>>>[<,,>+<[-],+<>.<,%&d2.[e2.f]--->2[>-]<[>]v-......<+[+<>+>]].,+,>[<++,>><,]-.>,+%";
+        public static string BottlesOfBeerFunctions = "&6++.+++++++++++++[.+++[++..--------.-------.++++++++++++++.-%&[]7[[-.---------.%&6++.+++..7++.%&1+++++++++++++>a---<+++.>.---------.<.c%";
 
         public BottlesOfBeerFitness(GA ga, int maxIterationCount, string appendFunctions = null)
             : base(ga, maxIterationCount, appendFunctions)
@@ -145,7 +144,7 @@ protected override void RunProgramMethod(string program)
                 Console.Write(">: ");
                 byte startingValue = Byte.Parse(Console.ReadLine());
                 int index = 0;
-                bool odd = true;
+                int index2 = 0;
 
                 _console.Clear();
 
@@ -171,7 +170,7 @@ protected override void RunProgramMethod(string program)
                     (b) =>
                     {
                         // The program correctly solves the problem, however the output is in byte format. For example: 5b => 598 (where 98 = 'b'). We need to format the output for humans to read by leaving the numeric values as byte and the text values as char.
-                        if (odd)
+                        if (index2++ % (_targetString.Length + 1) == 0)
                         {
                             // Append numeric byte value.
                             _console.Append(b);
@@ -181,8 +180,6 @@ protected override void RunProgramMethod(string program)
                             // Append text.
                             _console.Append((char)b);
                         }
-
-                        odd = !odd;
                     });
 
                     bf.Run(_maxIterationCount);

AIProgrammer.GA/GA.cs

@@ -47,6 +47,7 @@ public class GA : IGeneticAlgorithm
 	{
         public GAParams GAParams { get; set; }
         public bool Stop { get; set; }
+        private DateTime _lastEpoch = DateTime.Now;
 
 		/// <summary>
 		/// Default constructor sets mutation rate to 5%, crossover to 80%, population to 100,
@@ -128,13 +129,15 @@ public void Go(bool resume = false)
 
                 if (GAParams.CurrentGeneration % 100 == 0)
                 {
-                    Console.WriteLine("Generation " + GAParams.CurrentGeneration + ", Best Fitness: " + fitness);
+                    Console.WriteLine("Generation " + GAParams.CurrentGeneration + ", Time: " + Math.Round((DateTime.Now - _lastEpoch).TotalSeconds, 2) + "s, Best Fitness: " + fitness);
 
                     if (GAParams.HistoryPath != "")
                     {
                         // Record history timeline.
                         File.AppendAllText(GAParams.HistoryPath, DateTime.Now.ToString() + "," + fitness + "," + GAParams.TargetFitness + "," + GAParams.CurrentGeneration + "\r\n");
                     }
+
+                    _lastEpoch = DateTime.Now;
                 }
 
                 if (GAParams.TargetFitness > 0 && fitness >= GAParams.TargetFitness)

AIProgrammer.Interpreter/Interpreter.cs

@@ -36,6 +36,7 @@ public class FunctionCallObj
             public int DataPointer { get; set; }
             public Stack<int> CallStack { get; set; }
             public bool ExitLoop { get; set; }
+            public int ExitLoopInstructionPointer { get; set; }
             public int Ticks { get; set; }
         };
 
@@ -93,7 +94,7 @@ public class FunctionCallObj
         /// <summary>
         /// The list of functions and their starting instruction index.
         /// </summary>
-        private readonly Dictionary<char, int> m_Functions = new Dictionary<char, int>(26);
+        private readonly Dictionary<char, int> m_Functions = new Dictionary<char, int>();
 
         /// <summary>
         /// Identifier for next function. Will serve as the instruction to call this function.
@@ -110,6 +111,11 @@ public class FunctionCallObj
         /// </summary>
         private Stack<int> m_CurrentCallStack;
 
+        /// <summary>
+        /// Number of cells available to functions for memory. When a function is executed, an array of cells are allocated in upper-memory addresses (eg., 1000-1999, 2000-2999, etc.) for usage.
+        /// </summary>
+        private const int _memoryAvailableForFunctions = 255;
+
         /// <summary>
         /// Number of instructions executed.
         /// </summary>
@@ -228,6 +234,8 @@ public Interpreter(string programCode, Func<byte> input, Action<byte> output)
                 this.m_CurrentCallStack = temp.CallStack;
                 // Restore exit loop status.
                 this.m_ExitLoop = temp.ExitLoop;
+                // Restore exit loop instruction pointer.
+                this.m_ExitLoopInstructionPointer = temp.ExitLoopInstructionPointer;
                 // Restore ticks.
                 this.m_Ticks = temp.Ticks;
                 // Restore the instruction pointer.
@@ -244,21 +252,22 @@ public Interpreter(string programCode, Func<byte> input, Action<byte> output)
                 this.m_InstructionSet.Add(instruction, () =>
                 {
                     // Store the current instruction pointer and data pointer before we move to the function.
-                    var functionCallObj = new FunctionCallObj { InstructionPointer = this.m_InstructionPointer, DataPointer = this.m_DataPointer, CallStack = this.m_CurrentCallStack, ExitLoop = this.m_ExitLoop, Ticks = this.m_Ticks };
+                    var functionCallObj = new FunctionCallObj { InstructionPointer = this.m_InstructionPointer, DataPointer = this.m_DataPointer, CallStack = this.m_CurrentCallStack, ExitLoop = this.m_ExitLoop, ExitLoopInstructionPointer = this.m_ExitLoopInstructionPointer, Ticks = this.m_Ticks };
                     this.m_FunctionCallStack.Push(functionCallObj);
 
                     // Give the function a fresh call stack.
                     this.m_CurrentCallStack = new Stack<int>();
                     this.m_ExitLoop = false;
+                    this.m_ExitLoopInstructionPointer = 0;
 
                     // Get current memory value to use as input for the function.
                     var inputValue = this.m_Memory[this.m_DataPointer];
 
                     // Set the data pointer to the functions starting memory address.
-                    this.m_DataPointer = 1000 * (instruction - 96); // each function gets a space of 1000 memory slots.
+                    this.m_DataPointer = _memoryAvailableForFunctions * (instruction - 96); // each function gets a space of 1000 memory slots.
 
                     // Clear function memory.
-                    Array.Clear(this.m_Memory, this.m_DataPointer, 1000);
+                    Array.Clear(this.m_Memory, this.m_DataPointer, _memoryAvailableForFunctions);
 
                     // Copy the input value to the function's starting memory address.
                     this.m_Memory[this.m_DataPointer] = inputValue;