fit26.rb

def sum(l)

	t = 0
	l.each { |x| t += x }
	return t
end
	
def av(l)
	return nil if (l.empty?)
	return sum(l) / l.size
end


def d3(l, p, d, z0)


	z = 0.0
	l1 = []
	l.size.times \
	{
		|i|
		next if (d[i] == 0)
		z1 = p[i] * (d[i] ** $w[l[i]])
		z += z1
		l1 << [p[i], d[i], $w[l[i]], d[i] ** $w[l[i]], z]
		$d[l[i]] += (z1 < z0) ? -1 : +1 if (!z0.nil?)
	}
	z /= l.size
	
	return z

end
	
def near2(l, j, a)

	l3 = a['l']
	l2 = []
	l1 = {'a' => ['a'], 'b' => ['a'], 'c' => ['a', 'b']}[$b[j]]
	l.size.times \
	{
		|i|
		next if (i == j)
		next if (!l1.member?($b[i]))
		d = 0
		l3.each { |x| d += (l[i][x] - l[j][x]) ** 2 }
		l2 << {'i' => i, 'd' => d}
	}
	l2 = l2.sort_by { |x| x['d'] }

	r = (0..a['r'])
	l4 = r.map { |x| l2[x]['i'] }
	p = l4.map { |x| l[x][a['c']] }
	d = r.map { |x| l2[x]['d'] }

	return d3(l4, p, d, $b[j] != 'c' ? l[j][a['c']] : nil)

end

	
def inc(e, b, x)
	e[b] = {'t' => 0.0, 'c' => 0} if (!e.member?(b))
	e[b]['t'] += x
	e[b]['c'] += 1
	e[b]['av'] = e[b]['t'] / e[b]['c']
end
	
def total(e)
	return Hash[e.map { |k, v| [k, v['av']]}]
end

def reshuffle()

	l = $b.select { |x| x != 'c' }.shuffle
	$b[0...l.size] = l
end

def stats(l)
	e = {}
	[l.map { |x| (x[0] - x[1]).abs }, $b].transpose.each \
	{
		|x, b|
		inc(e, b, x)
	}
	return total(e)
end
	
def near(l, a)

	l2 = (0...l.size).map { |i| near2(l, i, a) }
	l1 = l.map { |x| x[a['c']] }

	$x = l2
	return stats([l1, l2].transpose)
end


def out(fn, l)

	f = File.open("#{fn}.txt", 'w')
	l.each { |x| f.puts(x.join("\t")) }
	f.close

end
	
def outby(fn, l)
	out(fn, l.sort_by { |x| x[0] })
end
	
def read(fn)
	
	l = File.open('data.txt').readlines
	l1 = l.shift.split
	return l.map \
	{
		|x|
		Hash[[l1, x.split.map { |y| y.to_f }].transpose]
	}
	
end

def abc(n)
	
	$b = []
	a = {'a' => 2, 'b' => 2, 'c' => 1}

	t = sum(a.values)
	a.each \
	{
		|k, v|
		$b += [k] * (v.to_f / t * n).to_i
	}
	$b[$b.size...n] = [a.keys.last] * (n - $b.size)

end

def rbf(l)
	x = near(l, {'l' => ['d', 'dh', 'dl', 'a', 'sd', 'mx', 'mn'], 'r' => 20, 'c' => 'h2'})
	
end
	
	

# srand(0)
l = read('data.txt')

l.shuffle!

ls = l.size

$stderr.puts("ls=#{ls}")

abc(ls)

c = $b.select { |x| x != 'c' }.size

$w = [0.1] * c

loop \
{
	$d = [0] * c
	x = rbf(l)
	puts(x.values.join("\t"))
	$stdout.flush
	c.times \
	{
		|i|
		$w[i] += $d[i] * 0.001
	}
#	reshuffle()
}