36 bool equal = (*aCopy == *bCopy);
44 const size_t varCount = 5;
67 const size_t varCount = 5;
82 vector<RawSquareFreeIdeal*> ideals;
107 for (
size_t i = 0; i < ideals.size(); ++i) {
108 for (
size_t j = 0; j < ideals.size(); ++j) {
116 for (
size_t i = 0; i < ideals.size(); ++i)
146 #define TEST_MINIMIZE(idealStr, minimizedStr) { \ 147 RSFIdeal* ideal = newRawSquareFreeIdealParse(idealStr); \ 148 RSFIdeal* minimized = newRawSquareFreeIdealParse(minimizedStr); \ 149 ASSERT_FALSE(ideal->isMinimallyGenerated()); \ 151 ASSERT_TRUE(sortedEqual(*ideal, *minimized)); \ 152 ASSERT_TRUE(ideal->isMinimallyGenerated()); \ 154 ASSERT_TRUE(sortedEqual(*ideal, *minimized)); \ 155 deleteRawSquareFreeIdeal(ideal); \ 156 deleteRawSquareFreeIdeal(minimized); \ 165 (
"111111111111111111110000000000000000000000011111111111111111111111101\n" 166 "111111111111111111111111111111111111111111111111111111111111111111111\n" 167 "000000000000000000000000000000000000000000000000000000000000000000010\n",
168 "111111111111111111110000000000000000000000011111111111111111111111101\n" 169 "000000000000000000000000000000000000000000000000000000000000000000010\n");
184 #define TEST_COLON_REMINIMIZE_TERM(idealStr, colonStr, minimizedStr) { \ 185 RSFIdeal* ideal = newRawSquareFreeIdealParse(idealStr); \ 186 Word* colon = newTermParse(colonStr); \ 187 RSFIdeal* minimized = newRawSquareFreeIdealParse(minimizedStr); \ 188 ideal->colonReminimize(colon); \ 189 ASSERT_TRUE2(sortedEqual(*ideal, *minimized), *ideal, *minimized); \ 190 ASSERT_TRUE(ideal->isMinimallyGenerated()); \ 191 deleteRawSquareFreeIdeal(ideal); \ 193 deleteRawSquareFreeIdeal(minimized); \ 196 #define TEST_COLON_REMINIMIZE_VAR(idealStr, colonVar, minimizedStr) { \ 197 RSFIdeal* idealVar = newRawSquareFreeIdealParse(idealStr); \ 198 RSFIdeal* idealTerm = newRawSquareFreeIdealParse(idealStr); \ 199 Word* colon = newTerm(idealTerm->getVarCount()); \ 200 setExponent(colon, colonVar, 1); \ 201 RSFIdeal* minimized = newRawSquareFreeIdealParse(minimizedStr); \ 202 idealVar->colonReminimize((size_t)colonVar); \ 203 ASSERT_TRUE2(sortedEqual(*idealVar, *minimized), *idealVar, *minimized); \ 204 idealTerm->colonReminimize(colon); \ 205 ASSERT_TRUE2(sortedEqual(*idealTerm, *minimized), *idealVar, *minimized); \ 206 deleteRawSquareFreeIdeal(idealVar); \ 207 deleteRawSquareFreeIdeal(idealTerm); \ 209 deleteRawSquareFreeIdeal(minimized); \ 221 (
"011111111111111111110000000000000000000000011111111111111111111111101\n" 222 "011111111111111111111111111111111111111111111011111111111111111111101\n" 223 "000000000000000000000000000000000000000000000100000000000000000000010\n", 67,
224 "011111111111111111111111111111111111111111111011111111111111111111101\n" 225 "000000000000000000000000000000000000000000000100000000000000000000000\n");
241 "000000000000001\n", 0,
242 "000000000000000\n");
255 "11000\n10100\n01100");
257 "11000\n10100\n01100");
259 (
"011111111111111111110000000000000000000000011111111111111111111111101\n" 260 "011111111111111111111111111111111111111111111011111111111111111111101\n" 261 "100000000000000000000000000000000000000000000100000000000000000000010\n",
262 "100000000000000000000000000000000000000000000000000000100000000000010",
263 "011111111111111111111111111111111111111111111011111111011111111111101\n" 264 "000000000000000000000000000000000000000000000100000000000000000000000\n");
282 "000000000000000\n");
289 vector<size_t> countsCorrect(varCount);
290 vector<size_t> counts;
296 const size_t insertAllOnesCount = varCount < 33 ? varCount : 33;
297 for (
size_t i = 0; i < insertAllOnesCount; ++i) {
299 for (
size_t var = 0; var < varCount; ++var)
300 countsCorrect[var] += 1;
307 for (
size_t i = 0; i < varCount; ++i) {
310 countsCorrect[i] -= 1;
319 #define TEST_HASFULLSUPPORT(idealStr, _extraStr, value) { \ 320 const char* extraStr = _extraStr; \ 321 Word* extra = extraStr == 0 ? 0 : newTermParse(extraStr); \ 322 RSFIdeal* ideal = newRawSquareFreeIdealParse(idealStr); \ 324 ASSERT_TRUE2(ideal->hasFullSupport(extra), *ideal, extraStr); \ 326 ASSERT_FALSE2(ideal->hasFullSupport(extra), *ideal, extraStr); \ 328 deleteRawSquareFreeIdeal(ideal); \ 346 (
"011111111111111111110000000000000000000000011011111111111111111111101\n" 347 "111111111111111111111111111111111111111111111011111111111111111111101\n" 348 "000000000000000000000000000000000000000000000000000000000000000000010\n",
349 "000000000000000000000000000000000000000000000100000000000000000000000",
353 (
"011111111111111111110000000000000000000000011011111111111111111111101\n" 354 "111111111111111111111111111111111111111111111011111111111111111111101\n" 355 "000000000000000000000000000000000000000000000000000000000000000000010\n",
356 "000000000000000000000000000000000000000000000000000000000000000000000",
359 (
"011111111111111111110000000000000000000000011011111111111111111111101\n" 360 "111111111111111111111111111111111111111111111011111111111111111111101\n" 361 "000000000000000000000000000000000000000000000000000000000000000000000\n",
362 "000000000000000000000000000000000000000000000100000000000000000000000",
366 (
"11111111111111111111111111111111\n",
367 "00000000000000000000000000000000",
371 #define TEST_COMPACT(beforeStr, removeStr, afterStr) { \ 372 RSFIdeal* before = newRawSquareFreeIdealParse(beforeStr); \ 373 Word* remove = newTermParse(removeStr); \ 374 RSFIdeal* after = newRawSquareFreeIdealParse(afterStr); \ 375 before->compact(remove); \ 376 ASSERT_EQ(*before, *after); \ 377 deleteRawSquareFreeIdeal(before); \ 378 deleteTerm(remove); \ 379 deleteRawSquareFreeIdeal(after); \ 385 TEST_COMPACT(
"111\n000\n001\n101",
"110",
"1\n0\n1\n1\n");
388 (
"011111111111111111110000000000000000000000011011111111111111111111101\n" 389 "111111111111111111111111111111111111111111111011111111111111111111101\n" 390 "000000000000000000000000010000000000000000000000000000000000000000010\n",
391 "111111110000000000000000000000000000000000000000000000000000000000001",
392 "111111111111000000000000000000000001101111111111111111111110\n" 393 "111111111111111111111111111111111111101111111111111111111110\n" 394 "000000000000000001000000000000000000000000000000000000000001\n");
397 #define TEST_TRANSPOSE(beforeStr, removeStr, afterStr) { \ 398 RSFIdeal* before = newRawSquareFreeIdealParse(beforeStr); \ 399 Word* remove = removeStr == 0 ? 0 : newTermParse(removeStr);\ 400 RSFIdeal* after = newRawSquareFreeIdealParse(afterStr); \ 401 const size_t maxDim = before->getGeneratorCount() > before->getVarCount() ?\ 402 before->getGeneratorCount() : before->getVarCount(); \ 403 RSFIdeal* calculated = newRawSquareFreeIdeal(maxDim, maxDim);\ 404 calculated->setToTransposeOf(*before, remove); \ 405 ASSERT_EQ(*calculated, *after); \ 406 calculated->setToTransposeOf(*calculated); \ 407 calculated->transpose(); \ 408 ASSERT_EQ(*calculated, *after); \ 409 deleteRawSquareFreeIdeal(before); \ 410 deleteTerm(remove); \ 411 deleteRawSquareFreeIdeal(after); \ 412 deleteRawSquareFreeIdeal(calculated); \ 429 "101\n100\n011\n111\n001\n101\n");
434 for (
size_t i = 0; i < 200; ++i) {
439 TEST_TRANSPOSE(myBefore.c_str(), myRemove.c_str(), myAfter.c_str());
void sortLexAscending()
Sorts the generators in ascending lex order.
bool equals(const Word *a, const Word *b, size_t varCount)
Returns true if a equals b.
RawSquareFreeIdeal RSFIdeal
Word * newTerm(size_t varCount)
Returns identity term of varCount variables.
Word * getGenerator(size_t index)
Returns the generator at index.
TEST(RawSquareFreeIdeal, Insert_Term)
void getVarDividesCounts(vector< size_t > &counts) const
Sets counts[var] to the number of generators that var divides.
#define TEST_SUITE(SUITE)
RSFIdeal * newRawSquareFreeIdeal(size_t varCount, size_t capacity)
Allocates object with enough memory for capacity generators in varCount variables.
void setToIdentity(Word *res, const Word *resEnd)
#define TEST_COMPACT(beforeStr, removeStr, afterStr)
A bit packed square free ideal placed in a pre-allocated buffer.
#define TEST_TRANSPOSE(beforeStr, removeStr, afterStr)
void setExponent(Word *a, size_t var, bool value)
#define ASSERT_TRUE(VALUE)
unsigned long Word
The native unsigned type for the CPU.
static const size_t BitsPerWord
RawSquareFreeIdeal * newRawSquareFreeIdealParse(const char *str)
Allocates and returns an ideal based on str.
#define TEST_HASFULLSUPPORT(idealStr, _extraStr, value)
void setToAllVarProd(Word *res, size_t varCount)
Sets all exponents of res to 1.
Word * newTermParse(const char *strParam)
Allocates and returns a term based on str.
#define TEST_MINIMIZE(idealStr, minimizedStr)
size_t getGeneratorCount() const
#define TEST_COLON_REMINIMIZE_TERM(idealStr, colonStr, minimizedStr)
size_t insert(const Ideal &ideal)
Inserts the generators of ideal from index 0 onward until reaching a non-squarefree generator or all ...
#define TEST_COLON_REMINIMIZE_VAR(idealStr, colonVar, minimizedStr)
void deleteRawSquareFreeIdeal(RSFIdeal *ideal)
void deleteTerm(Word *term)
Deletes term previously returned by newTerm().