Exemplo n.º 1
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var p = (Lawnmower)problem;
            var d = (LawnmowerData)input;

            switch (p.Orientation)
            {
            case Lawnmower.O_UP:
                p.PosY--;
                if (p.PosY < 0)
                {
                    p.PosY = p.MaxY - 1;
                }
                break;

            case Lawnmower.O_LEFT:
                p.PosX--;
                if (p.PosX < 0)
                {
                    p.PosX = p.MaxX - 1;
                }
                break;

            case Lawnmower.O_DOWN:
                p.PosY++;
                if (p.PosY >= p.MaxY)
                {
                    p.PosY = 0;
                }
                break;

            case Lawnmower.O_RIGHT:
                p.PosX++;
                if (p.PosX >= p.MaxX)
                {
                    p.PosX = 0;
                }
                break;

            default:      // whoa!
                state.Output.Fatal("Whoa, somehow I got a bad orientation! (" + p.Orientation + ")");
                break;
            }

            p.Moves++;
            if (p.Map[p.PosX][p.PosY] == Lawnmower.UNMOWED)
            {
                p.Sum++;
                p.Map[p.PosX][p.PosY] = p.Moves;
            }

            // return [0,0]
            d.x = 0;
            d.y = 0;
        }
Exemplo n.º 2
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var edge = ((EdgeData)(input)).edge;
            var prob = (Edge)problem;

            if (prob.From.Length == prob.NumEdges)  // we're full, need to expand
            {
                var from_    = new int[prob.NumEdges * 2];
                var to_      = new int[prob.NumEdges * 2];
                var reading_ = new int[prob.NumEdges * 2];
                Array.Copy(prob.From, 0, from_, 0, prob.From.Length);
                Array.Copy(prob.To, 0, to_, 0, prob.To.Length);
                Array.Copy(prob.Reading, 0, reading_, 0, prob.Reading.Length);
                prob.From    = from_;
                prob.To      = to_;
                prob.Reading = reading_;
            }

            if (prob.Start.Length == prob.NumNodes)  // we're full, need to expand
            {
                var start_  = new bool[prob.NumNodes * 2];
                var accept_ = new bool[prob.NumNodes * 2];
                Array.Copy(prob.Start, 0, start_, 0, prob.Start.Length);
                Array.Copy(prob.Accept, 0, accept_, 0, prob.Accept.Length);
                prob.Start  = start_;
                prob.Accept = accept_;
            }

            var newedge = prob.NumEdges;

            prob.NumEdges++;
            var newnode = prob.NumNodes;

            prob.NumNodes++;

            // set up new node
            prob.Accept[newnode] = false;
            prob.Start[newnode]  = false;

            // set up new edge
            prob.From[newedge]    = prob.To[edge];
            prob.To[newedge]      = newnode;
            prob.Reading[newedge] = prob.Reading[edge];

            // pass the original edge down the left child

            Children[0].Eval(state, thread, input, stack, individual, problem);

            // reset input for right child
            ((EdgeData)(input)).edge = newedge;

            // pass the new edge down the right child

            Children[1].Eval(state, thread, input, stack, individual, problem);
        }
Exemplo n.º 3
0
        public override void Eval(
            IEvolutionState state,
            int thread,
            GPData input,
            ADFStack stack,
            GPIndividual individual,
            IProblem problem)
        {
            var p = (Ant)problem;

            switch (p.Orientation)
            {
            case Ant.O_UP:
                p.Orientation = Ant.O_RIGHT;
                break;

            case Ant.O_LEFT:
                p.Orientation = Ant.O_UP;
                break;

            case Ant.O_DOWN:
                p.Orientation = Ant.O_LEFT;
                break;

            case Ant.O_RIGHT:
                p.Orientation = Ant.O_DOWN;
                break;

            default:      // whoa!
                state.Output.Fatal("Whoa, somehow I got a bad orientation! (" + p.Orientation + ")");
                break;
            }
            p.Moves++;
        }
Exemplo n.º 4
0
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            var image       = ((FeatureExtractionProblem)problem).currentImage[thread];
            var transformer = ((FeatureExtractionProblem)problem).imageTransformer;

            transformer.TransformImage(image, (Image.ImageTransformer.TransformationType)morphType);
        }
Exemplo n.º 5
0
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            var p = (FeatureExtractionProblem)problem;

            Children[0].Eval(state, thread, input, stack, individual, problem);
            p.imageTransformer.TransformImage(p.currentImage[thread], Image.ImageTransformer.TransformationType.OPEN);
        }
Exemplo n.º 6
0
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            var p = (FeatureExtractionProblem2)problem;

            Children[0].Eval(state, thread, input, stack, individual, problem);
            p.currentImage[thread] = p.imageTransformer.RotateViaCenter(p.currentImage[thread], 20);
        }
Exemplo n.º 7
0
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            var p = (FeatureExtractionProblem)problem;

            Children[0].Eval(state, thread, input, stack, individual, problem);
            p.currentImage[thread] = p.currentImage[thread].Not();
        }
