Beispiel #1
0
func (g *GenCubePoints) Generate(number int) b.Generation {
	var conformaciones []c.Conformation
	fmt.Println("Conformations Generator", number)
	for i := 0; i < number; i++ {

		fmt.Println("--> conf:", i)
		var puntosHijo_C []c.Point
		g.Points = g.Points[:0]

		g.generar(puntosHijo_C)
		fitness := f.NewFitness(g.Points).GetFitness()

		if fitness == 0 {
			i = i - 1
			continue
		}

		conf := c.Conformation{
			Conformations: g.Points,
			Fitness:       f.NewFitness(g.Points).GetFitness(),
		}
		conf.Init()

		conformaciones = append(conformaciones, conf)
	}

	rGn := b.Generation{
		Conformations: conformaciones,
		DmaxP:         g.board.GenDmaxP(conformaciones),
		RadioGiroP:    g.board.GenRadioGiroP(conformaciones),
	}
	return rGn
}
func (mc MakeCubeChildren) MakeChildren(gen b.Generation, board *b.BlackBoard) b.Generation {
	mc.board = board
	var length int = len(board.Hplevel.HpString)
	var numConf int = len(gen.ParentsLst)

	fmt.Println("MC>", length, numConf)

	var conf []c.Conformation
	var corte []int

	cOver := NewCrossOver(board)

	for i := 0; i < numConf; i++ {
		var tempP c.Parents

		if board.Params.CrossOverOp == 0 {
			fmt.Println("OnePoint")
			corte = cOver.OnePointCrossOver(length)
		} else if board.Params.CrossOverOp == 1 {
			fmt.Println("twoPoint")
			corte = cOver.TwoPointCrossOver(length)
		} else if board.Params.CrossOverOp == 2 {
			fmt.Println("UniformPoint")
			corte = cOver.UniformPointCrossOver(length)
		}
		var padre1 int = 0
		var padre2 int = 0

		if board.Params.MutationOp == 0 {
			padre1 = gen.ParentsLst[i].Parent1
			padre2 = gen.ParentsLst[i].Parent2
			tempP = gen.ParentsLst[i]
		} else {
			fmt.Println("Mutation OP !=0")
			switch rand.Intn(2) {
			case 0:
				fmt.Println("MUT 0")
				padre1 = gen.ParentsLst[i].Parent1
				padre2 = gen.ParentsLst[i].Parent2
				tempP = gen.ParentsLst[i]
				break
			case 1:
				fmt.Println("MUT 1")
				padre1 = gen.ParentsLst[i].Parent2
				padre2 = gen.ParentsLst[i].Parent1
				tempP.Parent1 = padre1
				tempP.Parent2 = padre2
				break
			default:
				fmt.Println("MakeCubeChildrens")
				break
			}
		}

		var puntosPadre1 []c.Point
		puntosPadre1 = make([]c.Point, len(gen.Conformations[padre1].Conformations))
		copy(puntosPadre1, gen.Conformations[padre1].Conformations)
		var puntosPadre2 []c.Point
		puntosPadre2 = make([]c.Point, len(gen.Conformations[padre2].Conformations))
		copy(puntosPadre2, gen.Conformations[padre2].Conformations)

		var nuevoHijo1 []c.Point
		var nuevoHijo2 []c.Point

		for m := 0; m < length; m++ {
			puntosPadre1[m].ResetR()
			puntosPadre2[m].ResetR()
		}

		var puntosHijo_C []c.Point

		fP := c.Point{
			XValue:       0.0,
			YValue:       0.0,
			ZValue:       0.0,
			MovVectValue: 0,
			Letter:       puntosPadre1[0].Letter,
			Way0:         true,
			Way1:         true,
			Way2:         true,
			Way3:         true,
			Way4:         true,
			Way5:         true,
		}

		nuevoHijo1 = append(nuevoHijo1, fP)

		if board.Params.CrossOverOp == 0 {
			for j := 1; j < length; j++ {
				fmt.Println(" It j", j)
				if j < corte[0] {
					j = mc.check(puntosHijo_C, puntosPadre1[j].MovVectValue, &nuevoHijo1, j)
				} else {
					j = mc.check(puntosHijo_C, puntosPadre2[j].MovVectValue, &nuevoHijo1, j)
				}
			}
			var puntosHijo_C []c.Point

			c2 := c.Point{
				XValue:       0.0,
				YValue:       0.0,
				ZValue:       0.0,
				MovVectValue: 0,
				Letter:       puntosPadre2[0].Letter,
				Way0:         true,
				Way1:         true,
				Way2:         true,
				Way3:         true,
				Way4:         true,
				Way5:         true,
			}
			nuevoHijo2 = append(nuevoHijo2, c2)

			for j := 1; j < length; j++ {
				if j < corte[0] {
					j = mc.check(puntosHijo_C, puntosPadre2[j].MovVectValue, &nuevoHijo2, j)
				} else {
					j = mc.check(puntosHijo_C, puntosPadre1[j].MovVectValue, &nuevoHijo2, j)
				}
			}
		} else if board.Params.CrossOverOp == 1 {
			for j := 1; j < length; j++ {
				if j < corte[0] {
					j = mc.check(puntosHijo_C, puntosPadre1[j].MovVectValue, &nuevoHijo1, j)
				} else if j < corte[1] {
					j = mc.check(puntosHijo_C, puntosPadre2[j].MovVectValue, &nuevoHijo1, j)
				} else {
					j = mc.check(puntosHijo_C, puntosPadre1[j].MovVectValue, &nuevoHijo1, j)
				}
			}

			var puntosHijo_C []c.Point

			c2 := c.Point{
				XValue:       0.0,
				YValue:       0.0,
				ZValue:       0.0,
				MovVectValue: 0,
				Letter:       puntosPadre2[0].Letter,
				Way0:         true,
				Way1:         true,
				Way2:         true,
				Way3:         true,
				Way4:         true,
				Way5:         true,
			}
			nuevoHijo2 = append(nuevoHijo2, c2)

			for j := 1; j < length; j++ {
				if j < corte[0] {
					j = mc.check(puntosHijo_C, puntosPadre2[j].MovVectValue, &nuevoHijo2, j)
				} else if j < corte[1] {
					j = mc.check(puntosHijo_C, puntosPadre1[j].MovVectValue, &nuevoHijo2, j)
				} else {
					j = mc.check(puntosHijo_C, puntosPadre2[j].MovVectValue, &nuevoHijo2, j)
				}
			}
		} else if board.Params.CrossOverOp == 2 {
			for j := 1; j < length; j++ {
				if corte[j] == 0 {
					j = mc.check(puntosHijo_C, puntosPadre1[j].MovVectValue, &nuevoHijo1, j)
				} else {
					j = mc.check(puntosHijo_C, puntosPadre2[j].MovVectValue, &nuevoHijo1, j)
				}
			}
			var puntosHijo_C []c.Point

			c2 := c.Point{
				XValue:       0.0,
				YValue:       0.0,
				ZValue:       0.0,
				MovVectValue: 0,
				Letter:       puntosPadre2[0].Letter,
				Way0:         true,
				Way1:         true,
				Way2:         true,
				Way3:         true,
				Way4:         true,
				Way5:         true,
			}
			nuevoHijo2 = append(nuevoHijo2, c2)

			for j := 1; j < length; j++ {
				if corte[j] == 0 {
					j = mc.check(puntosHijo_C, puntosPadre2[j].MovVectValue, &nuevoHijo2, j)
				} else {
					j = mc.check(puntosHijo_C, puntosPadre1[j].MovVectValue, &nuevoHijo2, j)
				}
			}
		}

		hijo1 := c.Conformation{
			Conformations: nuevoHijo1,
			Fitness:       f.NewFitness(nuevoHijo1).GetFitness(),
			Parents:       tempP,
		}
		hijo1.Init()
		conf = append(conf, hijo1)

		hijo2 := c.Conformation{
			Conformations: nuevoHijo2,
			Fitness:       f.NewFitness(nuevoHijo2).GetFitness(),
			Parents:       tempP,
		}
		hijo2.Init()
		conf = append(conf, hijo2)
	}

	for _, b := range board.Bests {
		conf = append(conf, b)
	}
	board.Bests = board.Bests[:0]

	rGn := b.Generation{
		Conformations: conf,
		DmaxP:         board.GenDmaxP(conf),
		RadioGiroP:    board.GenRadioGiroP(conf),
	}
	return rGn
}