/// <summary>
        /// Applies standard filters to eliminate some false positive optimizer results
        /// </summary>
        /// <param name="result">The statistic results</param>
        /// <param name="fitness">The calling fitness</param>
        /// <returns></returns>
        public bool IsSuccess(Dictionary <string, decimal> result, OptimizerFitness fitness)
        {
            if (!fitness.Config.EnableFitnessFilter)
            {
                return(true);
            }

            //using config ignore a result with negative return or disable this single filter and still apply others
            if (fitness.GetType() != typeof(CompoundingAnnualReturnFitness) && !fitness.Config.IncludeNegativeReturn && result["CompoundingAnnualReturn"] < 0)
            {
                return(false);
            }

            //must meet minimum trading activity if configured
            if (fitness.Config.MinimumTrades > 0 && result["TotalNumberOfTrades"] < fitness.Config.MinimumTrades)
            {
                return(false);
            }

            //Consider not trading a failure
            if (result["TotalNumberOfTrades"] == 0)
            {
                return(false);
            }

            //Consider 100% loss rate a failure
            if (result["LossRate"] == 1)
            {
                return(false);
            }

            return(true);
        }
        public void Initialize(string[] args)
        {
            _config = LoadConfig(args);
            _file.File.Copy(_config.ConfigPath, System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config.json"), true);

            string path = _config.AlgorithmLocation;

            if (!string.IsNullOrEmpty(path) && (path.Contains('\\') || path.Contains('/')) && !path.EndsWith("py"))
            {
                _file.File.Copy(path, System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, System.IO.Path.GetFileName(path)), true);
                string pdb = path.Replace(System.IO.Path.GetExtension(path), ".pdb");

                //due to locking issues, need to manually clean to update pdb
                if (!_file.File.Exists(pdb))
                {
                    _file.File.Copy(pdb, System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, System.IO.Path.GetFileName(pdb)), true);
                }
            }

            var fitnessTypeName = _config.FitnessTypeName.Contains(".") ? _config.FitnessTypeName : "Jtc.Optimization.LeanOptimizer." + _config.FitnessTypeName;

            OptimizerFitness fitness = (OptimizerFitness)Assembly.GetExecutingAssembly().CreateInstance(fitnessTypeName, false, BindingFlags.Default, null,
                                                                                                        new object[] { _config, new FitnessFilter() }, null, null);

            if (_manager == null)
            {
                if (new[] { typeof(SharpeMaximizer), typeof(NFoldCrossReturnMaximizer), typeof(NestedCrossSharpeMaximizer), typeof(NFoldCrossSharpeMaximizer), typeof(WalkForwardSharpeMaximizer),
                            typeof(WalkForwardWeightedMetricSharpeMaximizer) }.Contains(fitness.GetType()))
                {
                    _manager = new MaximizerManager();
                    if (fitness.GetType() == typeof(OptimizerFitness))
                    {
                        LogProvider.ErrorLogger.Info("Fitness for shared app domain was switched to the default: SharpeMaximizer.");
                        fitness = new SharpeMaximizer(_config, new FitnessFilter());
                    }
                }
                else
                {
                    _manager = new GeneManager();
                }
            }

            //todo: some constraints for running python
            if (_config.AlgorithmLanguage == "Python")
            {
                _config.UseSharedAppDomain = true;
                _config.MaxThreads         = 1;
            }

            _manager.Initialize(_config, fitness);
            _manager.Start();
        }