Пример #1
0
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            // get the current context
            var c = stack.Top(0);

            if (c == null)
            {
                // uh oh
                state.Output.Fatal("No context with which to evaluate ADFArgument terminal " + ToStringForError()
                                   + ".  This often happens if you evaluate a tree by hand  which is supposed to only be an ADF's associated tree.");
            }

            c.Evaluate(state, thread, input, stack, individual, problem, Argument);
        }
Пример #2
0
 /// <summary>
 /// Increases Arguments to accommodate space if necessary. Sets adf to a.
 /// You need to then fill out the Arguments yourself.
 /// </summary>
 public void PrepareADF(ADF a, GPProblem problem)
 {
     // set to the length requested or longer
     if (a.Children.Length > Arguments.Length)
     {
         var newArguments = new GPData[a.Children.Length];
         Array.Copy(Arguments, 0, newArguments, 0, Arguments.Length);
         // fill gap -- ugh, luckily this doesn't happen but a few times
         for (var x = Arguments.Length; x < newArguments.Length; x++)
         {
             newArguments[x] = (GPData)problem.Input.Clone();
         }
         Arguments = newArguments;
     }
     Adf = a;
 }
Пример #3
0
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            // prepare a context
            var c = stack.Push(stack.Take());

            c.PrepareADM(this);

            // evaluate the top of the associatedTree
            individual.Trees[AssociatedTree].Child.Eval(state, thread, input, stack, individual, problem);

            // pop the context off, and we're done!
            if (stack.Pop(1) != 1)
            {
                state.Output.Fatal("Stack prematurely empty for " + ToStringForError());
            }
        }
Пример #4
0
        public override void Setup(IEvolutionState state, IParameter paramBase)
        {
            var def = DefaultBase;

            // BRS: MUST set up GPData before ADFStack, so that ADFContext has access to state.Evaluator.p_problem.Data
            // This avoids a reference to GPProblem.P_DATA, and thus allows us to use interfaces instead of concrete types
            // Important for decoupling and Inversion of Control (IoC).
            IParameter p = paramBase.Push(P_DATA);

            Input = (GPData)state.Parameters.GetInstanceForParameterEq(p, def.Push(P_DATA), typeof(GPData));
            Input.Setup(state, p);

            p     = paramBase.Push(P_STACK);
            Stack = (ADFStack)state.Parameters.GetInstanceForParameterEq(p, def.Push(P_STACK), typeof(ADFStack));
            Stack.Setup(state, p);
        }
Пример #5
0
        /// <summary>
        /// Evaluates the argument number in the current context
        /// </summary>
        public virtual void Evaluate(IEvolutionState state, int thread, GPData input, ADFStack stack,
                                     GPIndividual individual, IProblem problem, int argument)
        {
            // do I have that many Arguments?
            if ((argument >= Adf.Children.Length) || argument < 0)
            // uh oh
            {
                individual.PrintIndividual(state, 0);
                state.Output.Fatal("Invalid argument number for " + Adf.ErrorInfo());
            }

            // Am I an ADM or an ADF?
            //if (Adf == null)
            //    state.Output.Fatal("ADF is null for " + Adf.ErrorInfo());
            //else

            if (!(Adf is ADM)) // it's an ADF
            {
                Arguments[argument].CopyTo(input);
            }
            else // it's an ADM
            {
                // get rid of my context temporarily
                if (stack.MoveOntoSubstack(1) != 1)
                {
                    state.Output.Fatal("Substack prematurely empty for " + Adf.ErrorInfo());
                }

                // Call the GPNode
                Adf.Children[argument].Eval(state, thread, input, stack, individual, problem);

                // restore my context
                if (stack.MoveFromSubstack(1) != 1)
                {
                    state.Output.Fatal("Stack prematurely empty for " + Adf.ErrorInfo());
                }
            }
        }
Пример #6
0
 /// <summary>
 /// Modifies gpd so that gpd is equivalent to us. You may
 /// safely assume that gpd is of the same class as we are.
 /// Do not share references with the other object, except to
 /// read-only data: instead, copy any read-write data as necessary.
 /// </summary>
 public virtual void CopyTo(GPData gpd)
 {
 }