Exemplo n.º 8
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            Children[0].Eval(state, thread, input, stack, individual, problem);

            var  md = (MajorityData)input;
            long y0 = md.Data0;
            long y1 = md.Data1;

            Children[1].Eval(state, thread, input, stack, individual, problem);
            long z0 = md.Data0;
            long z1 = md.Data1;

            Children[2].Eval(state, thread, input, stack, individual, problem);

            // IF Y THEN Z ELSE MD is
            // (Y -> Z) ^ (~Y -> MD)
            // (!Y v Z) ^ (Y v MD)
            md.Data0 = (~y0 | z0) & (y0 | md.Data0);
            md.Data1 = (~y1 | z1) & (y1 | md.Data1);
        }
Exemplo n.º 9
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var md = (MultiplexerData)input;

            Children[0].Eval(state, thread, input, stack, individual, problem);

            if (md.Status == MultiplexerData.STATUS_3)
            {
                md.Dat3 = (byte)(md.Dat3 ^ -1); // BRS: this was originally "md.dat_3 ^= -1;"
            }
            else if (md.Status == MultiplexerData.STATUS_6)
            {
                md.Dat6 ^= -1L;
            }
            else // md.status == MultiplexerData.STATUS_11
            {
                for (var x = 0; x < MultiplexerData.MULTI_11_NUM_BITSTRINGS; x++)
                {
                    md.Dat11[x] ^= -1L;
                }
            }
        }
Exemplo n.º 10
0
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            var cProblem = (MultiClassifierProblem)problem;

            ((ClassificationData)input).doubleVal = cProblem.CurrentParam[paramIndex];
            ((ClassificationData)input).index     = (int)paramIndex;
        }
Exemplo n.º 11
0
        /// <summary>
        /// Just like eval, but it retraces the map and prints out info.
        /// </summary>
        public void EvalPrint(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem, int[][] map2)
        {
            var p = (Ant)problem;

            switch (p.Orientation)
            {
            case Ant.O_UP:
                p.PosY--;
                if (p.PosY < 0)
                {
                    p.PosY = p.MaxY - 1;
                }
                break;

            case Ant.O_LEFT:
                p.PosX--;
                if (p.PosX < 0)
                {
                    p.PosX = p.MaxX - 1;
                }
                break;

            case Ant.O_DOWN:
                p.PosY++;
                if (p.PosY >= p.MaxY)
                {
                    p.PosY = 0;
                }
                break;

            case Ant.O_RIGHT:
                p.PosX++;
                if (p.PosX >= p.MaxX)
                {
                    p.PosX = 0;
                }
                break;

            default:      // whoa!
                state.Output.Fatal("Whoa, somehow I got a bad orientation! (" + p.Orientation + ")");
                break;
            }

            p.Moves++;
            if (p.Map[p.PosX][p.PosY] == Ant.FOOD && p.Moves < p.MaxMoves)
            {
                p.Sum++;
                p.Map[p.PosX][p.PosY] = Ant.ATE;
            }

            if (p.Moves < p.MaxMoves)
            {
                if (++p.PMod > 122 /* ascii z */)
                {
                    p.PMod = 97;                               /* ascii a */
                }
                map2[p.PosX][p.PosY] = p.PMod;
            }
        }
Exemplo n.º 12
0
 public override void Eval(IEvolutionState state,
                           int thread,
                           GPData input,
                           ADFStack stack,
                           GPIndividual individual,
                           IProblem problem)
 {
 }
Exemplo n.º 13
0
 public override void Eval(IEvolutionState state,
                           int thread,
                           GPData input,
                           ADFStack stack,
                           GPIndividual individual,
                           IProblem problem)
 {
     ((MultiplexerData)input).x = (((Multiplexer)problem).addressPart >> 0) & 1;
 }
Exemplo n.º 14
0
 public override void Eval(IEvolutionState state,
                           int thread,
                           GPData input,
                           ADFStack stack,
                           GPIndividual individual,
                           IProblem problem)
 {
     // No need to evaluate or look at children.
 }
Exemplo n.º 15
0
 public override void Eval(IEvolutionState state,
                           int thread,
                           GPData input,
                           ADFStack stack,
                           GPIndividual individual,
                           IProblem problem)
 {
     // no need to do anything here
 }
Exemplo n.º 16
0
 public override void Eval(IEvolutionState state,
                           int thread,
                           GPData input,
                           ADFStack stack,
                           GPIndividual individual,
                           IProblem problem)
 {
     Children[0].Eval(state, thread, input, stack, individual, problem);
     ((MultiplexerData)input).x ^= 1;
 }
Exemplo n.º 17
0
 public override void Eval(IEvolutionState state,
                           int thread,
                           GPData input,
                           ADFStack stack,
                           GPIndividual individual,
                           IProblem problem)
 {
     ((ParityData)input).x =
         ((((Parity)problem).bits >> 31) & 1);
 }
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            index = ((ClassificationData)input).index;
            var minVal = ((MultiClassifierProblem)problem).Dataset.MinValues[index];
            var maxVal = ((MultiClassifierProblem)problem).Dataset.MaxValues[index];

            printedValue = Math.Round(minVal + (maxVal - minVal) * value);
            //if (val == maxVal)
            //    val = -1;
            ((ClassificationData)input).doubleVal = printedValue;
        }
