From a69741b24e1a72997fbfac77422b2e6fa8f84b6b Mon Sep 17 00:00:00 2001
From: Sebastien Bourdeauducq <sb@m-labs.hk>
Date: Thu, 9 Apr 2015 12:00:20 +0800
Subject: [PATCH] forgot other cordic files

---
 examples/cordic/cordic_impl.py      |  63 -----------
 examples/cordic/cordic_impl_eval.py |  71 ------------
 examples/sim/cordic_err.py          | 109 -------------------
 migen/test/test_cordic.py           | 160 ----------------------------
 4 files changed, 403 deletions(-)
 delete mode 100644 examples/cordic/cordic_impl.py
 delete mode 100644 examples/cordic/cordic_impl_eval.py
 delete mode 100644 examples/sim/cordic_err.py
 delete mode 100644 migen/test/test_cordic.py

diff --git a/examples/cordic/cordic_impl.py b/examples/cordic/cordic_impl.py
deleted file mode 100644
index 594f2bda8..000000000
--- a/examples/cordic/cordic_impl.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import copy
-import json
-
-from migen.fhdl.std import *
-from migen.genlib.cordic import Cordic
-from mibuild.tools import mkdir_noerror
-from mibuild.generic_platform import *
-from mibuild.xilinx import XilinxPlatform
-
-class CordicImpl(Module):
-	def __init__(self, name, **kwargs):
-		self.name = name
-		mkdir_noerror("build")
-		json.dump(kwargs, open("build/{}.json".format(name), "w"))
-		self.platform = platform = Platform()
-		self.submodules.cordic = Cordic(**kwargs)
-		width = flen(self.cordic.xi)
-		self.comb += self.cordic.xi.eq(
-				int((1<<width - 1)/self.cordic.gain*.98))
-		self.comb += self.cordic.yi.eq(0)
-		zi = self.cordic.zi
-		self.sync += zi.eq(zi + 1)
-		do = platform.request("do")
-		self.sync += do.eq(Cat(self.cordic.xo, self.cordic.yo))
-
-	def build(self):
-		self.platform.build(self, build_name=self.name)
-
-class Platform(XilinxPlatform):
-	default_clk_name = "clk"
-	default_clk_period = 20.0
-
-	_io = [
-		("clk", 0, Pins("AB13")),
-		("do", 0,
-			Pins("Y2 W3 W1 P8 P7 P6 P5 T4 T3",
-				"U4 V3 N6 N7 M7 M8 R4 P4 M6 L6 P3 N4",
-				"M5 V2 V1 U3 U1 T2 T1 R3 R1 P2 P1"),
-		),
-	]
-	def __init__(self):
-		XilinxPlatform.__init__(self, "xc6slx45-fgg484-2", self._io)
-
-if __name__ == "__main__":
-	default = dict(width=16, guard=0, eval_mode="pipelined",
-			func_mode="circular", cordic_mode="rotate")
-	variations = dict(
-			eval_mode=["combinatorial", "pipelined", "iterative"],
-			width=[4, 8, 12, 14, 16, 20, 24, 32],
-			stages=[10, 12, 14, 16, 20, 24, 32],
-			guard=[0, 1, 2, 3, 4],
-			)
-	CordicImpl("cordic_test", eval_mode="combinatorial").build()
-
-	name = "cordic_baseline"
-	CordicImpl(name, **default).build()
-
-	for k, v in sorted(variations.items()):
-		for vi in v:
-			name = "cordic_{}_{}".format(k, vi)
-			kw = copy.copy(default)
-			kw[k] = vi
-			CordicImpl(name, **kw).build()
diff --git a/examples/cordic/cordic_impl_eval.py b/examples/cordic/cordic_impl_eval.py
deleted file mode 100644
index eeefffb81..000000000
--- a/examples/cordic/cordic_impl_eval.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import glob, os, re, json
-
-import numpy as np
-import matplotlib.pyplot as plt
-import pandas
-
-
-def extract(b, n, r, c=int):
-	r = re.compile(r)
-	try:
-		f = open(b + n)
-	except:
-		return
-	for l in f:
-		m = r.search(l)
-		if m:
-			v = m.groups()[0]
-			v = v.replace(",", "")
-			return c(v)
-
-def load(prefix, base):
-	kw = json.load(open(base))
-	b = os.path.splitext(base)[0]
-	_, n = os.path.split(b)[1].split("_", 1)
-	try:
-		n, _ = n.rsplit("_", 1)
-		kw["vary"] = n
-	except:
-		pass
-	kw["slack"] = extract(b, ".par",
-			"GRPclk.*SETUP +\\| +([\d,]+\\.\d+)", float)
-	kw["freq"] = extract(b, ".srp",
-			"Maximum Frequency: +([\d,]+\\.\d+) *MHz", float)
-	kw["reg"] = extract(b, "_map.mrp",
-			"Number of Slice Registers: +([\d,]+) ")
-	kw["lut"] = extract(b, "_map.mrp",
-			"Number of Slice LUTs: +([\d,]+) ")
-	kw["slice"] = extract(b, "_map.mrp",
-			"Number of occupied Slices: +([\d,]+) ")
-	return kw
-
-def run(prefix):
-	dat = {}
-	for base in glob.glob("build/{}_*.json".format(prefix)):
-		kw = load(prefix, base)
-		if "vary" in kw:
-			dat[base] = kw
-	df = pandas.DataFrame.from_dict(dat, orient="index")
-	comp = "freq slice slack".split()
-	dfg = df.groupby("vary")
-	fig, ax = plt.subplots(len(dfg), len(comp))
-	for axj, (v, dfi) in zip(ax, dfg):
-		print(v, dfi)
-		if v not in dfi:
-			continue
-		dfi = dfi.sort(v)
-		for axi, n in zip(axj, comp):
-			x = dfi[v]
-			if type(x[0]) is type(""):
-				xi = range(len(x))
-				axi.set_xticks(xi)
-				axi.set_xticklabels(x)
-				x = xi
-			axi.plot(x, dfi[n])
-			axi.set_xlabel(v)
-			axi.set_ylabel(n)
-	fig.savefig("cordic_impl.pdf")
-	plt.show()
-
-if __name__ == "__main__":
-	run("cordic")
diff --git a/examples/sim/cordic_err.py b/examples/sim/cordic_err.py
deleted file mode 100644
index d7b89b1cf..000000000
--- a/examples/sim/cordic_err.py
+++ /dev/null
@@ -1,109 +0,0 @@
-import random
-
-import numpy as np
-import matplotlib.pyplot as plt
-
-from migen.fhdl.std import *
-from migen.fhdl import verilog
-from migen.genlib.cordic import Cordic
-from migen.sim.generic import run_simulation
-
-class TestBench(Module):
-	def __init__(self, n=None, xmax=.98, i=None, **kwargs):
-		self.submodules.cordic = Cordic(**kwargs)
-		if n is None:
-			n = 1<<flen(self.cordic.xi)
-		self.c = c = 2**(flen(self.cordic.xi) - 1)
-		self.cz = cz = 2**(flen(self.cordic.zi) - 1)
-		x = int(xmax*c/self.cordic.gain)
-		if i is None:
-			i = [(x, 0, int(cz*(2.*ii/n - 1))) for ii in range(n)]
-		self.i = i
-		random.shuffle(self.i)
-		self.ii = iter(self.i)
-		self.o = []
-
-	def do_simulation(self, selfp):
-		if selfp.cordic.new_out:
-			self.o.append((selfp.cordic.xo, selfp.cordic.yo, selfp.cordic.zo))
-		if selfp.cordic.new_in:
-			try:
-				selfp.cordic.xi, selfp.cordic.yi, selfp.cordic.zi = next(self.ii)
-			except StopIteration:
-				raise StopSimulation
-
-	def run_io(self):
-		run_simulation(self)
-		del self.o[0]
-		if self.i[0] != (0, 0, 0):
-			assert self.o[0] != (0, 0, 0)
-		#if self.i[-1] != self.i[-2]:
-		#	assert self.o[-1] != self.o[-2], self.o[-2:]
-
-def rms_err(width, guard=None, stages=None, n=None):
-	tb = TestBench(width=width, guard=guard, stages=stages,
-			n=n, eval_mode="combinatorial")
-	tb.run_io()
-	c = 2**(flen(tb.cordic.xi) - 1)
-	cz = 2**(flen(tb.cordic.zi) - 1)
-	g = tb.cordic.gain
-	xi, yi, zi = np.array(tb.i).T/c
-	zi *= c/cz*tb.cordic.zmax
-	xo1, yo1, zo1 = np.array(tb.o).T
-	xo = np.floor(c*g*(np.cos(zi)*xi - np.sin(zi)*yi))
-	yo = np.floor(c*g*(np.sin(zi)*xi + np.cos(zi)*yi))
-	dx = xo1 - xo
-	dy = yo1 - yo
-	mm = np.fabs([dx, dy]).max()
-	rms = np.sqrt(dx**2 + dy**2).sum()/len(xo)
-	return rms, mm
-
-def rms_err_map():
-	widths, stages = np.mgrid[8:33:1, 8:37:1]
-	errf = np.vectorize(lambda w, s: rms_err(int(w), None, int(s), n=333))
-	err = errf(widths, stages)
-	print(err)
-	lev = np.arange(10)
-	fig, ax = plt.subplots()
-	c1 = ax.contour(widths, stages, err[0], lev/10, cmap=plt.cm.Greys_r)
-	c2 = ax.contour(widths, stages, err[1], lev, cmap=plt.cm.Reds_r)
-	ax.plot(widths[:, 0], stages[0, np.argmin(err[0], 1)], "ko")
-	ax.plot(widths[:, 0], stages[0, np.argmin(err[1], 1)], "ro")
-	print(widths[:, 0], stages[0, np.argmin(err[0], 1)],
-			stages[0, np.argmin(err[1], 1)])
-	ax.set_xlabel("width")
-	ax.set_ylabel("stages")
-	ax.grid("on")
-	fig.colorbar(c1)
-	fig.colorbar(c2)
-	fig.savefig("cordic_rms.pdf")
-
-def plot_function(**kwargs):
-	tb = TestBench(eval_mode="combinatorial", **kwargs)
-	tb.run_io()
-	c = 2**(flen(tb.cordic.xi) - 1)
-	cz = 2**(flen(tb.cordic.zi) - 1)
-	g = tb.cordic.gain
-	xi, yi, zi = np.array(tb.i).T
-	xo, yo, zo = np.array(tb.o).T
-	fig, ax = plt.subplots()
-	#ax.plot(zi, xo-np.around(xi[0]*g*np.cos(zi/cz*np.pi)), "k-")
-	ax.plot(zi, xo, "r,")
-	ax.plot(zi, yo, "g,")
-	ax.plot(zi, zo, "b,")
-
-
-if __name__ == "__main__":
-	c = Cordic(width=16, guard=None, eval_mode="combinatorial")
-	print(verilog.convert(c, ios={c.xi, c.yi, c.zi, c.xo, c.yo, c.zo,
-		c.new_in, c.new_out}))
-	#print(rms_err(8))
-	#rms_err_map()
-	#plot_function(func_mode="hyperbolic", xmax=.3, width=16, n=333)
-	#plot_function(func_mode="circular", width=16, n=333)
-	#plot_function(func_mode="hyperbolic", cordic_mode="vector",
-	#        xmax=.3, width=16, n=333)
-	plot_function(func_mode="circular",
-			width=16, stages=15, guard=0,
-			n=1000, xmax=.98)
-	plt.show()
diff --git a/migen/test/test_cordic.py b/migen/test/test_cordic.py
deleted file mode 100644
index 082ad1339..000000000
--- a/migen/test/test_cordic.py
+++ /dev/null
@@ -1,160 +0,0 @@
-import unittest
-from random import randrange, random
-from math import *
-
-from migen.fhdl.std import *
-from migen.genlib.cordic import *
-
-from migen.test.support import SimCase, SimBench
-
-class CordicCase(SimCase, unittest.TestCase):
-	class TestBench(SimBench):
-		def __init__(self, **kwargs):
-			k = dict(width=8, guard=None, stages=None,
-				eval_mode="combinatorial", cordic_mode="rotate",
-				func_mode="circular")
-			k.update(kwargs)
-			self.submodules.dut = Cordic(**k)
-
-	def _run_io(self, n, gen, proc, delta=1, deltaz=1):
-		c = 2**(flen(self.tb.dut.xi) - 1)
-		g = self.tb.dut.gain
-		zm = self.tb.dut.zmax
-		pipe = {}
-		genn = [gen() for i in range(n)]
-		def cb(tb, tbp):
-			if tbp.dut.new_in:
-				if genn:
-					xi, yi, zi = genn.pop(0)
-				else:
-					raise StopSimulation
-				xi = floor(xi*c/g)
-				yi = floor(yi*c/g)
-				zi = floor(zi*c/zm)
-				tbp.dut.xi = xi
-				tbp.dut.yi = yi
-				tbp.dut.zi = zi
-				pipe[tbp.simulator.cycle_counter] = xi, yi, zi
-			if tbp.dut.new_out:
-				t = tbp.simulator.cycle_counter - tb.dut.latency - 1
-				if t < 1:
-					return
-				xi, yi, zi = pipe.pop(t)
-				xo, yo, zo = proc(xi/c, yi/c, zi/c*zm)
-				xo = floor(xo*c*g)
-				yo = floor(yo*c*g)
-				zo = floor(zo*c/zm)
-				xo1 = tbp.dut.xo
-				yo1 = tbp.dut.yo
-				zo1 = tbp.dut.zo
-				self.assertAlmostEqual(xo, xo1, delta=delta)
-				self.assertAlmostEqual(yo, yo1, delta=delta)
-				self.assertAlmostEqual(abs(zo - zo1) % (2*c), 0, delta=deltaz)
-		self.run_with(cb)
-
-	def test_rot_circ(self):
-		def gen():
-			ti = 2*pi*random()
-			r = random()*.98
-			return r*cos(ti), r*sin(ti), (2*random() - 1)*pi
-		def proc(xi, yi, zi):
-			xo = cos(zi)*xi - sin(zi)*yi
-			yo = sin(zi)*xi + cos(zi)*yi
-			return xo, yo, 0
-		self._run_io(50, gen, proc, delta=2)
-
-	def test_rot_circ_16(self):
-		self.setUp(width=16)
-		self.test_rot_circ()
-
-	def test_rot_circ_pipe(self):
-		self.setUp(eval_mode="pipelined")
-		self.test_rot_circ()
-
-	def test_rot_circ_iter(self):
-		self.setUp(eval_mode="iterative")
-		self.test_rot_circ()
-
-	def _test_vec_circ(self):
-		def gen():
-			ti = pi*(2*random() - 1)
-			r = .98 #*random()
-			return r*cos(ti), r*sin(ti), 0 #pi*(2*random() - 1)
-		def proc(xi, yi, zi):
-			return sqrt(xi**2 + yi**2), 0, zi + atan2(yi, xi)
-		self._run_io(50, gen, proc)
-
-	def test_vec_circ(self):
-		self.setUp(cordic_mode="vector")
-		self._test_vec_circ()
-
-	def test_vec_circ_16(self):
-		self.setUp(width=16, cordic_mode="vector")
-		self._test_vec_circ()
-
-	def _test_rot_hyp(self):
-		def gen():
-			return .6, 0, 2.1*(random() - .5)
-		def proc(xi, yi, zi):
-			xo = cosh(zi)*xi - sinh(zi)*yi
-			yo = sinh(zi)*xi + cosh(zi)*yi
-			return xo, yo, 0
-		self._run_io(50, gen, proc, delta=2)
-
-	def test_rot_hyp(self):
-		self.setUp(func_mode="hyperbolic")
-		self._test_rot_hyp()
-
-	def test_rot_hyp_16(self):
-		self.setUp(func_mode="hyperbolic", width=16)
-		self._test_rot_hyp()
-
-	def test_rot_hyp_iter(self):
-		self.setUp(cordic_mode="rotate", func_mode="hyperbolic",
-				eval_mode="iterative")
-		self._test_rot_hyp()
-
-	def _test_vec_hyp(self):
-		def gen():
-			xi = random()*.6 + .2
-			yi = random()*xi*.8
-			return xi, yi, 0
-		def proc(xi, yi, zi):
-			return sqrt(xi**2 - yi**2), 0, atanh(yi/xi)
-		self._run_io(50, gen, proc, deltaz=2)
-
-	def test_vec_hyp(self):
-		self.setUp(cordic_mode="vector", func_mode="hyperbolic")
-		self._test_vec_hyp()
-
-	def _test_rot_lin(self):
-		def gen():
-			xi = 2*random() - 1
-			if abs(xi) < .01:
-				xi = .01
-			yi = (2*random() - 1)*.5
-			zi = (2*random() - 1)*.5
-			return xi, yi, zi
-		def proc(xi, yi, zi):
-			return xi, yi + xi*zi, 0
-		self._run_io(50, gen, proc)
-
-	def test_rot_lin(self):
-		self.setUp(func_mode="linear")
-		self._test_rot_lin()
-
-	def _test_vec_lin(self):
-		def gen():
-			yi = random()*.95 + .05
-			if random() > 0:
-				yi *= -1
-			xi = abs(yi) + random()*(1 - abs(yi))
-			zi = 2*random() - 1
-			return xi, yi, zi
-		def proc(xi, yi, zi):
-			return xi, 0, zi + yi/xi
-		self._run_io(50, gen, proc, deltaz=2, delta=2)
-
-	def test_vec_lin(self):
-		self.setUp(func_mode="linear", cordic_mode="vector", width=8)
-		self._test_vec_lin()