source: branches/Robocode/HeuristicLab.Problems.Robocode/BestSolutionAnalyzer.cs @ 10901

using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.Robocode
{
    [StorableClass]
    [Item("Best Tank program Analyzer",
          "Analyzer that stores the best tank program.")]
    public class BestSolutionAnalyzer : SingleSuccessorOperator,
      ISymbolicExpressionTreeAnalyzer
    {
        #region parameter names
        private const string QualityParameterName = "Quality";
        private const string SymbolicExpressionTreeParameterName =
          "TankProgram";
        private const string MovesParameterName = "Moves";
        private const string ShotsParameterName = "Shots";
        private const string BestSolutionParameterName = "Best solution";
        private const string ResultsParameterName = "Results";
        private const string RobocodePathParamaterName = "Path";
        private const string CoevolutionParameterName = "Coevolution";
        #endregion


        #region parameters
        public IScopeTreeLookupParameter<DoubleValue> QualityParameter
        {
            get
            {
                return (IScopeTreeLookupParameter<DoubleValue>)
                          Parameters[QualityParameterName];
            }
        }
        public IScopeTreeLookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter
        {
            get
            {
                return (IScopeTreeLookupParameter<ISymbolicExpressionTree>)
                          Parameters[SymbolicExpressionTreeParameterName];
            }
        }
        //public ILookupParameter<IntValue> MovesParameter
        //{
        //    get
        //    {
        //        return (ILookupParameter<IntValue>)
        //                  Parameters[MovesParameterName];
        //    }
        //}
        //public ILookupParameter<IntValue> ShotsParameter
        //{
        //    get
        //    {
        //        return (ILookupParameter<IntValue>)
        //                  Parameters[ShotsParameterName];
        //    }
        //}
        public ILookupParameter<Solution> BestSolutionParameter
        {
            get
            {
                return (ILookupParameter<Solution>)
                          Parameters[BestSolutionParameterName];
            }
        }
        public ILookupParameter<ResultCollection> ResultParameter
        {
            get
            {
                return (ILookupParameter<ResultCollection>)
                          Parameters[ResultsParameterName];
            }
        }
        public ILookupParameter<StringValue> RobocodePathParameter
        {
            get
            {
                return (ILookupParameter<StringValue>)
                    Parameters[RobocodePathParamaterName];
            }
        }
        public ILookupParameter<BoolValue> CoevolutionParameter
        {
            get
            {
                return (ILookupParameter<BoolValue>)
                    Parameters[CoevolutionParameterName];
            }
        }
        #endregion

        [StorableConstructor]
        protected BestSolutionAnalyzer(bool deserializing) : base(deserializing) { }
        protected BestSolutionAnalyzer(BestSolutionAnalyzer original,
                                       Cloner cloner)
            : base(original, cloner)
        {
        }

        public BestSolutionAnalyzer()
        {
            Parameters.Add(
              new ScopeTreeLookupParameter<DoubleValue>(
                QualityParameterName,
                "The solution quality of the tank program."));
            Parameters.Add(
              new ScopeTreeLookupParameter<ISymbolicExpressionTree>(
                SymbolicExpressionTreeParameterName,
                "The tank program to evaluate represented " +
                "as symbolic expression tree."));
            Parameters.Add(
              new LookupParameter<Solution>(
                BestSolutionParameterName, "The best tank program."));
            //Parameters.Add(
            //  new LookupParameter<IntValue>(
            //    MovesParameterName, "The number of moves made."));
            //Parameters.Add(
            //  new LookupParameter<IntValue>(
            //    ShotsParameterName, "The shots made."));
            Parameters.Add(
              new LookupParameter<ResultCollection>(
                ResultsParameterName, "The result collection of the algorithm."));
            Parameters.Add(
              new LookupParameter<StringValue>(
                RobocodePathParamaterName,
                "Path of the Robocode installation."));
            Parameters.Add(
                new LookupParameter<BoolValue>(
                    CoevolutionParameterName,
                    "Use Coevolution"));
        }

        public override IOperation Apply()
        {
            // get an array of all trees
            // and an array of all qualities
            var trees = SymbolicExpressionTreeParameter.ActualValue;
            var qualities = QualityParameter.ActualValue;

            // find the tree with the best quality
            double maxQuality = double.NegativeInfinity;
            ISymbolicExpressionTree bestTree = null;
            for (int i = 0; i < qualities.Length; i++)
            {
                if (qualities[i].Value > maxQuality)
                {
                    maxQuality = qualities[i].Value;
                    bestTree = trees[i];
                }
            }

            var coevolution = CoevolutionParameter.ActualValue.Value;
            double actualQuality = 0;

            if (coevolution)
                actualQuality = Interpreter.EvaluateTankProgram(bestTree, null, RobocodePathParameter.ActualValue.Value);

            // create a solution instance
            //int shots = ShotsParameter.ActualValue.Value;
            //int moves = MovesParameter.ActualValue.Value;
            var bestSolution = new Solution(bestTree, RobocodePathParameter.ActualValue.Value);//, moves, shots);
            // store the new solution in the best solution parameter
            BestSolutionParameter.ActualValue = bestSolution;

            // also add the best solution as a result to the result collection
            // or alternatively update the existing result
            var resultCollection = ResultParameter.ActualValue;
            if (!resultCollection.ContainsKey(BestSolutionParameterName))
            {
              resultCollection.Add(
                new Result(BestSolutionParameterName,
                           "The best tank program", bestSolution));
              //if(coevolution)
              //    resultCollection.Add(
              //        new Result("Actual Quality",
              //            "The actual quality of the best program", new DoubleValue(actualQuality)));
            }
            else
            {
                resultCollection[BestSolutionParameterName].Value = bestSolution;
            }

            if (coevolution)
            {
                if (!resultCollection.ContainsKey("Actual Quality"))
                {
                    resultCollection.Add(
                        new Result("Actual Quality",
                            "The actual quality of the best program", new DoubleValue(actualQuality)));
                }
                else
                {
                    resultCollection["Actual Quality"].Value = new DoubleValue(actualQuality);
                }
            }

            // important return base.Apply() to make sure the 
            // next operator is queued for execution
            return base.Apply();
        }

        public override IDeepCloneable Clone(Cloner cloner)
        {
            return new BestSolutionAnalyzer(this, cloner);
        }

        // override this property to indicate that this analyzer
        // should be enabled by default in the algorithm
        public bool EnabledByDefault
        {
            get { return true; }
        }
    }
}