From b5954ef2de4f205108be0cf5a06f88540194bed9 Mon Sep 17 00:00:00 2001
From: David Robillard <d@drobilla.net>
Date: Sun, 19 Aug 2018 14:58:14 +0200
Subject: Tighten up size constraints

---
 test/test_gray_code_rank.cpp | 47 ++++++++++++++++++++------------------------
 test/test_hilbert.cpp        |  6 +++---
 test/test_utils.hpp          |  2 +-
 3 files changed, 25 insertions(+), 30 deletions(-)

(limited to 'test')

diff --git a/test/test_gray_code_rank.cpp b/test/test_gray_code_rank.cpp
index 7980bf3..a421159 100644
--- a/test/test_gray_code_rank.cpp
+++ b/test/test_gray_code_rank.cpp
@@ -31,11 +31,11 @@
 #include <iostream>
 #include <iterator>
 
-template <class T, size_t N, size_t D>
+template <class T, size_t Max, size_t D>
 T
 get_mask(const std::array<size_t, D>& ms, const size_t d, const size_t step)
 {
-	T      mask = make_zero_bitvec<T, N>();
+	T      mask = make_zero_bitvec<T, D>();
 	size_t b;
 	chilbert::extractMask(ms.data(), D, d, step, mask, b);
 
@@ -44,15 +44,15 @@ get_mask(const std::array<size_t, D>& ms, const size_t d, const size_t step)
 	return mask;
 }
 
-template <class T, size_t N, size_t D>
+template <class T, size_t Max, size_t D>
 void
 test_extract_mask(Context& ctx)
 {
 	for (size_t d = 0; d < D; ++d) {
-		const auto   ms    = make_random_precisions<N, D>(ctx);
+		const auto   ms    = make_random_precisions<Max, D>(ctx);
 		const auto   max_m = *std::max_element(std::begin(ms), std::end(ms));
 		const size_t step  = rand_between(ctx, 0, max_m);
-		const auto   mask  = get_mask<T, N>(ms, d, step);
+		const auto   mask  = get_mask<T, D>(ms, d, step);
 
 		for (size_t i = 0; i < D; ++i) {
 			assert(mask.test(i) == (ms[(d + i) % D] > step));
@@ -60,20 +60,17 @@ test_extract_mask(Context& ctx)
 	}
 }
 
-template <class T, size_t N, size_t D>
+template <class T, size_t Max, size_t D>
 void
 test_gray_code_rank(Context& ctx)
 {
 	for (size_t d = 0; d < D; ++d) {
 		// Generate random mask
-		const auto   ms    = make_random_precisions<N, D>(ctx);
-		const auto   max_m = *std::max_element(std::begin(ms), std::end(ms));
-		const size_t step  = rand_between(ctx, 0, max_m);
-		const auto   mask  = get_mask<T, N>(ms, d, step);
+		const auto mask = make_random_bitvec<T, D>(ctx);
 
 		// Generate two random values and their gray codes
-		const auto a = make_random_bitvec<T, N>(ctx);
-		const auto b = make_random_bitvec<T, N>(ctx);
+		const auto a = make_random_bitvec<T, D>(ctx);
+		const auto b = make_random_bitvec<T, D>(ctx);
 
 		auto ga = a;
 		grayCode(ga);
@@ -82,19 +79,17 @@ test_gray_code_rank(Context& ctx)
 		grayCode(gb);
 
 		// Calculate gray code ranks
-		auto ra = make_zero_bitvec<T, N>();
+		auto ra = make_zero_bitvec<T, D>();
 		chilbert::grayCodeRank(mask, ga, D, ra);
 
-		auto rb = make_zero_bitvec<T, N>();
+		auto rb = make_zero_bitvec<T, D>();
 		chilbert::grayCodeRank(mask, gb, D, rb);
 
 		// Ensure ranks have at most mask.count() bits
-		if (mask.count() < N) {
-			auto max = make_zero_bitvec<T, N>();
-			setBit(max, mask.count(), 1);
-			assert(ra < max);
-			assert(rb < max);
-		}
+		auto max = make_zero_bitvec<T, D>();
+		setBit(max, mask.count(), 1);
+		assert(ra < max);
+		assert(rb < max);
 
 		// Test fundamental property of gray code ranks
 		const auto mga = ga & mask;
@@ -103,8 +98,8 @@ test_gray_code_rank(Context& ctx)
 
 		// Test inversion
 		const auto pat     = ~mask;
-		auto       ga_out  = make_zero_bitvec<T, N>();
-		auto       gag_out = make_zero_bitvec<T, N>();
+		auto       ga_out  = make_zero_bitvec<T, D>();
+		auto       gag_out = make_zero_bitvec<T, D>();
 		grayCodeRankInv(mask, pat, ra, D, mask.count(), gag_out, ga_out);
 		assert((ga_out & mask) == (ga & mask));
 
@@ -114,12 +109,12 @@ test_gray_code_rank(Context& ctx)
 	}
 }
 
-template <class T, size_t N, size_t D>
+template <class T, size_t Max, size_t D>
 void
 test(Context& ctx)
 {
-	test_extract_mask<T, N, D>(ctx);
-	test_gray_code_rank<T, N, D>(ctx);
+	test_extract_mask<T, Max, D>(ctx);
+	test_gray_code_rank<T, Max, D>(ctx);
 }
 
 int
@@ -140,7 +135,7 @@ main()
 	test<chilbert::CBigBitVec, 64, 33>(ctx);
 	test<chilbert::CBigBitVec, 64, 60>(ctx);
 	test<chilbert::CBigBitVec, 64, 64>(ctx);
-	test<chilbert::CBigBitVec, 128, 65>(ctx);
+	test<chilbert::CBigBitVec, 96, 65>(ctx);
 	test<chilbert::CBigBitVec, 1024, 997>(ctx);
 
 	return 0;
diff --git a/test/test_hilbert.cpp b/test/test_hilbert.cpp
index 20646a2..6a3d1b8 100644
--- a/test/test_hilbert.cpp
+++ b/test/test_hilbert.cpp
@@ -94,7 +94,7 @@ from_big_int(const mpz_class& num)
 	return vec;
 }
 
-template <class T, size_t M, size_t D>
+template <class H, size_t M, size_t D>
 void
 test_standard(Context& ctx)
 {
@@ -103,7 +103,7 @@ test_standard(Context& ctx)
 	// Generate random point and its hilbert index
 	const auto pa = make_random_point<M, D>(ctx);
 
-	T ha = make_zero_bitvec<T, D * M>();
+	H ha = make_zero_bitvec<H, D * M>();
 	assert(ha.size() >= D * M);
 	chilbert::coordsToIndex(pa.data(), M, D, ha);
 
@@ -119,7 +119,7 @@ test_standard(Context& ctx)
 
 	// Generate the next hilbert index
 	const auto ib = ia + 1;
-	const auto hb = from_big_int<T, D * M>(ib);
+	const auto hb = from_big_int<H, D * M>(ib);
 
 	// Unmap next hilbert index to a point
 	auto pb = make_random_point<M, D>(ctx);
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index a695134..37db804 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -66,7 +66,7 @@ rand_between(Context& ctx, const size_t min, const size_t max)
 	return r;
 }
 
-/// Return an array of D precisions with sum at most N and each at most Max
+/// Return an array of D precisions each at most Max and with sum at most N
 template <size_t N, size_t D, size_t Max = 64>
 std::array<size_t, D>
 make_random_precisions(Context& ctx)
-- 
cgit v1.2.1