Working Fibonacci!

Changed instructions to more formally follow Brainf**k Extended Type 1, including:
@ exits the program or when in a function, ends the function and returns to main program. This replaces !.
$ stores the value of memory into a storage byte.
! retrieves the value from storage and copies to current memory.
Removed & (which used to define the start of a function, now obsolete due to @ effectively marking a function start and end).
Removed % (which used to define the end of a function, now obsolete due to @ marking a function start and end).
Optimizations.
Added optional logging with Loggly.

Author: primaryobjects

AIProgrammer.Fitness/Base/FitnessBase.cs

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

AIProgrammer.Fitness/Concrete/BottlesOfBeerFitness.cs

@@ -27,7 +27,7 @@ public class BottlesOfBeerFitness : FitnessBase
         /// Previously generated BrainPlus functions for outputting the terms: bottles,of,beer,on,the,wall,bottles of beer,on the wall. The last two functions call sub-functions themselves. Generated using StrictStringFitness with StringFunction.
         /// To use, set _appendCode = BottlesOfBeerFitness.BottlesOfBeerFunctions in main program.
         /// </summary>
-        public static string BottlesOfBeerFunctions = "&6++.+++++++++++++[.+++[++..--------.-------.++++++++++++++.-%&[]7[[-.---------.%&6++.+++..7++.%&+8[+7-.-.%&6+t+++i++[++-+[+++++[+++++++.-----[-[--[--[--.[-+----+.%&7++++++[+.------[--------[--------.+++++++-+++++..%&1+++++++++++++>a---<+++.>.---------.<.c%&d2.e2.f%";
+        public static string BottlesOfBeerFunctions = "6++.+++++++++++++[.+++[++..--------.-------.++++++++++++++.-@[]7[[-.---------.@6++.+++..7++.@+8[+7-.-.@6+t+++i++[++-+[+++++[+++++++.-----[-[--[--[--.[-+----+.@7++++++[+.------[--------[--------.+++++++-+++++..@1+++++++++++++>a---<+++.>.---------.<.c@d2.e2.f@";
 
         public BottlesOfBeerFitness(GA ga, int maxIterationCount, string appendFunctions = null)
             : base(ga, maxIterationCount, appendFunctions)

AIProgrammer.Fitness/Concrete/FibonacciFitness.cs

@@ -16,14 +16,15 @@ public class FibonacciFitness : FitnessBase
     {
         private int _trainingCount;
         private int _maxDigits; // number of fibonacci numbers to calculate.
+        private static int _functionCount; // number of functions in the appeneded code.
 
         /// <summary>
         /// Previously generated BrainPlus function for addition. Generated using AddFitness.
         /// To use, set _appendCode = FibonacciFitness.FibonacciFunctions in main program.
         /// </summary>
-        public static string FibonacciFunctions = "&,>,-[-<+>]<+.%";
+        public static string FibonacciFunctions = ",>,-[-<+>]<+.$@";
 
-        public FibonacciFitness(GA ga, int maxIterationCount, int maxDigits = 3, int maxTrainingCount = 2, string appendFunctions = null)
+        public FibonacciFitness(GA ga, int maxIterationCount, int maxDigits = 3, int maxTrainingCount = 3, string appendFunctions = null)
             : base(ga, maxIterationCount, appendFunctions)
         {
             _maxDigits = maxDigits;
@@ -32,6 +33,7 @@ public FibonacciFitness(GA ga, int maxIterationCount, int maxDigits = 3, int max
             if (_targetFitness == 0)
             {
                 _targetFitness = _trainingCount * 256 * _maxDigits;
+                _functionCount = CommonManager.GetFunctionCount(appendFunctions);
             }
         }
 
@@ -49,11 +51,9 @@ protected override double GetFitnessMethod(string program)
             {
                 switch (i)
                 {
-                    case 0: input1 = 1; input2 = 1; break;
-                    case 1: input1 = 1; input2 = 2; break;
-                    case 2: input1 = 2; input2 = 3; break;
-                    case 3: input1 = 3; input2 = 5; break;
-                    case 4: input1 = 5; input2 = 8; break;
+                    case 0: input1 = 1; input2 = 2; break;
+                    case 1: input1 = 3; input2 = 5; break;
+                    case 2: input1 = 8; input2 = 13; break;
                 };
 
                 try
@@ -78,9 +78,9 @@ protected override double GetFitnessMethod(string program)
                         else
                         {
                             // Not ready for input.
-                            //penalty++;
+                            penalty++;
 
-                            return 255;
+                            return 0;
                         }
                     },
                     (b) =>
@@ -90,11 +90,13 @@ protected override double GetFitnessMethod(string program)
                             // Not ready for output.
                             penalty++;
                         }
+                        else
+                        {
+                            _console.Append(b);
+                            _console.Append(",");
 
-                        _console.Append(b);
-                        _console.Append(",");
-
-                        digits.Add(b);
+                            digits.Add(b);
+                        }
                     });
                     _bf.Run(_maxIterationCount);
                 }
