ooxml_crypt 0.1.0

data/vendor/cybozulib/sample/serializer_smpl.cpp

@@ -0,0 +1,196 @@
+/*
+	how to serialize user data
+*/
+#include <stdio.h>
+#include <cybozu/file.hpp>
+#include <cybozu/serializer.hpp>
+#include <cybozu/mmap.hpp>
+#include <fstream>
+#include <map>
+#include <set>
+#include <string>
+#include <cybozu/string.hpp>
+
+struct Data {
+	typedef std::map<std::string, double> Str2Double;
+	typedef std::set<int> IntSet;
+	typedef std::vector<float> FloatVec;
+	typedef std::vector<cybozu::String> StrVec;
+	Str2Double sd_;
+	IntSet is_;
+	FloatVec fv_;
+	StrVec sv_;
+	bool operator==(const Data& rhs) const
+	{
+		return sd_ == rhs.sd_ && is_ == rhs.is_ && fv_ == rhs.fv_ && sv_ == rhs.sv_;
+	}
+	/*
+		define load and save function
+	*/
+	template<class InputStream>
+	void load(InputStream& is)
+	{
+		cybozu::load(sd_, is);
+		cybozu::load(is_, is);
+		cybozu::load(fv_, is);
+		cybozu::load(sv_, is);
+	}
+	template<class OutputStream>
+	void save(OutputStream& os) const
+	{
+		cybozu::save(os, sd_);
+		cybozu::save(os, is_);
+		cybozu::save(os, fv_);
+		cybozu::save(os, sv_);
+	}
+};
+
+struct Data2 {
+	Data d;
+	int a;
+	bool operator==(const Data2& rhs) const
+	{
+		return d == rhs.d && a == rhs.a;
+	}
+	template<class InputStream>
+	void load(InputStream& is)
+	{
+		cybozu::load(d, is);
+		cybozu::load(a, is);
+	}
+	template<class OutputStream>
+	void save(OutputStream& os) const
+	{
+		cybozu::save(os, d);
+		cybozu::save(os, a);
+	}
+};
+
+/*
+	how to make InputStream
+	InputStream must have size_t readSome(void *, size_t)
+	return read size
+*/
+struct VecInputStream {
+	std::vector<char> data;
+	size_t pos;
+	VecInputStream() : pos(0) {}
+
+	size_t readSome(void *buf, size_t size)
+	{
+		size_t readSize = std::min(size, data.size() - pos);
+		memcpy(buf, &data[pos], readSize);
+		pos += readSize;
+		return readSize;
+	}
+};
+
+/*
+	how to make OutputStream
+	OutputStream must have void write(const void *, size_t)
+*/
+struct VecOutputStream {
+	std::vector<char> data;
+	void write(const void *buf, size_t size)
+	{
+		data.insert(data.end(), (const char*)buf, (const char*)buf + size);
+	}
+};
+
+/*
+	VecInputStream2 does not have readSome() then
+	specialize cybozu::InputStreamTag<VecInputStream2>
+*/
+struct VecInputStream2 {
+	std::vector<char> data;
+	size_t pos;
+	VecInputStream2() : pos(0) {}
+
+	size_t readSome(void *buf, size_t size)
+	{
+		size_t readSize = std::min(size, data.size() - pos);
+		memcpy(buf, &data[pos], readSize);
+		pos += readSize;
+		return readSize;
+	}
+};
+
+namespace cybozu {
+template<>
+struct InputStreamTag<VecInputStream2>
+{
+	static size_t readSome(void *buf, size_t size, VecInputStream2& is)
+	{
+		return is.readSome(buf, size);
+	}
+};
+} // cybozu
+
+int main()
+{
+	const char *file = "test.data";
+	Data x;
+	x.sd_["abc"] = 9.3;
+	x.sd_["999"] = -123459.3;
+	x.sd_["AAAA"] = 7;
+	x.is_.insert(5);
+	x.is_.insert(55);
+	x.is_.insert(555);
+	x.is_.insert(5555);
+	x.fv_.push_back(9.2);
+	x.fv_.push_back(-0.1);
+	x.sv_.push_back("aiueo");
+	x.sv_.push_back("xxx");
+	x.sv_.push_back("doremi");
+
+	// save data by std::ofstream
+	{
+		std::ofstream os(file, std::ios::binary);
+		cybozu::save(os, x);
+	}
+	// load data from std::ifstream
+	{
+		std::ifstream is(file, std::ios::binary);
+
+		Data y;
+		cybozu::load(y, is);
+		puts(x == y ? "ok" : "ng");
+	}
+	Data2 x2;
+	x2.d = x;
+	x2.d.sd_["aaaaa"] = 1.2;
+	x2.a = 98765432;
+	// save data by cybozu::File
+	{
+		cybozu::File os(file, std::ios::out);
+		cybozu::save(os, x2);
+	}
+	// load data from cybozu::Mmap
+	{
+		cybozu::Mmap m(file);
+		cybozu::MemoryInputStream is(m.get(), m.size());
+
+		Data2 y2;
+		cybozu::load(y2, is);
+		puts(x2 == y2 ? "ok" : "ng");
+	}
+	// how to use VecInputStream and VecOutputStream
+	{
+		VecOutputStream os;
+		cybozu::save(os, x2);
+		{
+			VecInputStream is;
+			is.data = os.data;
+			Data2 y2;
+			cybozu::load(y2, is);
+			puts(x2 == y2 ? "ok" : "ng");
+		}
+		{
+			VecInputStream2 is;
+			is.data = os.data;
+			Data2 y2;
+			cybozu::load(y2, is);
+			puts(x2 == y2 ? "ok" : "ng");
+		}
+	}
+}

data/vendor/cybozulib/sample/socket_smpl.cpp

@@ -0,0 +1,82 @@
+/*
+	cf. ping6 -I eth0 <IPv6 addr>
+	Linux : <IPv6>%eth0
+	Windows : <IPv6>%<number>
+*/
+#include <cybozu/option.hpp>
+#include <cybozu/socket.hpp>
+
+int main(int argc, char *argv[])
+	try
+{
+	std::string ip;
+	uint16_t port;
+	std::string cmd;
+	bool verbose = false;
+	int mode = 0;
+	int timeoutSec = 0;
+
+	cybozu::Option opt;
+	opt.appendOpt(&ip, "", "ip", ": ip address");
+	opt.appendBoolOpt(&verbose, "v", ": verbose");
+	opt.appendOpt(&mode, 0, "m", ": mode = 4(v4only), 6(v6only), 0(both)");
+	opt.appendOpt(&port, uint16_t(50000), "p", ": port");
+	opt.appendOpt(&timeoutSec, 5, "t", ": timeout(sec)");
+	opt.appendParamOpt(&cmd, "cmd", ":string to send");
+	switch (mode) {
+	case 0:
+		mode = cybozu::Socket::allowIPv4 | cybozu::Socket::allowIPv6;
+		break;
+	case 4:
+		mode = cybozu::Socket::allowIPv4;
+		break;
+	case 6:
+		mode = cybozu::Socket::allowIPv6;
+		break;
+	default:
+		printf("bad mode=%d\n", mode);
+		return 1;
+	}
+
+	if (!opt.parse(argc, argv)) {
+		opt.usage();
+		return 1;
+	}
+	if (verbose) opt.put();
+	const int timeoutMsec = timeoutSec * 1000;
+	if (ip.empty()) {
+		printf("server port=%d\n", port);
+		cybozu::Socket server;
+		server.bind(port, mode);
+		for (;;) {
+			while (!server.queryAccept()) {
+			}
+			cybozu::Socket client;
+			if (verbose) {
+				cybozu::SocketAddr addr;
+				server.accept(client, &addr);
+				printf("addr=%s, port=%d\n", addr.toStr().c_str(), addr.getPort());
+			} else {
+				server.accept(client);
+			}
+			client.setSendTimeout(timeoutMsec);
+			client.setReceiveTimeout(timeoutMsec);
+			{
+				char buf[128];
+				size_t readSize = client.readSome(buf, sizeof(buf));
+				printf("rec=%s(%d)\n", std::string(buf, readSize).c_str(), (int)readSize);
+			}
+		}
+	} else {
+		printf("client ip=%s port=%d\n", ip.c_str(), port);
+		cybozu::SocketAddr sa(ip, port);
+		printf("addr=%s\n", sa.toStr().c_str());
+		cybozu::Socket client;
+		client.connect(sa, timeoutMsec);
+		client.setSendTimeout(timeoutMsec);
+		client.setReceiveTimeout(timeoutMsec);
+		client.write(cmd.c_str(), cmd.size());
+	}
+} catch (std::exception& e) {
+	printf("ERR %s\n", e.what());
+}

data/vendor/cybozulib/sample/ssl_smpl.cpp

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <string>
+#include <cybozu/ssl.hpp>
+
+int main(int argc, char *argv[])
+{
+	try {
+		argc--, argv++;
+		if (argc < 2) {
+			fprintf(stderr, "ssl_smpl host dir\n");
+			fprintf(stderr, " ex ssl_smpl www.cybozu.com /\n");
+			return 1;
+		}
+		const std::string host = argv[0];
+		const std::string path = argv[1];
+		cybozu::ssl::ClientSocket s;
+		printf("connect %s\n", host.c_str());
+		s.connect(host, 443);
+		const std::string http = "GET " + path + " HTTP/1.0\r\n\r\n";
+		printf("cmd=%s\n", http.c_str());
+		s.write(http.c_str(), http.size());
+		puts("write end");
+		ssize_t total = 0;
+		for (;;) {
+			char buf[1024];
+			size_t readSize = s.readSome(buf, sizeof(buf));
+			if (readSize == 0) {
+				break;
+			}
+			total += readSize;
+			printf("%s", std::string(buf, readSize).c_str());
+		}
+		printf("\ntotal=%d\n", (int)total);
+	} catch (cybozu::Exception& e) {
+		printf("err=%s\n", e.what());
+		return 1;
+	}
+}
+

data/vendor/cybozulib/sample/stacktrace_smpl.cpp

@@ -0,0 +1,52 @@
+/*
+	sample how to use stacktrace
+	g++ -I ../include/ stacktrace_smpl.cpp -g -rdynamic && ./a.out
+*/
+#include <stdio.h>
+#include <iostream>
+#define CYBOZU_EXCEPTION_WITH_STACKTRACE
+#include <cybozu/exception.hpp>
+
+void putStackTrace()
+{
+	throw cybozu::Exception("throw test");
+}
+
+struct A {
+	void f() {
+		putStackTrace();
+	}
+};
+
+struct B {
+	A a;
+	void g() {
+		a.f();
+	}
+};
+
+void func()
+{
+	puts("func");
+	B b;
+	b.g();
+}
+
+void g()
+{
+	func();
+}
+
+void h()
+{
+	g();
+}
+
+int main()
+	try
+{
+	h();
+} catch (std::exception& e) {
+	printf("e=%s\n", e.what());
+}
+

data/vendor/cybozulib/sample/svd_bench_smpl.cpp

@@ -0,0 +1,143 @@
+//#define USE_REDSVD
+#ifdef USE_REDSVD
+#include <../redsvd-read-only/src/redsvd.hpp>
+#endif
+#include <iostream>
+#include <stdio.h>
+#include <math.h>
+#include <cybozu/inttype.hpp>
+#define CYBOZU_NLP_SVD_USE_RANDOM
+#include <cybozu/nlp/svd.hpp>
+#include <cybozu/time.hpp>
+
+template<class Matrix>
+void SetUnitary(Matrix& m)
+{
+	cybozu::nlp::svd::InitRandomMatrix(m);
+	cybozu::nlp::svd::OrthonormalizeMatrix(m);
+}
+
+double getTime()
+{
+	cybozu::Time t;
+	t.setCurrentTime();
+	return t.getTime() + t.getMsec() * 1e-3;
+}
+
+template<class Matrix, class Vector>
+void test(int row, int col, int rank, int tryRank, bool isFull)
+{
+	printf("(%5d, %5d, %5d, %3d, %c) ", row, col, rank, tryRank, isFull ? 'F' : '-');
+	typedef typename Matrix::Scalar Double;
+	int s_rank = isFull ? std::min(row, col) : rank;
+	Matrix U(row, s_rank);
+	Vector S(s_rank);
+	Matrix V(col, s_rank);
+	SetUnitary(U);
+	SetUnitary(V);
+	S.setZero();
+	for (int i = 0; i < rank; i++) {
+		S(i) = (Double)((s_rank - i) * 0.5);
+	}
+	if (isFull) {
+		for (int i = rank; i < s_rank; i++) {
+			S(i) = (Double)(0.04 * (s_rank - i));
+		}
+	}
+	Matrix A = U * S.asDiagonal() * V.transpose();
+	Matrix UO, VO;
+	Vector SO;
+	{
+#ifdef USE_REDSVD
+		double b = getTime();
+		REDSVD::RedSVD redsvd;
+		redsvd.run(A, tryRank);
+		double e = getTime();
+		printf("%6.1fmsec ", (e - b) * 1e3);
+		UO = redsvd.matrixU();
+		SO = redsvd.singularValues();
+		VO = redsvd.matrixV();
+#else
+		double b = getTime();
+		cybozu::nlp::ComputeSVD(UO, SO, VO, A, tryRank);
+		double e = getTime();
+		printf("%6.1fmsec ", (e - b) * 1e3);
+#endif
+	}
+#if 0
+	if (row * col <= 10000) {
+		double b = getTime();
+		Eigen::JacobiSVD<Matrix> svd(A, Eigen::ComputeThinU | Eigen::ComputeThinV);
+		double e = getTime();
+		printf("%.2fmsec ", (e - b) * 1e3);
+	} else {
+		printf("---msec ");
+	}
+#endif
+
+	double diff = 0;
+	for (int i = 0; i < tryRank; ++i) {
+		double v = fabs(S(i) - SO(i));
+		if (S(i) > 0) {
+			v /= S(i);
+		}
+		diff += v;
+	}
+	diff /= tryRank;
+	printf("%6.2f %6.2f %7.4f ", S(0), S(rank - 1), diff);
+	printf("%f ", (A - UO * SO.asDiagonal() * VO.transpose()).norm());
+	int nearNum = 0;
+	int orthNum = 0;
+	for (int i = 0; i < tryRank; i++) {
+		double u = fabs(U.col(i).dot(UO.col(i)));
+		if (u > 0.85) nearNum++;
+		if (u < 0.1) orthNum++;
+	}
+	printf("%d %d", nearNum, orthNum);
+	printf("\n");
+}
+
+int main()
+{
+	const struct {
+		int row;
+		int col;
+		int rank;
+		int tryRank;
+	} tbl[] = {
+		{ 100, 100, 10, 10 },
+		{ 100, 100, 10, 9 },
+		{ 100, 100, 10, 9 },
+		{ 100, 100, 10, 8 },
+		{ 100, 100, 10, 8 },
+		{ 100, 100, 50, 50 },
+		{ 100, 100, 50, 50 },
+		{ 100, 100, 50, 49 },
+		{ 100, 100, 50, 48 },
+		{ 100, 100, 50, 10 },
+		{ 300, 300, 50, 48 },
+		{ 300, 300, 50, 48 },
+		{ 600, 600, 100, 95 },
+		{ 600, 600, 100, 95 },
+		{ 1000, 1000, 10, 10 },
+		{ 1000, 1000, 10, 9 },
+		{ 1000, 1000, 10, 8 },
+		{ 1000, 1000, 20, 20 },
+		{ 1000, 1000, 20, 19 },
+		{ 1000, 1000, 20, 18 },
+		{ 1000, 1000, 100, 100 },
+		{ 1000, 1000, 100, 99 },
+		{ 1000, 1000, 100, 90 },
+		{ 10000, 10000, 100, 100 },
+		{ 10000, 10000, 100, 91 },
+		{ 10000, 10000, 300, 100 },
+		{ 10000, 10000, 1000, 100 },
+	};
+	printf("(  row,   col,  rank,   r, f)       msec eigen-max min  diff\n");
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		test<Eigen::MatrixXd, Eigen::VectorXd>(tbl[i].row, tbl[i].col, tbl[i].rank, tbl[i].tryRank, false);
+		if (tbl[i].row <= 1000) {
+			test<Eigen::MatrixXd, Eigen::VectorXd>(tbl[i].row, tbl[i].col, tbl[i].rank, tbl[i].tryRank, true);
+		}
+	}
+}