Exemplo n.º 19
0
 public override void Eval(IEvolutionState state,
                           int thread,
                           GPData input,
                           ADFStack stack,
                           GPIndividual individual,
                           IProblem problem)
 {
     // Evaluate both children.  Return the second one (done automagically).
     Children[0].Eval(state, thread, input, stack, individual, problem);
     Children[1].Eval(state, thread, input, stack, individual, problem);
 }
Exemplo n.º 20
0
 public void EvalPrint(
     IEvolutionState state,
     int thread,
     GPData input,
     ADFStack stack,
     GPIndividual individual,
     IProblem problem,
     int[][] map2)
 {
     Eval(state, thread, input, stack, individual, problem);
 }
Exemplo n.º 21
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var rd = ((DoubleData)(input));

            rd.x = ((MultiValuedRegression)problem).currentX;
        }
Exemplo n.º 22
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var rd = (RegressionData)input;

            rd.x = ((Regression)problem).CurrentValue;
        }
Exemplo n.º 23
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var rd = ((RegressionData)(input));

            Children[0].Eval(state, thread, input, stack, individual, problem);
            rd.x = rd.x * rd.x;
        }
Exemplo n.º 24
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var rd = ((TwoBoxData)input);
            var tb = ((TwoBox)problem);

            rd.x = tb.inputsh0[tb.currentIndex];
        }
Exemplo n.º 25
0
        public override void eval(ec.EvolutionState state,
		                  int thread,
		                  GPData input,
		                  ADFStack stack,
		                  GPIndividual individual,
		                  Problem problem)
        {
            UnityProblem p = (UnityProblem)problem;
                        GameObject ball = p.model.ball.gameObject;
                        GameObject car = p.model.car.gameObject;
                        ((RegressionData)input).x = Vector3.Distance(ball.transform.position, car.transform.position);
        }
Exemplo n.º 26
0
 public override void Eval(
     IEvolutionState state,
     int thread,
     GPData input,
     ADFStack stack,
     GPIndividual individual,
     IProblem problem)
 {
     // Evaluate both children.  Easy as cake.
     Children[0].Eval(state, thread, input, stack, individual, problem);
     Children[1].Eval(state, thread, input, stack, individual, problem);
 }
Exemplo n.º 27
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var rd = ((LawnmowerData)(input));

            rd.x = x;
            rd.y = y;
        }
Exemplo n.º 28
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var md = (MajorityData)input;

            md.Data0 = X0;
            md.Data1 = X1;
        }
Exemplo n.º 29
0
        public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
        {
            var p  = (FeatureExtractionProblem2)problem;
            var c0 = p.currentImage[thread].Copy();

            Children[0].Eval(state, thread, input, stack, individual, problem);
            var c1 = p.currentImage[thread].Copy();

            c0.CopyTo(p.currentImage[thread]);
            Children[1].Eval(state, thread, input, stack, individual, problem);
            p.currentImage[thread] = p.currentImage[thread].Mul(c1);
        }
Exemplo n.º 30
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var md = (MultiplexerData)input;

            long[] dat_11 = null;  // quiets compiler complaints
            long   dat_6  = 0L;
            byte   dat_3  = 0;

            // No shortcuts for now
            Children[0].Eval(state, thread, input, stack, individual, problem);

            if (md.Status == MultiplexerData.STATUS_3)
            {
                dat_3 = md.Dat3;
            }
            else if (md.Status == MultiplexerData.STATUS_6)
            {
                dat_6 = md.Dat6;
            }
            else // md.status == MultiplexerData.STATUS_11
            {
                dat_11 = md.PopDat11();
                Array.Copy(md.Dat11, 0,
                           dat_11, 0,
                           MultiplexerData.MULTI_11_NUM_BITSTRINGS);
            }

            Children[1].Eval(state, thread, input, stack, individual, problem);

            // modify

            if (md.Status == MultiplexerData.STATUS_3)
            {
                md.Dat3 |= dat_3;
            }
            else if (md.Status == MultiplexerData.STATUS_6)
            {
                md.Dat6 |= dat_6;
            }
            else // md.status == MultiplexerData.STATUS_11
            {
                for (int x = 0; x < MultiplexerData.MULTI_11_NUM_BITSTRINGS; x++)
                {
                    md.Dat11[x] |= dat_11[x];
                }
                md.PushDat11(dat_11);
            }
        }
Exemplo n.º 31
0
        public override void Eval(IEvolutionState state,
                                  int thread,
                                  GPData input,
                                  ADFStack stack,
                                  GPIndividual individual,
                                  IProblem problem)
        {
            var edge = ((EdgeData)(input)).edge;
            var prob = (Edge)problem;

            prob.Reading[edge] = Edge.EPSILON;
        }