data47b.rb

require 'statsample'


def f2(n)
	return n.odd? ? (n * 3 + 1) / 2 : n / 2

end

def f1(n)
	n = (n * 3 + 1) / 2 if (n.odd?)
	n /= 2 if (n.even?)
	return n

end

def dense(w, d)
	w2 = w - 1
	
	a = (0...w2).to_a
	s = '0' * w2
	(1..(d * w - 1)).map { a.delete_at(rand(a.size)) }.each { |x| s[x, 1] = '1' }
	return ('1' + s).to_i(2) 
	
end

def stat(l)
	l = [0] if (l.empty?)
        t = t2 = 0
        l.each \
        {
		|x|
		t += x
		t2 += x ** 2
        }
        c = l.size
        a = t.to_f / c
        z = t2.to_f / c - a ** 2
        sd = Math.sqrt(z < 0 ? 0 : z)

	return a, sd, l.max.to_f, l.min.to_f
end

def stat2(l, t, n)
	return Hash[[["a#{n}", "sd#{n}", "mx#{n}"], stat(l)[0..2].map { |x| x / t }].transpose]
end

def d(s)
        c = s.split('').select { |x| x == '1' }.size
	d = c.to_f / s.length
        return d
        
end

def data(n)
	ns = n.to_s(2)
	nl = ns.length
	m = nl / 2
	
	nsh = ns[0..m]
	nsl = ns[m..-1]
	
	asdm1 = stat2(ns.split(/0+/).map { |x| x.length }, nl, 1)
	
	l1 = ns.split(/1+/)
	
	l1.shift
	asdm0 = stat2(l1.map { |x| x.length }, nl, 0)
	
	return {'n' => n, 'ns' => ns, 'nl' => nl, 'd' => d(ns), 'dh' => d(nsh), 'dl' => d(nsl)}.merge(asdm1).merge(asdm0)
end


def dist(m)
		
	w = 100
	d = 0.0
	c = 50
	l = []
	(c + 1).times \
	{
		|x|
		d = x.to_f / c
		n = dense(w, d)
		x = {0 => data(n), 1 => data(f2(n))}

		m.times { n = f2(n) }
		x[1]['wr'] = (n.to_s(2).length.to_f / x[0]['nl'].to_f) ** (1.0 / m)
		l << x
	}
	$stderr.puts("#{l.size} pts")
	return l
end

def sum(l)

	t = 0.0
	l.each { |x| t += x }
	return t
end

def av(l)
	return nil if (l.empty?)
	return sum(l) / l.size
end

def corr(l, y1)
	
	yp = "#{y1}_p"
	ye = "#{y1}_e"
	xav = av(l.map { |x| x[y1] })
	yav = av(l.map { |x| x[yp] })

	tx = ty = txy = e = 0.0
	m = nil
	l.each \
	{
		|z|
		
		x = z[y1]
		y = z[yp]
		
		txy += (x - xav) * (y - yav)
		tx += (x - xav) ** 2
		ty += (y - yav) ** 2
		
		z[ye] = (x - y)
		e1 = z[ye]
		e += e1
		m = [m, e1.abs].compact.max
	}
	r = txy / (Math.sqrt(tx) * Math.sqrt(ty))
	e /= l.size
	return {'r' => r, 'e_a' => e, 'e_m' => m}
	
end

def dot(x, z)

	t = z['c']
	
	(z.keys - ['c']).each { |v| t += z[v] * x[v] }
	return t
		
end

def predict(l, vy, z)
	l.each \
	{
		|x|
		
		x[1]["#{vy}_p"] = dot(x[0], z)
	}
end

def fit(l, vx, vy)

	a = {}

	vx.each { |v| a[v] = l.map { |x| x[0][v] }.to_vector() }

	a[vy] = l.map { |x| x[1][vy] }.to_vector()
	
	ds = a.to_dataset()

	r = Statsample::Regression.multiple(ds, vy)
#	$stderr.puts(r.summary)

	z = r.coeffs.merge({'c' => r.constant})
	
	predict(l, vy, z)
	
	a = corr(l.map { |x| x[1] }, vy)
	
	return z.merge!(a)

end

def fmt(a)
	a2 = {}
	a.each \
	{
		|k, v|
		a2[k] = v.is_a?(Numeric) ? sprintf("%.3g", v).to_f : v
	}
	return a2
	
end

def model(v, m)
	l = dist(m)

	a = {}

	l2 = (1..l.size).map { {} }

	(v + ['wr']).each \
	{
		|x|
		a[x] = fit(l, v, x)
		l1 = l.map { |y| y[1][x] }
		a[x].merge!({'mn' => l1.min, 'mx' => l1.max})

		l.size.times \
		{
			|i|
			
			l2[i][x] = (l[i][1][x] - l[i][1]["#{x}_p"])
		}

		$stderr.puts(fmt({'x' => x}.merge(a[x].select { |k, v| ['r', 'e_m', 'e_a', 'mn', 'mx'].member?(k) })).inspect)
	}

	f = File.open('err.txt', 'w')
	f.puts(l2[0].keys.join("\t"))
	l2.each { |x| f.puts(x.values.join("\t")) }
	f.close
	a['l'] = l
	return a
	
end

def out(fn, a)
	
	return if (fn.nil?)
	f = File.open(fn, 'a')
	f.puts(a.keys.join("\t")) if (f.size == 0)
	if (a.nil?)
		f.puts
	else
		f.puts(a.values.join("\t"))
	end
	f.close
end

def detect(a, v, n, j)
	return {} if (a['x'])
	
	x1 = data(n)
	i = 0
	c = 500
	r = [3, 2]
	x1['nl'] = r[0]
	loop \
	{
		x2 = {}
		(v + ['wr']).each \
		{
			|vy|
			
			x2[vy] = dot(x1, a[vy].select { |k, x| (v + ['c']).member?(k) }) 
			
			x2[vy] += a['l'][j][1]["#{vy}_e"] if (!j.nil?)
			
			x2[vy] = a[vy]['mn'] if (x2[vy] < a[vy]['mn'])
			x2[vy] = a[vy]['mx'] if (x2[vy] > a[vy]['mx'])
		}
		x2['nl'] = x1['nl'] * x2['wr']
		x1 = x2
		i += 1
		break if (x1['nl'] < r[1] || i == c)
	}
	return i == c ? nil : i

end

def scan(a, v, j, c)

	l = []
	File.open(a['fn'], 'w').close if (!a['fn'].nil?)
	c.times \
	{
		|i|
		x = detect(a, v, dense(100, i.to_f / (c - 1)), j)
		l << x
	}
	return l.select { |x| x.nil? }.size
end

def test(a, v, i)

	c = scan(a, v, nil, 20)
	return if (c > 0)
	
	x1 = 0.25
	a['l'].sort_by! { |x| x[1]['wr_e'] }
	x = 0
	a['l'].size.times \
	{
		|j|
		
		c = scan(a, v, j, 20)
		case c
		when 0
			co = 2
			d = x1
			x += 1
		when 20
			co = 1
			d = -x1
		else
			co = 3
			d = 0
		end
		
		puts([i + d, a['l'][j][1]['wr_e'], co].join("\t"))
		$stdout.flush
	}
	out('out1.txt', a['wr'].merge({'x' => x}))
	return
end

srand(0)

v = ['a1', 'a0', 'dh', 'dl', 'sd0', 'sd1', 'mx1']


x = ARGV[0].nil? ? 1 : ARGV[0].to_i

File.open('out1.txt', 'w').close

(1..40).each \
{
	|i|
	
	a = model(v, i)
	
	test(a, v, i)
}