ooxml_crypt 0.1.0

data/vendor/cybozulib/sample/wm_bench_smpl.cpp

@@ -0,0 +1,182 @@
+#include <cybozu/wavelet_matrix.hpp>
+#include <cybozu/xorshift.hpp>
+#include <algorithm>
+#include <cybozu/benchmark.hpp>
+#include <stdlib.h>
+
+struct Naive {
+private:
+	Naive(const Naive&);
+	void operator=(const Naive&);
+public:
+	const std::vector<uint8_t>& v_;
+	explicit Naive(const std::vector<uint8_t>& v)
+		: v_(v)
+	{
+	}
+	size_t get(size_t pos) const
+	{
+		return v_[pos];
+	}
+	size_t rank(uint32_t val, size_t pos) const
+	{
+		return std::count(v_.begin(), v_.begin() + pos, val);
+	}
+	size_t rankLt(uint32_t val, size_t pos) const
+	{
+		size_t ret = 0;
+		for (size_t i = 0, n = pos; i < n; i++) {
+			if (v_[i] < val) ret++;
+		}
+		return ret;
+	}
+	size_t select(uint32_t val, size_t n) const
+	{
+		const size_t N = v_.size();
+		n++;
+		for (size_t i = 0; i < N; i++) {
+			if (v_[i] == val) n--;
+			if (n == 0) return i;
+		}
+		return cybozu::NotFound;
+	}
+};
+
+void add(size_t& ret, size_t x)
+{
+	ret += x;
+}
+
+template<class T, class RG>
+void bench_get(const T& wm, RG& rg, size_t N)
+{
+	size_t ret = 0;
+	printf("get   ");
+	CYBOZU_BENCH("", add, ret, wm.get(rg() & (N - 1)));
+	printf(" ret=%u\n", (int)ret);
+}
+
+template<class T, class RG>
+void bench_rank(const T& wm, RG& rg, size_t N)
+{
+	size_t ret = 0;
+	printf("rank  ");
+	CYBOZU_BENCH("", add, ret, wm.rank(uint8_t(rg()), rg() & (N - 1)));
+	printf(" ret=%u\n", (int)ret);
+}
+
+template<class T, class RG>
+void bench_rankLt(const T& wm, RG& rg, size_t N)
+{
+	size_t ret = 0;
+	printf("rank  ");
+	CYBOZU_BENCH("", add, ret, wm.rankLt(uint8_t(rg()), rg() & (N - 1)));
+	printf(" ret=%u\n", (int)ret);
+}
+
+template<class T, class RG>
+void oneSelect(size_t& ret, const T& wm, RG& rg, const std::vector<int>& maxTbl)
+{
+	uint8_t c = uint8_t(rg());
+	size_t pos = rg() % maxTbl[c];
+	ret += wm.select(c, pos);
+}
+
+template<class T, class Vec8, class RG>
+void bench_select(const T& wm, const Vec8& v, RG& rg)
+{
+	size_t ret = 0;
+	std::vector<int> maxTbl;
+	maxTbl.resize(256);
+	for (int i = 0; i < 256; i++) {
+		maxTbl[i] = (int)wm.size(i) + 1;
+	}
+	printf("select");
+	CYBOZU_BENCH("", oneSelect, ret, wm, rg, maxTbl);
+	printf(" ret=%u\n", (int)ret);
+	Naive nv(v);
+/*
+	over pos=67108805, i=1024, v=58
+over pos=67108841, i=1026, v=35
+*/
+	const struct {
+		uint8_t v;
+		uint64_t pos;
+	} tbl[] = {
+		{ 58, 1024 },
+		{ 35, 1026 },
+	};
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		uint8_t c = tbl[i].v;
+		uint64_t pos = tbl[i].pos;
+		uint64_t a = nv.select(c, pos);
+		uint64_t b = wm.select(c, pos);
+		if (a != b) {
+			printf("ERR c=%d, pos=%d, a=%d, b=%d\n", (int)c, (int)pos, (int)a, (int)b);
+			exit(1);
+		}
+	}
+	puts("select ok");
+}
+
+template<class Vec8>
+void bench(const cybozu::WaveletMatrix& wm, const Vec8& v, size_t N)
+{
+	cybozu::XorShift rg;
+	puts("wm");
+	bench_get(wm, rg, N);
+	bench_rank(wm, rg, N);
+	bench_rankLt(wm, rg, N);
+	bench_select(wm, v, rg);
+#if 0
+	bench_get(nv, "nv", 1000000, N);
+	bench_rank(nv, "nv", 10, N);
+	bench_rank_lt(nv, "nv", 10, N);
+	bench_select(nv, "nv", 10);
+#endif
+}
+
+void run(size_t bitLen)
+{
+	cybozu::XorShift rg;
+	cybozu::WaveletMatrix wm;
+	const size_t N = size_t(1) << bitLen;
+	printf("%09llx\n", (long long)N);
+	puts("init");
+	std::vector<uint8_t> v;
+	v.resize(N);
+	for (size_t i = 0; i < N; i++) {
+		v[i] = uint8_t(rg());
+	}
+#if 0
+	printf("v\n");
+	for (size_t i = 0; i < N; i++) {
+		printf("%d ", v[i]);
+	}
+	printf("\n");
+#endif
+	wm.init(v, 8);
+	puts("start");
+	bench(wm, v, N);
+}
+
+int main(int argc, char *argv[])
+	try
+{
+	size_t bitLen = 26;
+	argc--, argv++;
+	while (argc > 0) {
+		if (argc > 1 && strcmp(*argv, "-b") == 0) {
+			argc--, argv++;
+			bitLen = atoi(*argv);
+		} else
+		{
+			printf("usage wm_bench_smpl.exe [-b bitLen]\n");
+			return 1;
+		}
+		argc--, argv++;
+	}
+	run(bitLen);
+} catch (std::exception& e) {
+	printf("err %s\n", e.what());
+}

