コード例 #1
0
ファイル: eda.go プロジェクト: jgcarvalho/zeca
func (p *Probs) GenRule() *rules.Rule {
	var rule rules.Rule
	rule.Prm = p.rulePrm
	st := rules.RuleStates(rule.Prm)
	rule.Code = make([][][]byte, len(st))
	for ln := range st {
		rule.Code[ln] = make([][]byte, len(st))
		for c := range st {
			rule.Code[ln][c] = make([]byte, len(st))
			for rn := range st {
				randv := rand.Float64()
				for i, v := range p.probs[ln][c][rn] {
					// fmt.Println("valor", v)
					// fmt.Println("valor", randv)
					randv -= v
					if randv < 0.0 {
						rule.Code[ln][c][rn] = rule.Prm.TransitionStates[i]
						break
					}
				}
			}
		}

	}

	return &rule
}
コード例 #2
0
ファイル: eda.go プロジェクト: jgcarvalho/zeca
func NewProbs(prm rules.Params) *Probs {
	var p Probs
	p.rulePrm = prm
	st := rules.RuleStates(prm)
	p.probs = make([][][][]float64, len(st))
	for ln := range st {
		p.probs[ln] = make([][][]float64, len(st))
		for c := range st {
			p.probs[ln][c] = make([][]float64, len(st))
			for rn := range st {
				//p.probs[ln][c][rn] = prm.transitionStates[rand.Intn(len(prm.transitionStates))]
				p.probs[ln][c][rn] = make([]float64, len(prm.TransitionStates))
				for pv := range p.probs[ln][c][rn] {
					if c != 0 {
						p.probs[ln][c][rn][pv] = 1.0 / float64(len(p.probs[ln][c][rn]))
					} else {
						if pv == len(p.probs[ln][c][rn])-1 {
							p.probs[ln][c][rn][pv] = 1.0
						} else {
							p.probs[ln][c][rn][pv] = 0.0
						}

					}

				}
			}
		}
	}

	return &p
}
コード例 #3
0
ファイル: eda.go プロジェクト: jgcarvalho/zeca
func (p *Probs) AdjustProbs(pop Population, n_selection, n_tournament int) {
	// selection := make([]*ca.CellAuto1D, n_selection)
	mean_fitness := 0.0

	var tournament Tournament
	tournament.rule = make([]*rules.Rule, n_tournament)
	tournament.fitness = make([]float64, n_tournament)

	var count [][][][]float64
	st := rules.RuleStates(p.rulePrm)
	count = make([][][][]float64, len(st))
	for ln := range st {
		count[ln] = make([][][]float64, len(st))
		for c := range st {
			count[ln][c] = make([][]float64, len(st))
			for rn := range st {
				//p.probs[ln][c][rn] = prm.transitionStates[rand.Intn(len(prm.transitionStates))]
				count[ln][c][rn] = make([]float64, len(p.rulePrm.TransitionStates))
			}
		}
	}
	// var wg2 sync.WaitGroup
	// var wg3 sync.WaitGroup

	for j := 0; j < n_selection; j++ {
		for i := 0; i < n_tournament; i++ {
			x := rand.Intn(len(pop.rule))
			tournament.rule[i] = pop.rule[x]
			tournament.fitness[i] = pop.fitness[x]
		}

		sort.Sort(sort.Reverse(tournament))

		mean_fitness += tournament.fitness[0]

		n := len(tournament.rule[0].Code)
		for ln := 0; ln < n; ln++ {
			for c := 0; c < n; c++ {
				for rn := 0; rn < n; rn++ {
					index := bytes.IndexByte(p.rulePrm.TransitionStates, tournament.rule[0].Code[ln][c][rn])
					count[ln][c][rn][index] += 1
				}
			}
		}
	}

	n := len(tournament.rule[0].Code)
	for ln := 0; ln < n; ln++ {
		for c := 0; c < n; c++ {
			for rn := 0; rn < n; rn++ {
				for i := 0; i < len(count[ln][c][rn]); i++ {
					p.probs[ln][c][rn][i] = count[ln][c][rn][i] / float64(n_selection)
				}
			}
		}
	}

	fmt.Println("Mean Fitness:", mean_fitness/float64(n_selection))
}
コード例 #4
0
ファイル: util.go プロジェクト: jgcarvalho/zeca
func (p *Probs) AdjustProbs(pop []Individual) {
	// n := len(pop.rule)

	var count [][][][]float64
	st := rules.RuleStates(p.rulePrm)
	count = make([][][][]float64, len(st))
	for ln := range st {
		count[ln] = make([][][]float64, len(st))
		for c := range st {
			count[ln][c] = make([][]float64, len(st))
			for rn := range st {
				//p.probs[ln][c][rn] = prm.transitionStates[rand.Intn(len(prm.transitionStates))]
				count[ln][c][rn] = make([]float64, len(p.rulePrm.TransitionStates))
			}
		}
	}
	for j := 0; j < len(pop); j++ {
		n := len(pop[0].Rule.Code)
		for ln := 0; ln < n; ln++ {
			for c := 0; c < n; c++ {
				for rn := 0; rn < n; rn++ {
					index := bytes.IndexByte(p.rulePrm.TransitionStates, pop[j].Rule.Code[ln][c][rn])
					count[ln][c][rn][index] += 1
				}
			}
		}
	}

	n := len(pop[0].Rule.Code)
	for ln := 0; ln < n; ln++ {
		for c := 0; c < n; c++ {
			for rn := 0; rn < n; rn++ {
				for i := 0; i < len(count[ln][c][rn]); i++ {
					p.probs[ln][c][rn][i] = count[ln][c][rn][i] / float64(len(pop))
				}
				// fmt.Printf("Contagem %f %f %f %f \n", count[ln][c][rn][0], count[ln][c][rn][1], count[ln][c][rn][2], count[ln][c][rn][3])
				// fmt.Printf("len pop rule %d \n", len(pop.rule))
				// fmt.Printf("Probabilidade %f %f %f %f \n", p.probs[ln][c][rn][0], p.probs[ln][c][rn][1], p.probs[ln][c][rn][2], p.probs[ln][c][rn][3])
			}
		}
	}

}