ooxml_crypt 0.1.0

data/vendor/cybozulib/include/cybozu/v128.hpp

@@ -0,0 +1,376 @@
+#pragma once
+/**
+	@file
+	@brief wrapper of __m128
+	@author MITSUNARI Shigeo(@herumi)
+	@license modified new BSD license
+	http://opensource.org/licenses/BSD-3-Clause
+*/
+#include <cybozu/inttype.hpp>
+#include <stdio.h>
+#include <assert.h>
+#ifdef _WIN32
+	#include <intrin.h>
+#else
+	#ifdef __linux__
+		#include <x86intrin.h>
+	#else
+		#include <emmintrin.h>
+	#endif
+#endif
+
+#ifndef MIE_PACK // for shufps
+	#define MIE_PACK(x, y, z, w) ((x) * 64 + (y) * 16 + (z) * 4 + (w))
+#endif
+
+namespace cybozu {
+
+struct V128 {
+	__m128i x_;
+	V128()
+	{
+	}
+	V128(const uint32_t *p)
+		: x_(_mm_load_si128((const __m128i*)p))
+	{
+	}
+	V128(__m128i x)
+		: x_(x)
+	{
+	}
+	V128(__m128 x)
+		: x_(_mm_castps_si128(x))
+	{
+	}
+	__m128 to_ps() const { return _mm_castsi128_ps(x_); }
+	// m = [x3:x2:x1:x0]
+	V128(uint32_t x3, uint32_t x2, uint32_t x1, uint32_t x0)
+		: x_(_mm_set_epi32(x3, x2, x1, x0))
+	{
+	}
+	explicit V128(uint32_t x)
+		: x_(_mm_cvtsi32_si128(x))
+	{
+	}
+#if defined(_M_X64) || defined(__x86_64__)
+	explicit V128(uint64_t x)
+		: x_(_mm_cvtsi64_si128(x))
+	{
+	}
+#endif
+	V128(const V128& rhs)
+		: x_(rhs.x_)
+	{
+	}
+	void clear()
+	{
+		*this = _mm_setzero_si128();
+	}
+	void set(uint32_t x)
+	{
+		x_ = _mm_set1_epi32(x);
+	}
+	// m = [x3:x2:x1:x0]
+	void set(uint32_t x3, uint32_t x2, uint32_t x1, uint32_t x0)
+	{
+		x_ = _mm_set_epi32(x3, x2, x1, x0);
+	}
+	// aligned
+	void store(uint32_t *p) const
+	{
+		_mm_store_si128((__m128i*)p, x_);
+	}
+	// unaligned
+	void store_u(uint32_t *p) const
+	{
+		_mm_storeu_si128((__m128i*)p, x_);
+	}
+	// aligned
+	void load(const uint32_t *p)
+	{
+		x_ = _mm_load_si128((const __m128i*)p);
+	}
+	// unaligned
+	void load_u(const uint32_t *p)
+	{
+		x_ = _mm_loadu_si128((const __m128i*)p);
+	}
+	/*
+		*this >>= n
+	*/
+	template<int n>
+	void shrBit();
+	/*
+		*this <<= n
+	*/
+	template<int n>
+	void shlBit();
+	void put(const char *msg = 0) const
+	{
+		uint32_t v[4];
+		store_u(v);
+		if (msg) printf("%s", msg);
+		printf("%08x:%08x:%08x:%08x", v[3], v[2], v[1], v[0]);
+		if (msg) putchar('\n');
+	}
+};
+
+inline uint32_t movd(const V128& a)
+{
+	return _mm_cvtsi128_si32(a.x_);
+}
+
+inline V128 Zero()
+{
+	return _mm_setzero_si128();
+}
+
+template<int n>
+inline V128 psrldq(const V128& a)
+{
+	return _mm_srli_si128(a.x_, n);
+}
+
+template<int n>
+inline V128 pslldq(const V128& a)
+{
+	return _mm_slli_si128(a.x_, n);
+}
+
+template<int n>
+inline V128 psrlq(const V128& a)
+{
+	return _mm_srli_epi64(a.x_, n);
+}
+
+inline V128 psrlq(const V128& a, const V128& n)
+{
+	return _mm_srl_epi64(a.x_, n.x_);
+}
+
+template<int n>
+inline V128 psllq(const V128& a)
+{
+	return _mm_slli_epi64(a.x_, n);
+}
+
+inline V128 psllq(const V128& a, const V128& n)
+{
+	return _mm_sll_epi64(a.x_, n.x_);
+}
+
+template<int n>
+inline V128 palignr(const V128& a, const V128& b)
+{
+	return _mm_alignr_epi8(a.x_, b.x_, n);
+}
+
+inline V128 punpckhdq(const V128& a, const V128& b)
+{
+	return _mm_unpackhi_epi32(a.x_, b.x_);
+}
+
+inline V128 punpckhqdq(const V128& a, const V128& b)
+{
+	return _mm_unpackhi_epi64(a.x_, b.x_);
+}
+
+inline V128 punpckldq(const V128& a, const V128& b)
+{
+	return _mm_unpacklo_epi32(a.x_, b.x_);
+}
+
+inline V128 punpcklqdq(const V128& a, const V128& b)
+{
+	return _mm_unpacklo_epi64(a.x_, b.x_);
+}
+
+inline V128 unpcklps(const V128& a, const V128& b)
+{
+	return _mm_unpacklo_ps(a.to_ps(), b.to_ps());
+}
+
+inline V128 unpckhps(const V128& a, const V128& b)
+{
+	return _mm_unpackhi_ps(a.to_ps(), b.to_ps());
+}
+
+inline V128 paddd(const V128& a, const V128& b)
+{
+	return _mm_add_epi32(a.x_, b.x_);
+}
+inline V128 psubd(const V128& a, const V128& b)
+{
+	return _mm_sub_epi32(a.x_, b.x_);
+}
+
+inline V128 pandn(const V128& a, const V128& b)
+{
+	return _mm_andnot_si128(a.x_, b.x_);
+}
+
+inline V128 por(const V128& a, const V128& b)
+{
+	return _mm_or_si128(a.x_, b.x_);
+}
+
+inline V128 pand(const V128& a, const V128& b)
+{
+	return _mm_and_si128(a.x_, b.x_);
+}
+
+inline V128 pxor(const V128& a, const V128& b)
+{
+	return _mm_xor_si128(a.x_, b.x_);
+}
+
+inline V128 pmaxsd(const V128& a, const V128& b)
+{
+	return _mm_max_epi32(a.x_, b.x_);
+}
+
+inline V128 pminsd(const V128& a, const V128& b)
+{
+	return _mm_min_epi32(a.x_, b.x_);
+}
+
+inline V128 pmaxud(const V128& a, const V128& b)
+{
+	return _mm_max_epu32(a.x_, b.x_);
+}
+
+inline V128 pminud(const V128& a, const V128& b)
+{
+	return _mm_min_epu32(a.x_, b.x_);
+}
+
+inline V128 pcmpeqd(const V128& a, const V128& b)
+{
+	return _mm_cmpeq_epi32(a.x_, b.x_);
+}
+
+inline V128 pcmpgtd(const V128& a, const V128& b)
+{
+	return _mm_cmpgt_epi32(a.x_, b.x_);
+}
+
+inline uint32_t pmovmskb(const V128& a)
+{
+	return _mm_movemask_epi8(a.x_);
+}
+inline V128 pshufb(const V128& a, const V128& b)
+{
+	return _mm_shuffle_epi8(a.x_, b.x_);
+}
+
+template<int n>
+inline V128 pshufd(const V128& a)
+{
+	return _mm_shuffle_epi32(a.x_, n);
+}
+
+template<int idx>
+inline uint32_t pextrd(const V128& a)
+{
+	return _mm_extract_epi32(a.x_, idx);
+}
+
+template<int idx>
+inline V128 pinsrd(const V128& a, uint32_t v)
+{
+	return _mm_castsi128_ps(_mm_insert_epi32(a.x_, v, idx));
+}
+
+template<int idx>
+inline V128 pinsrb(const V128& a, uint8_t v)
+{
+	return _mm_castsi128_ps(_mm_insert_epi8(a.x_, v, idx));
+}
+
+inline int ptest_zf(const V128& a, const V128& b)
+{
+	return _mm_testz_si128(a.x_, b.x_);
+}
+
+inline int ptest_cf(const V128& a, const V128& b)
+{
+	return _mm_testc_si128(a.x_, b.x_);
+}
+
+inline V128 psadbw(const V128& a, const V128& b)
+{
+	return _mm_sad_epu8(a.x_, b.x_);
+}
+
+inline void swap128(uint32_t *p, uint32_t *q)
+{
+	V128 t(p);
+	V128(q).store(p);
+	t.store(q);
+}
+
+inline void copy128(uint32_t *dest, const uint32_t *src)
+{
+	V128(src).store(dest);
+}
+
+template<int n>
+inline void V128::shrBit()
+{
+	assert(n < 64);
+	*this = psrlq<n>(*this) | psllq<64 - n>(psrldq<8>(*this));
+#if 0
+	if (n == 64) {
+		*this = psrldq<8>(*this);
+	} else if (n > 64) {
+		*this = psrlq<n - 64>(psrldq<8>(*this));
+	}
+#endif
+}
+
+template<int n>
+inline void V128::shlBit()
+{
+	assert(n < 64);
+	*this = psllq<n>(*this) | psrlq<64 - n>(pslldq<8>(*this));
+#if 0
+	if (n == 64) {
+		*this = pslldq<8>(*this);
+	} else if (n > 64) {
+		*this = psllq<n - 64>(pslldq<8>(*this));
+	}
+#endif
+}
+
+/*
+	byte rotr [x2:x1:x0]
+*/
+template<int n>
+inline void rotrByte(V128& x0, V128& x1, V128& x2)
+{
+	V128 t(x0);
+	x0 = palignr<n>(x1, x0);
+	x1 = palignr<n>(x2, x1);
+	x2 = palignr<n>(t, x2);
+}
+
+/*
+	byte rotl [x2:x1:x0]
+*/
+template<int n>
+inline void rotlByte(V128& x0, V128& x1, V128& x2)
+{
+	V128 t(x2);
+	x2 = palignr<16 - n>(x2, x1);
+	x1 = palignr<16 - n>(x1, x0);
+	x0 = palignr<16 - n>(x0, t);
+}
+
+#if defined(_M_X64) || defined(__x86_64__)
+inline uint64_t movq(const V128& a)
+{
+	return _mm_cvtsi128_si64(a.x_);
+}
+#endif
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/wavelet_matrix.hpp

@@ -0,0 +1,345 @@
+#pragma once
+/**
+	@file
+	@brief Wavelet Matrix
+	@author MITSUNARI Shigeo(@herumi)
+	@license modified new BSD license
+	http://opensource.org/licenses/BSD-3-Clause
+*/
+#include <cybozu/sucvector.hpp>
+#include <stdio.h>
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+
+//#define CYBOZU_WAVELET_MATRIX_DIRECT_CONSTRUCT
+
+#ifndef CYBOZU_WAVELET_MATRIX_DIRECT_CONSTRUCT
+	#include <cybozu/bitvector.hpp>
+#endif
+
+namespace cybozu {
+/*
+	current version supports only max 32GiB
+*/
+template<bool withSelect = true, class SucVector = cybozu::SucVectorT<uint32_t, false> >
+class WaveletMatrixT {
+	typedef uint32_t size_type;
+	bool getPos(uint64_t v, size_t pos) const
+	{
+		return (v & (uint64_t(1) << pos)) != 0;
+	}
+	template<class V>
+	size_t countZero(const V& in, size_t bitPos) const
+	{
+		size_t ret = 0;
+		const size_t mask = size_t(1) << bitPos;
+		for (size_t i =0, n = in.size(); i < n; i++) {
+			if (!(in[i] & mask)) ret++;
+		}
+		return ret;
+	}
+	void initFromTbl(std::vector<size_type>& tbl, size_t pos, size_t from, size_t i) const
+	{
+		if (i == valBitLen_) {
+			tbl[pos] = (size_type)from;
+		} else {
+			initFromTbl(tbl, pos, svv[i].rank(false, from), i + 1);
+			initFromTbl(tbl, pos + (size_t(1) << (valBitLen_ - 1 - i)), svv[i].rank(true, from) + offTbl[i], i + 1);
+		}
+	}
+	void initFromLtTbl(std::vector<size_type>& tbl, size_t pos, size_t from, size_t ret, size_t i) const
+	{
+		if (i == valBitLen_) {
+			tbl[pos] = (size_type)ret;
+		} else {
+			size_t end = svv[i].rank1(from);
+			initFromLtTbl(tbl, pos, from - end, ret, i + 1);
+			initFromLtTbl(tbl, pos + (size_t(1) << (valBitLen_ - 1 - i)), offTbl[i] + end, ret + from - end, i + 1);
+		}
+	}
+	typedef std::vector<SucVector> SucVecVec;
+	uint64_t maxVal_;
+	size_t valBitLen_;
+	size_t size_;
+	SucVecVec svv;
+	std::vector<size_type> offTbl;
+	std::vector<size_type> fromTbl;
+	std::vector<size_type> fromLtTbl;
+	typedef std::vector<uint32_t> Uint32Vec;
+	static const uint64_t posUnit = 256;
+	std::vector<Uint32Vec> selTbl_;
+
+	// call after initialized
+	template<class Vec>
+	void initSelTbl(std::vector<Uint32Vec>& tblVec, const Vec& vec) const
+	{
+		if (!withSelect) return;
+		tblVec.resize(maxVal_);
+
+		Uint32Vec iTbl(maxVal_);
+		Uint32Vec numTbl(maxVal_);
+		for (uint64_t v = 0; v < maxVal_; v++) {
+			const size_t size = sucvector_util::getBlockNum(this->size(v), posUnit);
+			tblVec[v].resize(size);
+			iTbl[v] = 1;
+		}
+		for (uint32_t pos = 0, n = (uint32_t)vec.size(); pos < n; pos++) {
+			uint64_t v = vec[pos];
+			uint32_t i = iTbl[v];
+			numTbl[v]++;
+			if (numTbl[v] >= i * posUnit) {
+				if (i < tblVec[v].size()) {
+					tblVec[v][i] = pos + 1;
+					iTbl[v]++;
+				}
+			}
+		}
+	}
+public:
+	WaveletMatrixT()
+		: maxVal_(1)
+		, valBitLen_(0)
+		, size_(0)
+	{
+	}
+	/*
+		data format(endian is depend on CPU:eg. little endian for x86/x64)
+		valBitLen     : 8
+		maxVal        : 8
+		size          : 8
+		svv
+		offTblSize    : 8
+		offTbl
+		fromTblSize   : 8
+		fromTbl
+		fromLtTblSize : 8
+		fromLtTbl
+	*/
+	template<class OutputStream>
+	void save(OutputStream& os) const
+	{
+		cybozu::save(os, maxVal_);
+		cybozu::save(os, valBitLen_);
+		cybozu::save(os, size_);
+		assert(valBitLen_ == svv.size());
+		for (size_t i = 0; i < valBitLen_; i++) {
+			svv[i].save(os);
+		}
+		cybozu::savePodVec(os, offTbl);
+		cybozu::savePodVec(os, fromTbl);
+		cybozu::savePodVec(os, fromLtTbl);
+
+		if (withSelect) {
+			for (uint64_t v = 0; v < maxVal_; v++) {
+				cybozu::savePodVec(os, selTbl_[v]);
+			}
+		}
+	}
+	template<class InputStream>
+	void load(InputStream& is)
+	{
+		cybozu::load(maxVal_, is);
+		cybozu::load(valBitLen_, is);
+		cybozu::load(size_, is);
+		svv.resize(valBitLen_);
+		for (size_t i = 0; i < valBitLen_; i++) {
+			svv[i].load(is);
+		}
+		cybozu::loadPodVec(offTbl, is);
+		cybozu::loadPodVec(fromTbl, is);
+		cybozu::loadPodVec(fromLtTbl, is);
+
+		if (withSelect) {
+			selTbl_.resize(maxVal_);
+			for (uint64_t v = 0; v < maxVal_; v++) {
+				cybozu::loadPodVec(selTbl_[v], is);
+			}
+		}
+	}
+	uint64_t size() const { return size_; }
+	uint64_t size(uint64_t val) const
+	{
+		assert(val < maxVal_);
+		return rank(val, size_);
+	}
+	template<class Vec>
+	void init(const Vec& vec, size_t valBitLen)
+	{
+		if (vec.size() > (uint64_t(1) << 32)) throw cybozu::Exception("WaveletMatrix:init:too large") << vec.size();
+		if (valBitLen > 16) throw cybozu::Exception("WaveletMatrix:init:too large valBitLen") << valBitLen;
+		valBitLen_ = valBitLen;
+		maxVal_ = uint64_t(1) << valBitLen_;
+		size_ = vec.size();
+		svv.resize(valBitLen_);
+
+		// count zero bit
+		offTbl.resize(valBitLen_);
+		for (size_t i = 0, n = offTbl.size(); i < n; i++) {
+			offTbl[i] = (size_type)countZero(vec, valBitLen - 1 - i);
+		}
+
+		// construct svv
+		Vec cur = vec, next;
+		next.resize(size_);
+		for (size_t i = 0; i < valBitLen; i++) {
+#ifdef CYBOZU_WAVELET_MATRIX_DIRECT_CONSTRUCT
+			SucVector& sv = svv[i];
+#else
+			cybozu::BitVector sv;
+#endif
+			sv.resize(size_);
+			size_t zeroPos = 0;
+			size_t onePos = offTbl[i];
+			for (size_t j = 0; j < size_; j++) {
+				bool b = getPos(cur[j], valBitLen - 1 - i);
+				if (b) {
+					sv.set(j);
+				}
+				if (i == valBitLen - 1) continue;
+				if (b) {
+					next[onePos++] = cur[j];
+				} else {
+					next[zeroPos++] = cur[j];
+				}
+			};
+#ifdef CYBOZU_WAVELET_MATRIX_DIRECT_CONSTRUCT
+			sv.ready();
+#else
+			svv[i].init(sv.getBlock(), sv.size());
+#endif
+			next.swap(cur);
+		}
+
+		// construct fromTbl
+		fromTbl.resize(maxVal_);
+		initFromTbl(fromTbl, 0, 0, 0);
+
+		fromLtTbl.resize(maxVal_);
+		initFromLtTbl(fromLtTbl, 0, 0, 0, 0);
+
+		initSelTbl(selTbl_, vec);
+	}
+	uint64_t get(uint64_t pos) const
+	{
+		assert(pos < size_);
+		uint64_t ret = 0;
+		size_t i = 0;
+		for (;;) {
+			bool b = svv[i].get(pos);
+			ret = (ret << 1) | uint32_t(b);
+			if (i == valBitLen_ - 1) return ret;
+#if 0
+			pos = svv[i].rank(b, pos);
+			if (b) pos += offTbl[i];
+#else
+			if (b) {
+				pos = offTbl[i] + svv[i].rank1(pos);
+			} else {
+				pos -= svv[i].rank1(pos);
+			}
+#endif
+			i++;
+		}
+	}
+	/*
+		get number of val in [0, pos)
+		@note shotcut idea to reduce computing 'from' by @echizen_tm
+		see http://ja.scribd.com/doc/102636443/Wavelet-Matrix
+	*/
+	uint64_t rank(uint64_t val, uint64_t pos) const
+	{
+		assert(val < maxVal_);
+		if (pos > size_) pos = size_;
+		for (size_t i = 0; i < valBitLen_; i++) {
+			bool b = (val & (uint64_t(1) << (valBitLen_ - 1 - i))) != 0;
+			if (b) {
+				pos = offTbl[i] + svv[i].rank1(pos);
+			} else {
+				pos -= svv[i].rank1(pos);
+			}
+		}
+		return pos - fromTbl[val];
+	}
+	/*
+		get value and rank
+		val = get(pos);
+		return rank(val, pos);
+	*/
+	template<class T>
+	uint64_t get(T* pval, uint64_t pos) const
+	{
+		if (pos > size_) pos = size_;
+		uint64_t ret = 0;
+		for (size_t i = 0; i < valBitLen_; i++) {
+			bool b = svv[i].get(pos);
+			ret = (ret << 1) | uint32_t(b);
+			if (b) {
+				pos = offTbl[i] + svv[i].rank1(pos);
+			} else {
+				pos -= svv[i].rank1(pos);
+			}
+		}
+		*pval = (T)ret;
+		return pos - fromTbl[ret];
+	}
+	/*
+		get number of less than val in [0, pos)
+	*/
+	uint64_t rankLt(uint64_t val, uint64_t pos) const
+	{
+		assert(val < maxVal_);
+		if (pos > size_) pos = size_;
+		uint64_t ret = 0;
+		for (size_t i = 0; i < valBitLen_; i++) {
+			bool b = getPos(val, valBitLen_ - 1 - i);
+			uint64_t end = svv[i].rank1(pos);
+			if (b) {
+				ret += pos - end;
+				pos = offTbl[i] + end;
+			} else {
+				pos -= end;
+			}
+		}
+		return ret - fromLtTbl[val];
+	}
+	uint64_t select(uint64_t val, uint64_t rank) const
+	{
+		if (!withSelect) throw cybozu::Exception("WaveletMatrix:select:not support");
+		assert(val < maxVal_);
+		const Uint32Vec& tbl = selTbl_[val];
+		if (rank / posUnit >= tbl.size()) return cybozu::NotFound;
+		const size_t pos = size_t(rank / posUnit);
+//		size_t L = 0;
+//		size_t R = size_;
+		size_t L = tbl[pos];
+		size_t R = pos >= tbl.size() - 1 ? size_ : tbl[pos + 1];
+//printf("val=%d, rank=%d, L=%d, R=%d, size=%d\n", (int)val, (int)rank, (int)L, (int)R, (int)size_);
+		rank++;
+		while (L < R) {
+			size_t M = (L + R) / 2;
+			if (this->rank(val, M) < rank) {
+				L = M + 1;
+			} else {
+				R = M;
+			}
+		}
+		if (L > 0) L--;
+		for (;;) {
+			if (this->rank(val, L) == rank) {
+				return L - 1;
+			}
+			L++;
+			if (L > size_) return cybozu::NotFound;
+		}
+	}
+};
+
+typedef WaveletMatrixT<> WaveletMatrix;
+
+} // cybozu
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif