twoCuts.h

// Internals of Tester class
#if USE_TWO_CUTS

struct TwoCutInt {
  EdgeId a, b;
  bool flip;

  static const int max_value = ((Ring::size - 1) * (Ring::size - 2)) / 2;
  static const int num_classes = (Ring::size * (Ring::size - 1)) / 2;

  struct Tables {
    signed char decodeMatrix[Ring::size][Ring::size];
    struct { signed char a, b; } encodeTable[max_value];
    signed char classMatrix[Ring::size][Ring::size];

    Tables() {
      encodeTable[0] = {1, 2};

      for (int i = 1; i < max_value; i++) {
        bool carry = (encodeTable[i-1].b + 1 >= Ring::size);
        encodeTable[i].a = encodeTable[i-1].a + carry;
        encodeTable[i].b = carry ? encodeTable[i].a + 1 : encodeTable[i-1].b + 1;
      }

      memset(decodeMatrix, -1, sizeof(decodeMatrix));

      for (int i = 0; i < max_value; i++) {
        decodeMatrix[encodeTable[i].a][encodeTable[i].b] = i;
      }

      memset(classMatrix, -1, sizeof(classMatrix));

      struct { signed char a, b; } classTable[num_classes];
      classTable[0] = {0, 1};

      for (int i = 1; i < num_classes; i++) {
        bool carry = (classTable[i-1].b + 1 >= Ring::size);
        classTable[i].a = classTable[i-1].a + carry;
        classTable[i].b = carry ? classTable[i].a + 1 : classTable[i-1].b + 1;
      }

      for (int i = 0; i < num_classes; i++) {
        classMatrix[classTable[i].a][classTable[i].b] = i;
        classMatrix[classTable[i].b][classTable[i].a] = i;
      }
    }
  };

  static const Tables S;

  inline int getValue(const Mapping &map) const {
    return S.decodeMatrix[map[a]][flip ? Ring::negate(map[b]) : map[b]];
  }

  inline void encode(Mapping& map, int value) const {
    auto vals = S.encodeTable[value];
    map.assign(a, vals.a);
    map.assign(b, flip ? Ring::negate(vals.b) : vals.b);
  }

  inline int getClass(const Mapping &map) const {
    return S.classMatrix[map[a]][flip ? Ring::negate(map[b]) : map[b]];
  }
};

#endif