data/vendor/cybozulib/sample/zlib_smpl.cpp

@@ -0,0 +1,41 @@
+#include <cybozu/zlib.hpp>
+#include <cybozu/option.hpp>
+#include <cybozu/mmap.hpp>
+#include <fstream>
+
+int main(int argc, char *argv[])
+	try
+{
+	bool doUncomp = false;
+	std::string inFile;
+	std::string outFile;
+	cybozu::Option opt;
+	opt.appendBoolOpt(&doUncomp, "d", ": uncompress");
+	opt.appendParam(&inFile, "input file");
+	opt.appendParam(&outFile, "output file");
+	opt.appendHelp("h", ": show thismessage");
+	if (!opt.parse(argc, argv)) {
+		opt.usage();
+		return 0;
+	}
+	cybozu::Mmap f(inFile);
+	std::string out;
+	if (doUncomp) {
+		out.resize(f.size() * 10);
+		size_t size = cybozu::ZlibUncompress(&out[0], out.size(), f.get(), f.size());
+		out.resize(size);
+	} else {
+		out.resize(f.size());
+		size_t size = cybozu::ZlibCompress(&out[0], out.size(), f.get(), f.size());
+		if (size == 0) {
+			fprintf(stderr, "not compress\n");
+			return 1;
+		}
+		out.resize(size);
+	}
+	std::ofstream ofs(outFile.c_str(), std::ios::binary);
+	ofs.write(out.data(), out.size());
+} catch (std::exception& e) {
+	fprintf(stderr, "ERR %s\n", e.what());
+	return 1;
+}

data/vendor/cybozulib/src/Makefile

@@ -0,0 +1,8 @@
+
+all:
+	$(MAKE) -C base
+
+clean:
+	$(MAKE) -C base clean
+
+

data/vendor/cybozulib/src/base/Makefile

@@ -0,0 +1,19 @@
+include ../../common.mk
+
+#TARGET=../../lib/libcybozu_base$(OBJSUF).a
+TARGET=
+SRC=
+
+all: $(TARGET)
+
+$(TARGET): $(OBJS)
+	$(AR) $@ $(OBJS)
+
+$(OBJDIR):
+	@$(MKDIR) $(OBJDIR)
+
+clean:
+	$(CLEAN)
+
+-include $(DEPEND_FILE)
+

data/vendor/cybozulib/test/Makefile

@@ -0,0 +1,12 @@
+
+all:
+	$(MAKE) -C base
+	$(MAKE) -C nlp
+
+test:
+	$(MAKE) -C base test
+	$(MAKE) -C nlp test
+clean:
+	$(MAKE) -C base clean
+	$(MAKE) -C nlp clean
+

data/vendor/cybozulib/test/base/Makefile

@@ -0,0 +1,37 @@
+include ../../common.mk
+
+TARGET=$(TEST_FILE)
+#LIBS=$(TOPDIR)lib/libcybozu_base$(OBJSUF).a
+LIBS=
+
+SRC=$(wildcard *.cpp)
+ifneq ($(HAS_BOOST),1)
+	SRC:=$(filter-out regex_test.cpp,$(SRC))
+endif
+#ifneq ($(HAS_MECAB),1)
+	SRC:=$(filter-out mecab_test.cpp,$(SRC))
+#endif
+ifeq ($(TRAVIS_TEST),1)
+	SRC:=$(filter-out env_test.cpp,$(SRC))
+	SRC:=$(filter-out fmindex_test.cpp,$(SRC))
+	SRC:=$(filter-out mmap_test.cpp,$(SRC))
+	SRC:=$(filter-out minixml_test.cpp,$(SRC))
+	SRC:=$(filter-out zlib_test.cpp,$(SRC))
+endif
+
+all: $(TARGET)
+
+test: $(TARGET)
+	@$(UNIT_TEST)
+
+$(OBJDIR):
+	@$(MKDIR) $(OBJDIR)
+
+clean:
+	$(CLEAN)
+
+$(LIBS):
+	$(MAKE) -C ../../src
+
+-include $(DEPEND_FILE)
+

data/vendor/cybozulib/test/base/array_test.cpp

