func main() {
min := 113
max := int(^uint32(0) >> 1)
for currentSum := min; currentSum <= max; currentSum++ {
var a Sum
var initVector vector.IntVector
for i := 0; i < currentSum; i += 1 {
initVector.Push(1)
}
a.Init(initVector)
count := recursiveMerging(a, currentSum, 0)
fmt.Println(currentSum, count)
if count%1000000 == 0 {
panic("")
}
}
}
// Partially mapped crossover.
func (a *GAOrderedIntGenome) Crossover(bi GAGenome, p1, p2 int) (GAGenome, GAGenome) {
ca := a.Copy().(*GAOrderedIntGenome)
b := bi.(*GAOrderedIntGenome)
cb := b.Copy().(*GAOrderedIntGenome)
copy(ca.Gene[p1:p2+1], b.Gene[p1:p2+1])
copy(cb.Gene[p1:p2+1], a.Gene[p1:p2+1])
//Proto child needs fixing
amap := new(vector.IntVector)
bmap := new(vector.IntVector)
for i := p1; i <= p2; i++ {
ma, found := ca.pmxmap(ca.Gene[i], p1, p2)
if found {
amap.Push(ma)
if bmap.Len() > 0 {
i1 := amap.Pop()
i2 := bmap.Pop()
ca.Gene[i1], cb.Gene[i2] = cb.Gene[i2], ca.Gene[i1]
}
}
mb, found := cb.pmxmap(cb.Gene[i], p1, p2)
if found {
bmap.Push(mb)
if amap.Len() > 0 {
i1 := amap.Pop()
i2 := bmap.Pop()
ca.Gene[i1], cb.Gene[i2] = cb.Gene[i2], ca.Gene[i1]
}
}
}
ca.Reset()
cb.Reset()
return ca, cb
}
func (t *GoTracker) dead() []int {
dead := new(vector.IntVector)
cp := t.Copy().(*GoTracker)
color := BLACK
move := 0
for {
vertex := cp.weights.Rand(color)
cp.Play(color, vertex)
move++
if move > 3*t.sqsize || cp.Winner() != EMPTY {
break
}
color = Reverse(color)
}
for i := 0; i < t.sqsize; i++ {
if t.board[i] != EMPTY && cp.board[i] != t.board[i] {
dead.Push(i)
}
}
stones := make([]int, dead.Len())
for i := 0; i < dead.Len(); i++ {
stones[i] = dead.At(i)
}
return stones
}
// capture any points connected to vertex, resetting their parent, rank and weight, and liberties
// check if chains adjacent to captured are now out of atari
func (t *GoTracker) capture(vertex int) *vector.IntVector {
// do a linear search for connected points
captured := new(vector.IntVector)
for i := 0; i < t.sqsize; i++ {
if find(i, t.parent) == vertex {
captured.Push(i)
}
}
// reset
for i := 0; i < captured.Len(); i++ {
capture := captured.At(i)
t.parent[capture] = capture
t.rank[capture] = 1
t.liberties[capture][0] = 0
t.liberties[capture][1] = 0
t.board[capture] = EMPTY
t.weights.Set(BLACK, capture, INIT_WEIGHT)
t.weights.Set(WHITE, capture, INIT_WEIGHT)
}
// update liberties
for i := 0; i < captured.Len(); i++ {
capture := captured.At(i)
for j := 0; j < 4; j++ {
adj := t.adj[capture][j]
if adj != -1 {
root := find(adj, t.parent)
t.liberties[root][0] |= t.mask[capture][0]
t.liberties[root][1] |= t.mask[capture][1]
}
}
}
return captured
}
// renvoie la liste des trolls avec qui le troll passé a un partage actif
func (store *MysqlStore) GetPartageurs(db *mysql.Client, trollId int) ([]int, os.Error) {
st := strconv.Itoa(trollId)
sql := "select troll_a, troll_b from partage where (troll_a=" + st + " or troll_b=" + st + ") and statut_a='on' and statut_b='on'"
err := db.Query(sql)
if err != nil {
return nil, err
}
result, err := db.UseResult()
if err != nil {
return nil, err
}
defer result.Free()
amis := new(vector.IntVector)
for {
row := result.FetchRow()
if row == nil {
break
}
r0 := fieldAsInt(row[0])
r1 := fieldAsInt(row[1])
if r0 == trollId {
amis.Push(r1)
} else {
amis.Push(r0)
}
}
return *amis, nil
}
func GetPrimeFactors(number int) (*vector.IntVector, *vector.IntVector) {
numbers := new(vector.IntVector)
counts := new(vector.IntVector)
primesChannel := GetPrimes()
result := number
for {
prime := <-primesChannel
if number < prime {
break
}
if result%prime == 0 {
numbers.Push(prime)
count := 1
for result = result / prime; result%prime == 0; result = result / prime {
count++
}
counts.Push(count)
}
}
return numbers, counts
}
func (d *debugHistogram) PrintSorted() {
if !printDebugOutput {
return
}
if len(d.mapping) == 0 {
return
}
var scores vector.IntVector
inverseMapping := make(map[int]string)
sum := 0
for key, value := range d.mapping {
inverseMapping[value] = key
scores.Push(value)
sum += value
}
scoresArray := sort.IntArray(scores)
scoresArray.Sort()
fmt.Fprintf(os.Stderr, "Debug histogram - sorted:\n")
length := len(scoresArray)
for i := 0; i < length; i++ {
current := scoresArray[length-i-1]
fmt.Fprintf(os.Stderr, "%s: %d (%2.1f%%)\n", inverseMapping[current], current, float(current)/float(sum)*100)
}
}
func removeZeros(c []int) []int {
var ret vector.IntVector
for _, v := range c {
if v != 0 {
ret.Push(v)
}
}
return ret
}
func BenchmarkIntVector(b *testing.B) {
for i := 0; i < b.N; i++ {
var vec vector.IntVector
for j := 0; j < vectorLength; j++ {
vec.Push(j)
}
for j := 0; j < vectorLength; j++ {
val := vec.At(j)
val++
}
}
}
func generatePrimes(min int, max int) vector.IntVector {
var ret vector.IntVector
for n := min; n <= max; n++ {
if isPrime(n) {
ret.Push(n)
}
}
return ret
}
func (connection *Connection) SearchPrefix(query string) (*vector.IntVector, os.Error) {
var count _C_int
resp := C.tcidbsearch(connection.Dystopia, C.CString(query), C.x_prefix(), &count)
fmt.Printf("searched for %v, num results = %d, resp = %v\n", query, count, resp)
var result vector.IntVector
for i := 0; i < int(count); i++ {
result.Push(int(C.x_get_result_item(resp, _C_int(i))))
}
// return &result, nil;
return &result, nil
}
// find all occurrences of s in source; report at most n occurences
func find(src, s string, n int) []int {
var res vector.IntVector
if s != "" && n != 0 {
// find at most n occurrences of s in src
for i := -1; n < 0 || len(res) < n; {
j := strings.Index(src[i+1:], s)
if j < 0 {
break
}
i += j + 1
res.Push(i)
}
}
return res
}
func readLexeme(state *LexerState,
rune int,
size int,
err os.Error,
predicate func(rune int) bool,
reader *bufio.Reader) (string, os.Error) {
var runes vector.IntVector
for predicate(rune) && size > 0 && err == nil {
runes.Push(rune)
rune, size, err = readRune(state, reader)
}
if err != os.EOF {
unreadRune(state, reader, rune)
}
return lexeme(runes), err
}
func TestGetPrimeFactorsOfANumber(t *testing.T) {
expectedPrimes := new(vector.IntVector)
for _, integer := range []int{2, 3, 5} {
expectedPrimes.Push(integer)
}
expectedCounts := new(vector.IntVector)
for _, integer := range []int{1, 2, 1} {
expectedCounts.Push(integer)
}
gotPrimes, gotCounts := GetPrimeFactors(90)
if !AreTwoIntVectorEquals(expectedPrimes, gotPrimes) || !AreTwoIntVectorEquals(expectedCounts, gotCounts) {
t.Errorf("Expected primes %q. Got primes %q\nExpected count %q. Got count %q", expectedPrimes, gotPrimes)
}
}
func generatePrimes(min int, max int) []int {
var primes vector.IntVector
for n := min; n <= max; n++ {
if isPrime(n) {
primes.Push(n)
}
}
ret := make([]int, len(primes))
for k, v := range primes {
ret[k] = v
}
return ret
}
func main() {
var a Sum
var initVector vector.IntVector
for i := 0; i < 100; i += 1 {
initVector.Push(1)
}
a.Init(initVector)
var count uint64 = 0
recursiveMerging(a, 100, 0, &count)
fmt.Println(count - 1)
}
func TestGridProductOfTheMainDiagonal(t *testing.T) {
grid := new(vector.Vector)
for i := 0; i < 5; i++ {
line := new(vector.IntVector)
for j := 0; j < 5; j++ {
if i == j {
line.Push(10)
} else {
line.Push(1)
}
}
grid.Push(line)
}
AssertGridProduct(t, grid, 10000)
}
func TestGridProductOfVerticalLine(t *testing.T) {
grid := new(vector.Vector)
for i := 0; i < 5; i++ {
line := new(vector.IntVector)
for j := 0; j < 5; j++ {
if j == 0 {
line.Push(10)
} else {
line.Push(1)
}
}
grid.Push(line)
}
AssertGridProduct(t, grid, 10000)
}
func ReadGridFromString(input string) *vector.Vector {
grid := new(vector.Vector)
lines := strings.Split(input, "\n")
for _, line := range lines {
lineVector := new(vector.IntVector)
numbers := strings.Split(line, " ")
for _, number := range numbers {
number, _ := strconv.Atoi(number)
lineVector.Push(number)
}
grid.Push(lineVector)
}
return grid
}
func continuedFraction(a float64, dSquaredFloorTimesTwo int) vector.IntVector {
aFloor := int(math.Floor(a))
var ret vector.IntVector
if dSquaredFloorTimesTwo == aFloor {
return ret
}
ret.Push(aFloor)
nextRet := continuedFraction(1/(a-float64(aFloor)), dSquaredFloorTimesTwo)
ret.AppendVector(&nextRet)
return ret
}
func TestConvertGridToString(t *testing.T) {
firstLine := new(vector.IntVector)
firstLine.Push(10)
firstLine.Push(15)
secondLine := new(vector.IntVector)
secondLine.Push(8)
secondLine.Push(5)
grid := new(vector.Vector)
grid.Push(firstLine)
grid.Push(secondLine)
expected := "10 15\n8 5"
got := ConvertGridToString(grid)
if expected != got {
t.Errorf("Expected: %q\nGot: %q", expected, got)
}
}
func TestConvertGridFromString(t *testing.T) {
grid := "10 15\n8 5"
firstLine := new(vector.IntVector)
firstLine.Push(10)
firstLine.Push(15)
secondLine := new(vector.IntVector)
secondLine.Push(8)
secondLine.Push(5)
expected := new(vector.Vector)
expected.Push(firstLine)
expected.Push(secondLine)
got := ReadGridFromString(grid)
if !AreGridEquals(expected, got) {
t.Errorf("Expected: %q\nGot: %q", expected, got)
}
}
// Specialized function for TeX-style hyphenation patterns. Accepts strings of the form '.hy2p'.
// The value it stores is of type vector.IntVector
func (p *Trie) AddPatternString(s string) {
v := new(vector.IntVector)
// precompute the Unicode rune for the character '0'
rune0, _ := utf8.DecodeRune([]byte{'0'})
strLen := len(s)
// Using the range keyword will give us each Unicode rune.
for pos, rune := range s {
if unicode.IsDigit(rune) {
if pos == 0 {
// This is a prefix number
v.Push(rune - rune0)
}
// this is a number referring to the previous character, and has
// already been handled
continue
}
if pos < strLen-1 {
// look ahead to see if it's followed by a number
next := int(s[pos+1])
if unicode.IsDigit(next) {
// next char is the hyphenation value for this char
v.Push(next - rune0)
} else {
// hyphenation for this char is an implied zero
v.Push(0)
}
} else {
// last character gets an implied zero
v.Push(0)
}
}
pure := strings.Map(func(rune int) int {
if unicode.IsDigit(rune) {
return -1
}
return rune
},
s)
leaf := p.addRunes(strings.NewReader(pure))
if leaf == nil {
return
}
leaf.value = v
}
func TreeSort(data []int) {
if len(data) <= 1 {
return
}
root := NewTree(nil, data[0]) //root node
for i := 1; i < len(data); i++ {
root.NewNode(data[i]) //filling up the tree
}
var sorted vector.IntVector
var sortIntoArray func(*Tree) //declared to use recursively
sortIntoArray = func(node *Tree) {
if node == nil {
return
}
sortIntoArray(node.left)
sorted.Push(node.val)
sortIntoArray(node.right)
}
sortIntoArray(root)
copy(data, sorted.Data()) //copy the sorted to the source
}
func CountColor(pngR io.Reader) int {
/* modify here */
// uniq := new (vector.Vector[uint32])
var colorVector vector.Vector
var rVector vector.IntVector
var gVector vector.IntVector
var bVector vector.IntVector
im, _ := png.Decode(pngR)
for y := 0; y < im.Bounds().Dy(); y++ {
for x := 0; x < im.Bounds().Dx(); x++ {
color := im.At(x, y)
unique := true
r, g, b, _ := color.RGBA()
for i := 0; i < colorVector.Len(); i++ {
if r == uint32(rVector.At(i)) &&
g == uint32(gVector.At(i)) &&
b == uint32(bVector.At(i)) {
unique = false
}
}
if unique == true {
colorVector.Push(color)
rVector.Push(int(r))
gVector.Push(int(g))
bVector.Push(int(b))
}
}
}
return colorVector.Len()
}
// Lookup returns an unsorted list of at most n indices where the byte string s
// occurs in the indexed data. If n < 0, all occurrences are returned.
// The result is nil if s is empty, s is not found, or n == 0.
// Lookup time is O((log(N) + len(result))*len(s)) where N is the
// size of the indexed data.
//
func (x *Index) Lookup(s []byte, n int) []int {
var res vector.IntVector
if len(s) > 0 && n != 0 {
// find matching suffix index i
i := x.search(s)
// x.at(i) <= s < x.at(i+1)
// ignore the first suffix if it is < s
if i < len(x.sa) && bytes.Compare(x.at(i), s) < 0 {
i++
}
// collect the following suffixes with matching prefixes
for (n < 0 || len(res) < n) && i < len(x.sa) && bytes.HasPrefix(x.at(i), s) {
res.Push(x.sa[i])
i++
}
}
return res
}
func distinct(list vector.StringVector) [][2]string {
if len(list) == 0 {
return nil
}
var keys vector.StringVector
var vals vector.IntVector
for _, l := range list {
index := search(keys, l)
if index == -1 {
keys.Push(l)
vals.Push(1)
} else {
vals.Set(index, vals.At(index)+1)
}
}
m := make([][2]string, len(keys))
for i, k := range keys {
m[i][0] = k
m[i][1] = fmt.Sprint(vals.At(i))
}
return m
}
// Adapted/ported the neat recipe/method by Manuel Ebert at
// http://portwempreludium.tumblr.com/post/13108758604/instagram-unshredding
func FindShredWidth(img *image.Gray) {
bounds := img.Bounds()
width := bounds.Max.X
height := bounds.Max.Y
avg := make([]float64, width)
for x := 0; x < width; x++ {
tmp := 0
for y := 0; y < height; y++ {
tmp += int(img.Pix[x+y*img.Stride])
}
avg[x] = float64(tmp) / float64(height)
}
diff := make([]float64, width)
for z := 1; z < width; z++ {
diff[z] = math.Fabs(avg[z] - avg[z-1])
}
diff[0] = 0.0
shred_width = 0
for threshold := 1; threshold < 255; threshold++ {
if shred_width >= 5 {
break
}
var boundaries vector.IntVector
for i, _ := range diff {
if diff[i] > float64(threshold) {
boundaries.Push(i)
}
}
if len(boundaries) == 0 {
shred_width = 0
continue
}
tmp := boundaries[0]
for b := 1; b < len(boundaries); b++ {
tmp = gcd(tmp, boundaries[b])
}
shred_width = tmp
}
}
func (t *GoTracker) playHeuristicMove(color byte) int {
if len(t.atari[color]) > 0 {
// play a random saving move
saves := new(vector.IntVector)
for _, last_liberty := range t.atari[color] {
if t.weights.Get(color, last_liberty) > 0 {
saves.Push(last_liberty)
}
}
if saves.Len() > 0 {
return saves.At(rand.Intn(saves.Len()))
}
}
if len(t.atari[Reverse(color)]) > 0 {
// play a random capture move
captures := new(vector.IntVector)
for _, last_liberty := range t.atari[Reverse(color)] {
captures.Push(last_liberty)
}
return captures.At(rand.Intn(captures.Len()))
}
return -1
}
// Sorts channels in random order
func (dbs *DBS) RandomChan() {
var SortCh vector.IntVector
for i := 0; i < NCh; i++ {
SortCh.Push(i)
dbs.RndCh[i] = i
}
//randomizesd reserved top canals
/* for i := 10; i > 1; i-- {
j := dbs.Rgen.Intn(i) + NCh-10
SortCh.Swap(NCh-10+i-1, j)
dbs.RndCh[NCh-10+i-1] =SortCh.Pop()
}
dbs.RndCh[NCh-10]=SortCh.Pop()
*/
//randomizes other canals
/* for i := NCh - 11; i > NChRes; i-- {
j := dbs.Rgen.Intn(i-NChRes) + NChRes
SortCh.Swap(i, j)
dbs.RndCh[i] =SortCh.Pop()
}
dbs.RndCh[NChRes] = SortCh.Pop()
dbs.RndCh[0] = 0
*/
//fmt.Println(dbs.RndCh);
for i := NCh - 1; i > NChRes; i-- {
j := dbs.Rgen.Intn(i-NChRes) + NChRes
SortCh.Swap(i, j)
dbs.RndCh[i] = SortCh.Pop()
}
dbs.RndCh[NChRes] = SortCh.Pop()
dbs.RndCh[0] = 0
}