@@ -130,6 +132,18 @@ protected override double GetFitnessMethod(string program)
                 // Bonus for less operations to optimize the code.
                 countBonus += ((_maxIterationCount - _bf.m_Ticks) / 1000.0);
 
+                // Bonus for using functions.
+                if (_functionCount > 0)
+                {
+                    for (char functionName = 'a'; functionName < 'a' + _functionCount; functionName++)
+                    {
+                        if (program.Contains(functionName))
+                        {
+                            countBonus += 25;
+                        }
+                    }
+                }
+
                 Ticks += _bf.m_Ticks;
             }
 

AIProgrammer.Functions/Concrete/StringFunction.cs

@@ -66,8 +66,7 @@ public string Generate(IGeneticAlgorithm ga)
                 // Run the genetic algorithm and get the best brain.
                 program = GAManager.Run(ga, _fitnessFunc, _generationFunc);
 
-                // For functions, replace ! with % return command.
-                appendCode += "&" + program.Replace('!', '%') + "%";
+                appendCode += program + "@";
 
                 // Reset the target fitness.
                 myFitness.ResetTargetFitness();

AIProgrammer.Interpreter/Interpreter.cs

@@ -7,7 +7,7 @@
 namespace AIProgrammer
 {
     /// <summary>
-    /// This the brainfuck interpreter
+    /// This is the brainfuck interpreter.
     /// 
     /// > 	Increment the pointer.
     /// < 	Decrement the pointer.
@@ -19,9 +19,9 @@ namespace AIProgrammer
     /// ] 	Jump backward to the matching [ unless the byte at the pointer is zero.
     /// 
     /// Extended commands, included in BrainPlus.
-    /// !   Exits the program.
-    /// &   Defines a new function a,b,c .. z.
-    /// %   Return to last position in main program and restore state. Current memory value of function is set in current program memory value.
+    /// @   Exits the program or if inside a function, return to last position in main program and restore state.
+    /// $   Overwrites the byte in storage with the byte at the pointer.
+    /// !   Overwrites the byte at the pointer with the byte in storage.
     /// a,b Call function a - z.
     /// 0-F Sets the value of the current memory pointer to a multiple of 16.
     /// </summary>
@@ -114,15 +114,20 @@ public class FunctionCallObj
 
         /// <summary>
         /// Pointer to a function's parent memory. When an input (,) command is executed from within a function, the function's current memory cell gets a copy of the value of the parent memory at this pointer. This allows passing multiple values as input to a function.
-        //  For example: ++>++++>+<<a.!&,>,-[-<+>]<+%
-        /// Parent memory contains: 2, 4, 1. Function will contain: 2, 4 and return a value of 6. Resulting parent memory contains: 6, 4, 1.
+        /// For example: ++>++++>+<<a!.@,>,-[-<+>]<+$@
+        /// Parent memory contains: 2, 4, 1. Function will contain: 2, 4 and store a value of 6 in storage. Resulting parent memory remains: 2, 4, 1. Upon next command !, parent memory will contain: 6, 4, 1. The value 6 is then displayed as output.
         /// </summary>
         private int m_FunctionInputPointer;
 
         /// <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.
+        /// Number of cells available to functions. When a function is executed, an array of cells are allocated in upper-addresses (eg., 1000-1999, 2000-2999, etc.) for usage.
         /// </summary>
-        private const int _memoryAvailableForFunctions = 255;
+        private const int _functionSize = 256;
+
+        /// <summary>
+        /// Storage memory value. Usually used to hold return values from function calls.
+        /// </summary>
+        private byte m_Storage;
 
         /// <summary>
         /// Number of instructions executed.
@@ -225,34 +230,36 @@ public Interpreter(string programCode, Func<byte> input, Action<byte> output)
             this.m_InstructionSet.Add('D', () => { if (!m_ExitLoop) this.m_Memory[this.m_DataPointer] = 208; });
             this.m_InstructionSet.Add('E', () => { if (!m_ExitLoop) this.m_Memory[this.m_DataPointer] = 224; });
             this.m_InstructionSet.Add('F', () => { if (!m_ExitLoop) this.m_Memory[this.m_DataPointer] = 240; });
-
-            // Create the instruction set for BrainPlus.
-            this.m_InstructionSet.Add('!', () => { this.m_Stop = true; });
-            this.m_InstructionSet.Add('&', () => { m_Functions.Add(m_NextFunctionCharacter++, this.m_InstructionPointer); });
-            this.m_InstructionSet.Add('%', () =>
+            this.m_InstructionSet.Add('@', () => 
             {
-                var temp = m_FunctionCallStack.Pop();
-                
-                // Get the result from the function call.
-                var result = this.m_Memory[this.m_DataPointer];
-
-                // Restore the data pointer.
-                this.m_DataPointer = temp.DataPointer;
-                // Set the value of memory equal to the function result.
-                this.m_Memory[this.m_DataPointer] = result;
-                // Restore the call stack.
-                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.
-                this.m_InstructionPointer = temp.InstructionPointer;
-                // Restore function input pointer.
-                this.m_FunctionInputPointer = temp.FunctionInputPointer;
+                if (m_FunctionCallStack.Count > 0)
+                {
+                    // Exit function.
+                    var temp = m_FunctionCallStack.Pop();
+
+                    // Restore the data pointer.
+                    this.m_DataPointer = temp.DataPointer;
+                    // Restore the call stack.
+                    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.
+                    this.m_InstructionPointer = temp.InstructionPointer;
+                    // Restore function input pointer.
+                    this.m_FunctionInputPointer = temp.FunctionInputPointer;
+                }
+                else
+                {
+                    // Exit program.
+                    this.m_Stop = true;
+                }
             });
+            this.m_InstructionSet.Add('$', () => { this.m_Storage = this.m_Memory[this.m_DataPointer]; });
+            this.m_InstructionSet.Add('!', () => { this.m_Memory[this.m_DataPointer] = this.m_Storage; });
 
             // Scan code for function definitions and store their starting memory addresses.
             ScanFunctions(programCode);
@@ -276,10 +283,10 @@ public Interpreter(string programCode, Func<byte> input, Action<byte> output)
                     this.m_FunctionInputPointer = this.m_DataPointer;
 
                     // Set the data pointer to the functions starting memory address.
-                    this.m_DataPointer = _memoryAvailableForFunctions * (instruction - 96); // each function gets a space of 1000 memory slots.
+                    this.m_DataPointer = _functionSize * (instruction - 96); // each function gets a space of 1000 memory slots.
 
                     // Clear function memory.
-                    Array.Clear(this.m_Memory, this.m_DataPointer, _memoryAvailableForFunctions);
+                    Array.Clear(this.m_Memory, this.m_DataPointer, _functionSize);
 
                     // Set the instruction pointer to the beginning of the function.
                     this.m_InstructionPointer = m_Functions[instruction];
@@ -334,7 +341,7 @@ private void RunLimited(int maxInstructions)
                     if (m_FunctionCallStack.Count > 0)
                     {
                         // We're inside a function, but ran out of instructions. Exit the function, but continue.
-                        if (this.m_InstructionSet.TryGetValue('%', out action))
+                        if (this.m_InstructionSet.TryGetValue('@', out action))
                         {
                             action();
                             this.m_InstructionPointer++;
@@ -381,20 +388,13 @@ private void RunUnlimited()
         /// </summary>
         private void ScanFunctions(string source)
         {
-            this.m_InstructionPointer = source.IndexOf('&');
-            while (this.m_InstructionPointer > -1 && this.m_InstructionPointer < source.Length && !m_Stop)
+            this.m_InstructionPointer = source.IndexOf('@');
+            while (this.m_InstructionPointer > -1 && this.m_InstructionPointer < source.Length - 1 && !m_Stop)
             {
-                // Fetch the next instruction
-                char instruction = this.m_Source[this.m_InstructionPointer];
-
-                Action action;
-                if (this.m_InstructionSet.TryGetValue(instruction, out action))
-                {
-                    // Store the function.
-                    action();
-                }
+                // Store the function.
+                m_Functions.Add(m_NextFunctionCharacter++, this.m_InstructionPointer);
 
-                this.m_InstructionPointer = source.IndexOf('&', this.m_InstructionPointer + 1);
+                this.m_InstructionPointer = source.IndexOf('@', this.m_InstructionPointer + 1);
             }
 
             this.m_InstructionPointer = 0;

AIProgrammer.Managers/AIProgrammer.Managers.csproj

@@ -42,6 +42,7 @@
   <ItemGroup>
     <Compile Include="CommonManager.cs" />
     <Compile Include="GAManager.cs" />
+    <Compile Include="LogManager.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>