@@ -0,0 +1,173 @@
+/*
+	debug for AlignedAlloc with doClear = false
+*/
+#include <cybozu/array.hpp>
+#include <cybozu/test.hpp>
+
+int a_count = 0;
+int b_count = 0;
+
+struct A {
+	int n;
+	A()
+		: n(a_count)
+	{
+		a_count++;
+	}
+	~A()
+	{
+		a_count--;
+	}
+};
+
+struct B {
+	std::string x;
+	B()
+	{
+		if (b_count == 3) throw std::bad_exception();
+		b_count++;
+		x = "dummy";
+	}
+	~B()
+	{
+		b_count--;
+	}
+};
+
+CYBOZU_TEST_AUTO(scoped_array)
+{
+	{
+		cybozu::ScopedArray<A> a(10);
+		CYBOZU_TEST_EQUAL(a_count, 10);
+		for (int i = 0; i < 10; i++) {
+			CYBOZU_TEST_EQUAL(a[i].n, i);
+			CYBOZU_TEST_EQUAL(a.data()[i].n, i);
+		}
+	}
+	CYBOZU_TEST_EQUAL(a_count, 0);
+}
+
+bool isAligned(const void *p, size_t alignSize)
+{
+	return (uintptr_t(p) & (alignSize - 1)) == 0;
+}
+
+CYBOZU_TEST_AUTO(aligned_array)
+{
+	cybozu::AlignedArray<int> a(10);
+	CYBOZU_TEST_EQUAL(a.size(), 10);
+	CYBOZU_TEST_ASSERT(isAligned(&a[0], 16));
+	for (int i = 0; i < 10; i++) {
+		CYBOZU_TEST_EQUAL(a[i], 0);
+		CYBOZU_TEST_EQUAL(a.data()[i], 0);
+	}
+}
+
+CYBOZU_TEST_AUTO(aligned_array_char)
+{
+	cybozu::AlignedArray<char> a(51);
+	CYBOZU_TEST_ASSERT(isAligned(&a[0], 16));
+	for (size_t i = 0; i < a.size(); i++) {
+		CYBOZU_TEST_EQUAL(a[i], 0);
+	}
+}
+
+CYBOZU_TEST_AUTO(resize)
+{
+	cybozu::AlignedArray<char> a(10);
+	CYBOZU_TEST_EQUAL(a.size(), 10);
+	CYBOZU_TEST_ASSERT(isAligned(&a[0], 16));
+	for (size_t i = 0; i < 10; i++) {
+		a[i] = (char)i;
+	}
+	a.resize(20);
+	CYBOZU_TEST_EQUAL(a.size(), 20);
+	CYBOZU_TEST_ASSERT(isAligned(&a[0], 16));
+	for (size_t i = 0; i < 10; i++) {
+		CYBOZU_TEST_EQUAL(a[i], (char)i);
+	}
+	for (size_t i = 10; i < 20; i++) {
+		CYBOZU_TEST_EQUAL(a[i], (char)0);
+	}
+	const char *p = &a[0];
+	a.resize(4);
+	CYBOZU_TEST_EQUAL(a.size(), 4);
+	CYBOZU_TEST_EQUAL(&a[0], p);
+	for (size_t i = 0; i < 4; i++) {
+		CYBOZU_TEST_EQUAL(a[i], (char)i);
+	}
+	CYBOZU_TEST_ASSERT(!a.empty());
+	a.resize(0);
+	CYBOZU_TEST_EQUAL(a.size(), 0);
+	CYBOZU_TEST_ASSERT(a.empty());
+	a.resize(20);
+	CYBOZU_TEST_EQUAL(a.size(), 20);
+	CYBOZU_TEST_EQUAL(&a[0], p); // same pointer until resize(20)
+	a.resize(21);
+	CYBOZU_TEST_EQUAL(a.size(), 21);
+	CYBOZU_TEST_ASSERT(&a[0] != p); // different pointer
+}
+
+CYBOZU_TEST_AUTO(AlignedArray_copy)
+{
+	cybozu::AlignedArray<int> x, z, y;
+	x.resize(10);
+	for (size_t i = 0; i < x.size(); i++) x[i] = (int)i;
+	y.resize(5);
+
+	y = x;
+	z = x;
+	cybozu::AlignedArray<int> w(x);
+	CYBOZU_TEST_EQUAL_ARRAY(x.data(), y.data(), x.size());
+	CYBOZU_TEST_EQUAL_ARRAY(x.data(), z.data(), x.size());
+	CYBOZU_TEST_EQUAL_ARRAY(x.data(), w.data(), x.size());
+
+	w.resize(25);
+	for (size_t i = 0; i < w.size(); i++) w[i] = (int)i + 123;
+	w = x;
+	CYBOZU_TEST_EQUAL_ARRAY(x.data(), w.data(), x.size());
+}
+
+#if (CYBOZU_CPP_VERSION == CYBOZU_CPP_VERSION_CPP11)
+CYBOZU_TEST_AUTO(AlignedArray_move)
+{
+	cybozu::AlignedArray<long> x, y;
+	x.resize(10);
+	y.resize(5);
+	const long* px = x.data();
+	const long* py = y.data();
+	CYBOZU_TEST_EQUAL(x.size(), 10);
+	CYBOZU_TEST_EQUAL(y.size(), 5);
+	for (size_t i = 0; i < x.size(); i++) {
+		x[i] = (long)i;
+	}
+	for (size_t i = 0; i < y.size(); i++) {
+		y[i] = (long)i + 10;
+	}
+	for (size_t i = 0; i < x.size(); i++) {
+		CYBOZU_TEST_EQUAL(x[i], (long)i);
+	}
+	for (size_t i = 0; i < y.size(); i++) {
+		CYBOZU_TEST_EQUAL(y[i], 10 + (long)i);
+	}
+	cybozu::AlignedArray<long> z(std::move(x));
+	const long* pz = &z[0];
+	CYBOZU_TEST_EQUAL(pz, px);
+	CYBOZU_TEST_EQUAL(x.data(), (long*)0);
+	CYBOZU_TEST_EQUAL(z.data(), px);
+	CYBOZU_TEST_EQUAL(z.size(), 10);
+	for (size_t i = 0; i < 10; i++) {
+		CYBOZU_TEST_EQUAL(z[i], (long)i);
+	}
+	CYBOZU_TEST_EQUAL(x.size(), 0);
+
+	z = std::move(y);
+	CYBOZU_TEST_EQUAL(py, &z[0]);
+	CYBOZU_TEST_EQUAL(py, z.data());
+	CYBOZU_TEST_EQUAL(y.size(), 0);
+	CYBOZU_TEST_EQUAL(z.size(), 5);
+	for (size_t i = 0; i < 5; i++) {
+		CYBOZU_TEST_EQUAL(z[i], 10 + (long)i);
+	}
+}
+#endif