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
|