RawSquareFreeTermTest.cpp

Go to the documentation of this file.

/* Frobby: Software for monomial ideal computations.
   Copyright (C) 2010 University of Aarhus
   Contact Bjarke Hammersholt Roune for license information (www.broune.com)
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see http://www.gnu.org/licenses/.
*/
#include "stdinc.h"
#include "RawSquareFreeTerm.h"
#include "tests.h"
 
TEST_SUITE(RawSquareFreeTerm)
 
using namespace SquareFreeTermOps;
namespace Ops = SquareFreeTermOps;
 
TEST(RawSquareFreeTerm, getWordCount) {
  ASSERT_EQ(getWordCount(0), 1u);
  ASSERT_EQ(getWordCount(1), 1u);
 
  ASSERT_EQ(getWordCount(BitsPerWord - 1), 1u);
  ASSERT_EQ(getWordCount(BitsPerWord), 1u);
  ASSERT_EQ(getWordCount(BitsPerWord + 1), 2u);
 
  ASSERT_EQ(getWordCount(10 * BitsPerWord - 1), 10u);
  ASSERT_EQ(getWordCount(10 * BitsPerWord), 10u);
  ASSERT_EQ(getWordCount(10 * BitsPerWord + 1), 11u);
}
 
TEST(RawSquareFreeTerm, SetAndGetExponent) {
  const size_t varCount = BitsPerWord * 2;
  Word* term = newTerm(varCount);
 
  for (size_t var = 0; var < varCount; ++var) {
    ASSERT_FALSE(getExponent(term, var));
    setExponent(term, var, true);
    ASSERT_TRUE(getExponent(term, var));
  }
 
  for (size_t var = 0; var < varCount; ++var) {
    ASSERT_TRUE(getExponent(term, var));
    setExponent(term, var, false);
    ASSERT_FALSE(getExponent(term, var));
  }
}
 
TEST(RawSquareFreeTerm, Assign) {
  const size_t varCount = BitsPerWord * 2;
  const size_t wordCount = getWordCount(varCount);
  Word* a = newTerm(varCount);
  Word* b = newTerm(varCount);
 
  setExponent(a, 1, true);
 
  ASSERT_TRUE(getExponent(a, 1));
  ASSERT_FALSE(getExponent(b, 1));
 
  assign(b, b + wordCount, a);
 
  ASSERT_TRUE(getExponent(a, 1));
  ASSERT_TRUE(getExponent(b, 1));
 
  setExponent(a, 1, false);
 
  ASSERT_FALSE(getExponent(a, 1));
  ASSERT_TRUE(getExponent(b, 1));
 
  deleteTerm(a);
  deleteTerm(b);
}
 
TEST(RawSquareFreeTerm, HasFullSupport) {
  const size_t maxVarCount = 2 * BitsPerWord + 1;
 
  for (size_t varCount = 0; varCount <= maxVarCount; ++varCount) {
    Word* term = newTerm(varCount);
 
    for (size_t var = 0; var < varCount; ++var) {
      ASSERT_FALSE_SILENT(hasFullSupport(term, varCount));
      setExponent(term, var, true);
    }
    ASSERT_TRUE_SILENT(hasFullSupport(term, varCount));
 
    for (size_t var = 0; var < varCount; ++var) {
      ASSERT_TRUE_SILENT(hasFullSupport(term, varCount));
      setExponent(term, var, false);
      ASSERT_FALSE_SILENT(hasFullSupport(term, varCount));
      setExponent(term, var, true);
    }
    ASSERT_TRUE(hasFullSupport(term, varCount));
 
    deleteTerm(term);
  }
}
 
TEST(RawSquareFreeTerm, IsIdentity) {
  const size_t maxVarCount = 2 * BitsPerWord + 1;
  for (size_t varCount = 0; varCount <= maxVarCount; ++varCount) {
    Word* term = newTerm(varCount);
    Word* termEnd = term + getWordCount(varCount);
 
    ASSERT_TRUE(isIdentity(term, termEnd));
    for (size_t var = 0; var < varCount; ++var) {
      ASSERT_TRUE_SILENT(isIdentity(term, termEnd));
      setExponent(term, var, true);
      ASSERT_FALSE_SILENT(isIdentity(term, termEnd));
      setExponent(term, var, false);
    }
    ASSERT_TRUE(isIdentity(term, termEnd));
 
    deleteTerm(term);
  }
}
 
TEST(RawSquareFreeTerm, GetSizeOfSupport) {
  const size_t maxVarCount = 2 * BitsPerWord + 1;
  for (size_t varCount = 0; varCount <= maxVarCount; ++varCount) {
    Word* term = newTerm(varCount);
 
    ASSERT_EQ(getSizeOfSupport(term, varCount), 0u);
    for (size_t var = 0; var < varCount; ++var) {
      setExponent(term, var, 1);
      ASSERT_EQ_SILENT(getSizeOfSupport(term, varCount), 1u);
      setExponent(term, var, 0);
    }
 
    for (size_t var = 0; var < varCount; ++var) {
      setExponent(term, var, 1);
      ASSERT_EQ_SILENT(getSizeOfSupport(term, varCount), var + 1);
    }
 
    deleteTerm(term);
  }
}
 
TEST(RawSquareFreeTerm, SetToIdentity) {
  const size_t maxVarCount = 2 * BitsPerWord + 1;
  for (size_t varCount = 0; varCount <= maxVarCount; ++varCount) {
    Word* term = newTerm(varCount);
    Word* termEnd = term + getWordCount(varCount);
 
    ASSERT_TRUE(isIdentity(term, termEnd));
    for (size_t var = 0; var < varCount; ++var) {
      setExponent(term, var, true);
      setToIdentity(term, termEnd);
      ASSERT_TRUE_SILENT(isIdentity(term, termEnd));
 
      setExponent(term, var, true);
      setToIdentity(term, varCount);
      ASSERT_TRUE_SILENT(isIdentity(term, termEnd));
    }
 
    deleteTerm(term);
  }
}
 
TEST(RawSquareFreeTerm, SetToAllVarProd) {
  const size_t maxVarCount = 2 * BitsPerWord + 1;
  for (size_t varCount = 0; varCount <= maxVarCount; ++varCount) {
    Word* term = newTerm(varCount);
 
    setToAllVarProd(term, varCount);
    ASSERT_TRUE(hasFullSupport(term, varCount));
    for (size_t var = 0; var < varCount; ++var) {
      setExponent(term, var, false);
      setToAllVarProd(term, varCount);
      ASSERT_TRUE_SILENT(isValid(term, varCount));
      ASSERT_TRUE_SILENT(hasFullSupport(term, varCount));
    }
 
    deleteTerm(term);
  }
}
 
TEST(RawSquareFreeTerm, IsRelativelyPrime) {
  const size_t maxVarCount = 2 * BitsPerWord + 1;
  for (size_t varCount = 0; varCount <= maxVarCount; ++varCount) {