203477c3a8
Verification of Przytycki's congruence works fine, however there are some small modifications that could be made. The, naive, approach to the verification of periodicity congruence for the Khovanov polynomial didn't work. There are just too many cases to check. Generation of all of them can exhaust the memory.
242 lines
6.5 KiB
C++
242 lines
6.5 KiB
C++
#ifndef _KNOTKIT_LIB_LIB_H
|
|
#define _KNOTKIT_LIB_LIB_H
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#include <sys/stat.h>
|
|
#include <sys/errno.h>
|
|
|
|
#include <gmpxx.h>
|
|
//#include <gmp.h>
|
|
#include <zlib.h>
|
|
|
|
#include <initializer_list>
|
|
#include <set>
|
|
#include <map>
|
|
#include <string>
|
|
#include <queue>
|
|
#include <algorithm>
|
|
|
|
#include <functional>
|
|
#include <unordered_set>
|
|
#include <unordered_map>
|
|
|
|
/* just need to implement ==, < */
|
|
template<class T> bool operator <= (const T &a, const T &b) { return (a < b) || (a == b); }
|
|
template<class T> bool operator > (const T &a, const T &b) { return ! (a <= b); }
|
|
template<class T> bool operator >= (const T &a, const T &b) { return ! (a < b); }
|
|
|
|
typedef enum copy { COPY, COPY1 } copy;
|
|
typedef enum copy2 { COPY2 } copy2;
|
|
|
|
typedef unsigned char uint8;
|
|
|
|
typedef unsigned char uchar;
|
|
typedef unsigned short ushort;
|
|
typedef unsigned int uint;
|
|
typedef unsigned long ulong;
|
|
|
|
typedef long long int64;
|
|
typedef unsigned long long uint64;
|
|
|
|
inline int64 abs64 (int64 x) { return llabs (x); }
|
|
|
|
typedef size_t hash_t;
|
|
|
|
static const unsigned uint8_bits = 8;
|
|
static const unsigned char_bits = 8;
|
|
static const unsigned uchar_bits = 8;
|
|
static const unsigned int_bits = 32;
|
|
|
|
inline hash_t hash (bool x) { return (hash_t)x; }
|
|
inline hash_t hash (char x) { return (hash_t)x; }
|
|
inline hash_t hash (unsigned char x) { return (hash_t)x; }
|
|
inline hash_t hash (short x) { return (hash_t)x; }
|
|
inline hash_t hash (unsigned short x) { return (hash_t)x; }
|
|
inline hash_t hash (int x) { return (hash_t)x; }
|
|
inline hash_t hash (unsigned x) { return (hash_t)x; }
|
|
inline hash_t hash (long x) { return (hash_t)x; }
|
|
inline hash_t hash (unsigned long x) { return (hash_t)x; }
|
|
|
|
inline hash_t hash (uint64 x) { return (hash_t)((x >> 32) ^ x); }
|
|
|
|
hash_t hash (const std::string &s);
|
|
|
|
inline bool operator == (const std::string &s, const std::string &t)
|
|
{
|
|
return strcmp (s.c_str (), t.c_str ()) == 0;
|
|
}
|
|
|
|
inline bool operator < (const std::string &s, const std::string &t)
|
|
{
|
|
return strcmp (s.c_str (), t.c_str ()) < 0;
|
|
}
|
|
|
|
inline bool operator <= (const std::string &s, const std::string &t)
|
|
{
|
|
return strcmp (s.c_str (), t.c_str ()) <= 0;
|
|
}
|
|
|
|
template<class T>
|
|
inline hash_t hash (const T &x)
|
|
{
|
|
return x.hash_self ();
|
|
}
|
|
|
|
inline hash_t
|
|
hash_combine (hash_t a, hash_t b)
|
|
{
|
|
return (a ^ b) * 131;
|
|
}
|
|
|
|
/* uint64 */
|
|
static const unsigned uint64_bits = 64;
|
|
static const unsigned uint64_bit_mask = 0x3f;
|
|
|
|
static const unsigned unsigned_bits = 32;
|
|
static const unsigned unsigned_bit_mask = 0x1f;
|
|
|
|
inline unsigned uint64_bitcount (uint64 x) { return __builtin_popcountll (x); }
|
|
inline unsigned uint64_ffs (uint64 x) { assert (x != 0); return __builtin_ctzll (x) + 1; }
|
|
|
|
inline uint64 uint64_bitmask (unsigned i) { assert (i >= 1 && i <= uint64_bits); return ((uint64)1) << (i - 1); }
|
|
inline unsigned uint64_fill (unsigned b) { assert (b <= uint64_bits); return ((uint64)1 << b) - 1; }
|
|
inline uint64 uint64_bitset (uint64 x, unsigned i) { return x | uint64_bitmask (i); }
|
|
inline uint64 uint64_bitclear (uint64 x, unsigned i) { return x & ~uint64_bitmask (i); }
|
|
inline uint64 uint64_bittoggle (uint64 x, unsigned i) { return x ^ uint64_bitmask (i); }
|
|
inline bool uint64_bittest (uint64 x, unsigned i) { return (bool)(x & uint64_bitmask (i)); }
|
|
|
|
/* unsigned */
|
|
inline unsigned unsigned_bitmask (unsigned i) { assert (i >= 1 && i <= unsigned_bits); return ((unsigned)1) << (i - 1); }
|
|
inline unsigned unsigned_fill (unsigned b) { assert (b <= unsigned_bits); return ((unsigned)1 << b) - 1; }
|
|
|
|
inline unsigned unsigned_discard_bit (unsigned w, unsigned i)
|
|
{
|
|
assert (i >= 1 && i <= unsigned_bits);
|
|
return (w & ((((unsigned)1) << (i - 1)) - 1))
|
|
| ((w >> i) << (i - 1));
|
|
}
|
|
|
|
inline unsigned unsigned_bitset (unsigned w, unsigned i) { return w | unsigned_bitmask (i); }
|
|
inline unsigned unsigned_bitclear (unsigned w, unsigned i) { return w &~ unsigned_bitmask (i); }
|
|
inline bool unsigned_bittest (unsigned w, unsigned i) { return (bool)(w & unsigned_bitmask (i)); }
|
|
|
|
inline unsigned unsigned_bitcount (unsigned w) { return __builtin_popcount (w); }
|
|
inline unsigned unsigned_ffs (unsigned w) { assert (w); return __builtin_ctzl (w) + 1; }
|
|
|
|
/* pack the bits of z into the zeros of x, where x has n bits. */
|
|
unsigned unsigned_pack (unsigned n, unsigned x, unsigned z);
|
|
|
|
inline bool is_odd (int x) { return x & 1; }
|
|
inline bool is_odd (unsigned x) { return x & 1; }
|
|
|
|
inline bool is_even (int x) { return !is_odd (x); }
|
|
inline bool is_even (unsigned x) { return !is_odd (x); }
|
|
|
|
inline unsigned unsigned_2pow (unsigned e) { return ((unsigned)1) << e; }
|
|
|
|
class unsigned_const_iter
|
|
{
|
|
private:
|
|
unsigned x;
|
|
unsigned b;
|
|
|
|
public:
|
|
unsigned_const_iter (unsigned x_) : x(x_), b(0) { if (x) b = unsigned_ffs (x); }
|
|
unsigned_const_iter (const unsigned_const_iter &i) : x(i.x), b(i.b) { }
|
|
~unsigned_const_iter () { }
|
|
|
|
unsigned_const_iter &operator = (const unsigned_const_iter &i) { x = i.x; b = i.b; return *this; }
|
|
|
|
unsigned val () const { assert (x); return b; }
|
|
operator bool () { return (bool)x; }
|
|
void operator ++ () { assert (x); x = unsigned_bitclear (x, b); if (x) b = unsigned_ffs (x); }
|
|
void operator ++ (int) { operator ++ (); }
|
|
};
|
|
|
|
inline bool between (unsigned a, unsigned x, unsigned b) { return a <= x && x <= b; }
|
|
|
|
void stderror (const char *fmt, ...);
|
|
|
|
int alpha_to_int (char c);
|
|
|
|
using std::tuple;
|
|
using std::get;
|
|
using std::make_tuple;
|
|
using std::tie;
|
|
using std::ignore;
|
|
using std::initializer_list;
|
|
|
|
#include <lib/show.h>
|
|
#include <lib/refcount.h>
|
|
|
|
#include <lib/io.h>
|
|
|
|
#include <lib/pair.h>
|
|
|
|
#include <lib/maybe.h>
|
|
#include <lib/vector.h>
|
|
|
|
#include <lib/set_wrapper.h>
|
|
#include <lib/set.h>
|
|
|
|
class bitset;
|
|
template<unsigned B> class ullmanset;
|
|
|
|
unsigned fact (unsigned n);
|
|
unsigned choose (unsigned n, unsigned k);
|
|
|
|
inline int random_int (int from, int to)
|
|
{
|
|
assert (to >= from);
|
|
return from + (random () % (to - from + 1));
|
|
}
|
|
|
|
#include <lib/smallbitset.h>
|
|
#include <lib/bitset.h>
|
|
#include <lib/ullmanset.h>
|
|
#include <lib/setcommon.h>
|
|
#include <lib/map_wrapper.h>
|
|
#include <lib/map.h>
|
|
|
|
template<class K>
|
|
struct hasher : public std::unary_function<K, hash_t>
|
|
{
|
|
hash_t operator () (const K &k) const { return hash (k); }
|
|
};
|
|
|
|
#include <lib/hashmap.h>
|
|
#include <lib/hashset.h>
|
|
|
|
#include <lib/ullmanmap.h>
|
|
#include <lib/mapcommon.h>
|
|
#include <lib/unionfind.h>
|
|
#include <lib/priority_queue.h>
|
|
#include <lib/directed_multigraph.h>
|
|
|
|
// ??? io
|
|
|
|
class algebra_writer
|
|
{
|
|
public:
|
|
// modules
|
|
unsigned io_id_counter;
|
|
map<unsigned, unsigned> id_io_id;
|
|
|
|
algebra_writer () : io_id_counter(0) { }
|
|
~algebra_writer () { }
|
|
};
|
|
|
|
class algebra_reader
|
|
{
|
|
public:
|
|
map<unsigned, unsigned> io_id_id;
|
|
|
|
};
|
|
|
|
#endif // _KNOTKIT_LIB_LIB_H
|