fit20b.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 d0(p, d, j)
		
		r = (0...p.size)
		r0 = r.select { |x| d[x].finite? }
	
		raise if (r0.empty?)
		
		t = sum(d.values_at(*r0))

		w = []
		r0.each { |x| w[x] = d[x] / t }
		
		$d[j] = [p, w].transpose.values_at(*r0)
		
		z = 0
		r0.each { |x| z += (w[x] * p[x]) }

		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] }
	
	
	return d0(p.map { |x| x[a['c']]}, r.map { |x| 1.0 / l2[x]['d'] }, j)
	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
	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 Hash[e.sort.map { |k, x| [k, x['t'] / x['c']] }]
	end
	
	def near(l, a)

#	reshuffle()
	$d = []
#	$stderr.puts(a.inspect)
	
	l2 = (0...l.size).map { |i| near2(l, i, a) }
	l1 = l.map { |x| x[a['c']] }
	
	return stats([l1, l2].transpose).merge({'l2' => l2})
	end
	
	def abc(n)
		
	$b = []
	a = {'a' => 3, '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 count(m, x, k, t)
		return true if (m['.'])
		if (m.empty? || x[k] < m[k]) then
			m.merge!(x)
			m['n'] = 0
			m['j'] = $j
		else
			m['n'] += 1
		end
		m['.'] = (m['n'] == t)
		return m['.']
	end
	
	def out(fn, l)
	
	f = File.open("#{fn}.txt", 'w')
	l.each { |x| f.puts(x.join("\t")) }
	f.close
	
	end
	
	def opt(l, l1, y)
		$stderr.puts([y, l1].inspect)
		
		lx = $h.values_at(*l1)
		x = near(l, {'l' => lx, 'r' => 10, 'c' => $h[y]})

		l2 = x.delete('l2')
		$stderr.puts(x.inspect)
		return l2
		
		
	end
		
	def read(fn)
		l = File.open(fn).readlines
		l1 = l[0].split
		$h = Hash[*[l1, (0...l1.size).to_a].transpose.flatten]
		return l[1..-1].map { |x| x.split.map { |x| x.to_f } }
	end
	
	def outby(fn, l)
		out(fn, l.sort_by { |x| x[0] })
	end
	
	def err(l)
		l1 = opt(l, ['d', 'dh', 'dl', 'a', 'sd', 'mx', 'mn'], 'h2')
			
		l2 = [l.map { |x| x[$h['h2']] }, l1].transpose
		
		outby('out', l2)
		
		
		l3 = [l.map { |x| x[$h['nl']] }, l1].transpose.map { |x| x[0] * x[1] / 50.0 }
		
		l4 = [l.map { |x| x[$h['ls']] }, l3].transpose
		
		outby('out2', l4)
	end

	l = read('data.txt')

	l.shuffle!
	
	ls = l.size
	
	$stderr.puts("ls=#{ls}")
	
	abc(ls)
	
	err(l)