data/vendor/cybozulib/sample/svd_smpl.cpp

@@ -0,0 +1,94 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <cybozu/nlp/svd.hpp>
+#include <cybozu/atoi.hpp>
+
+#define USE_DOUBLE
+
+void usage()
+{
+	fprintf(stderr, "svd_smpl.exe input [output] [-r rank]\n"
+		"  A = U S (V^T)\n"
+		"  input : input matrix A\n"
+		"  output: output basename.\n"
+		"          create output.[U, S, V]\n"
+		"          use input if not specified\n"
+		"  rank  : rank of S\n"
+		"matrix data format example\n"
+		"M = (1 0   3)\n"
+		"    (0 4.2 0)\n"
+		"(dense type)\n"
+		"# M D 2 3\n"
+		"1 0 3\n"
+		"0 4.2 0\n"
+		"\n"
+		"(sparse type)\n"
+		"# M S 2 3\n"
+		"0:1 2:3\n"
+		"1:4.2\n");
+	exit(1);
+}
+
+bool Run(const std::string& input, const std::string& output, int rank)
+{
+#ifdef USE_DOUBLE
+	Eigen::SparseMatrix<double, Eigen::RowMajor> SA;
+	Eigen::MatrixXd A;
+	Eigen::MatrixXd U;
+	Eigen::VectorXd S;
+	Eigen::MatrixXd V;
+#else
+	Eigen::SparseMatrix<float, Eigen::RowMajor> SA;
+	Eigen::MatrixXf A;
+	Eigen::MatrixXf U;
+	Eigen::VectorXf S;
+	Eigen::MatrixXf V;
+#endif
+	fprintf(stderr, "loading matrix %s\n", input.c_str());
+	if (cybozu::nlp::svd::LoadSparseMatrix(SA, input)) {
+		fprintf(stderr, "computing SVD\n");
+		cybozu::nlp::ComputeSVD(U, S, V, SA, rank);
+	} else if (cybozu::nlp::svd::LoadMatrix(A, input)) {
+		fprintf(stderr, "computing SVD\n");
+		cybozu::nlp::ComputeSVD(U, S, V, A, rank);
+	} else {
+		return false;
+	}
+	cybozu::nlp::svd::SaveMatrix(output + ".U", U);
+	cybozu::nlp::svd::SaveVector(output + ".S", S);
+	cybozu::nlp::svd::SaveMatrix(output + ".V", V);
+	return true;
+}
+
+int main(int argc, char *argv[])
+{
+	argc--, argv++;
+	std::string input;
+	std::string output;
+	int rank = 10;
+
+	while (argc > 0) {
+		if (argc > 1 && strcmp(*argv, "-r") == 0) {
+			argc--, argv++;
+			rank = cybozu::atoi(*argv);
+		} else
+		if (input.empty()) {
+			input = *argv;
+		} else
+		if (output.empty()) {
+			output = *argv;
+		} else
+		{
+			usage();
+		}
+		argc--, argv++;
+	}
+	if (input.empty()) {
+		usage();
+	}
+	if (output.empty()) {
+		output = input;
+	}
+	fprintf(stderr, "input=%s, output=%s, rank=%d\n", input.c_str(), output.c_str(), rank);
+	Run(input, output, rank);
+}