public virtual LGPProgram CreateProgram(int size, LGPEnvironment env)
        {
            LGPProgram program = new LGPProgram(this, mOperatorSet.Clone());

            program.Create(size);

            return(program);
        }
 protected void Setup()
 {
     if (mSetup == false)
     {
         mEnvironment = CreateEnvironment(mConfig);
         mMutationInstructionFactory              = CreateMutationInstructionFactory(mConfig.GetScript(ScriptNames.MutationInstructionFactory));
         mCrossoverInstructionFactory             = CreateCrossoverInstructionFactory(mConfig.GetScript(ScriptNames.CrossoverInstructionFactory));
         mPopInitInstructionFactory               = CreatePopInitInstructionFactory(mConfig.GetScript(ScriptNames.PopInitInstructionFactory));
         mReproductionSelectionInstructionFactory = CreateReproductionSelectionInstructionFactory(mConfig.GetScript(ScriptNames.ReproductionSelectionInstructionFactory));
         mRegInitInstructionFactory               = CreateRegInitInstructionFactory(mConfig.GetScript(ScriptNames.RegInitInstructionFactory));
         mSurvivalInstructionFactory              = CreateSurvivalInstructionFactory(mConfig.GetScript(ScriptNames.SurvivalInstructionFactory));
         mSetup = true;
     }
 }
        protected virtual LGPEnvironment CreateEnvironment(LGPConfig lgpConfig)
        {
            LGPEnvironment environment = new LGPEnvironment(lgpConfig);

            environment.CreateFitnessCaseTriggered += (index) =>
            {
                return(CreateFitnessCase(index));
            };
            environment.GetFitnessCaseCountTriggered += () =>
            {
                return(GetFitnessCaseCount());
            };

            return(environment);
        }
        public virtual void EvaluateFitness()
        {
            //if (InstructionCount == 0)
            //{
            //    throw new ArgumentNullException();
            //}

            MarkStructuralIntrons();

            if (mPop.ObjectiveEvaluator == null)
            {
                LGPEnvironment        env = mPop.Environment;
                int                   fitness_case_count = env.GetFitnessCaseCount();
                List <LGPFitnessCase> cases = new List <LGPFitnessCase>();
                for (int i = 0; i < fitness_case_count; ++i)
                {
                    LGPFitnessCase fitness_case = env.CreateFitnessCase(i);
                    ExecuteOnFitnessCase(fitness_case);
                    cases.Add(fitness_case);
                }
                mObjectiveValue = EvaluateFitnessFromAllCases(cases);
            }
            else
            {
                mObjectiveValue = mPop.ObjectiveEvaluator(this);
            }

            if (mPop.IsMaximization)
            {
                mFitness = mObjectiveValue;
            }
            else
            {
                mFitness = -mObjectiveValue;
            }
            mIsFitnessValid = true;
        }