/// <summary>
        /// Performs the required operations to calculates fitness
        /// </summary>
        /// <param name="normalizedParameters"></param>
        /// <returns></returns>
        public double Fitness(double[] normalizedParameters)
        {
            double result = 0;

            // Calculate result
            result = _strategyExecutor.ExecuteStrategy(normalizedParameters[0], normalizedParameters[1],
                                                       normalizedParameters[2], normalizedParameters[3]);

            Logger.Info("ALPHA:   " + normalizedParameters[0], "Optimization", "FitnessFunction");
            Logger.Info("BETA:    " + normalizedParameters[1], "Optimization", "FitnessFunction");
            Logger.Info("GAMMA:   " + normalizedParameters[2], "Optimization", "FitnessFunction");
            Logger.Info("EPSILON: " + normalizedParameters[3], "Optimization", "FitnessFunction");
            Logger.Info("PNL:     " + result, "Optimization", "FitnessFunction");

            // Return result
            return(result);
        }
        /// <summary>
        /// Function to optimize.
        /// </summary>
        /// <param name="w">Function W input value.</param>
        /// <param name="x">Function X input value.</param>
        /// <param name="y">Function Y input value.</param>
        /// <param name="z">Function Z input value.</param>
        /// <returns>Returns function output value.</returns>
        /// <remarks>The method should be overloaded by inherited class to
        /// specify the optimization function.</remarks>
        public override double OptimizationFunction(double w, double x, double y, double z)
        {
            double result = 0;

            //double wUserValue = ConvertValueToUserDefinedRange(w, 0.1);
            //double xUserValue = ConvertValueToUserDefinedRange(x, 0.0001);
            //double yUserValue = ConvertValueToUserDefinedRange(y, 0.1);
            //double zUserValue = ConvertValueToUserDefinedRange(z, 0.001);

            // Calculate result
            result = _strategyExecutor.ExecuteStrategy(w, x, y, z);

            //Logger.Info("ALPHA:   " + wUserValue, "Optimization", "FitnessFunction");
            //Logger.Info("BETA:    " + xUserValue, "Optimization", "FitnessFunction");
            //Logger.Info("GAMMA:   " + yUserValue, "Optimization", "FitnessFunction");
            //Logger.Info("EPSILON: " + zUserValue, "Optimization", "FitnessFunction");
            //Logger.Info("PNL:     " + result, "Optimization", "FitnessFunction");

            // Return result
            return(result);
        }
        /// <summary>
        /// Performs iterations depending upon the range and parameter values
        /// </summary>
        public void ExecuteIterations()
        {
            // Execute all combinations
            foreach (object[] ctorArgument in _ctorArguments)
            {
                double result = 0;

                // Calculate result
                result = _strategyExecutor.ExecuteStrategy(Convert.ToDouble(ctorArgument[1].ToString()),
                                                           Convert.ToDouble(ctorArgument[14].ToString()),
                                                           Convert.ToDouble(ctorArgument[5].ToString()),
                                                           Convert.ToDouble(ctorArgument[6].ToString()));

                Logger.Info("ALPHA:   " + ctorArgument[1], "Optimization", "ExecuteIterations");
                Logger.Info("BETA:    " + ctorArgument[14], "Optimization", "ExecuteIterations");
                Logger.Info("GAMMA:   " + ctorArgument[5], "Optimization", "ExecuteIterations");
                Logger.Info("EPSILON: " + ctorArgument[6], "Optimization", "ExecuteIterations");
                Logger.Info("PNL:     " + result, "Optimization", "ExecuteIterations");

                //// Return result
                //return result;
            }
        }