tomoto 0.1.0

data/vendor/tomotopy/src/Utils/AliasMethod.hpp

@@ -0,0 +1,169 @@
+#pragma once
+#include <memory>
+#include <iterator>
+#include <limits>
+
+namespace tomoto
+{
+	namespace sample
+	{
+		template<typename _Precision = uint32_t>
+		class AliasMethod
+		{
+			std::unique_ptr<_Precision[]> arr;
+			std::unique_ptr<size_t[]> alias;
+			size_t msize = 0, bitsize = 0;
+
+		public:
+			AliasMethod()
+			{
+			}
+
+			AliasMethod(const AliasMethod& o)
+			{
+				operator=(o);
+			}
+
+			AliasMethod(AliasMethod&& o)
+			{
+				operator=(o);
+			}
+
+			AliasMethod& operator=(const AliasMethod& o)
+			{
+				msize = o.msize;
+				bitsize = o.bitsize;
+				if (msize)
+				{
+					arr = make_unique<_Precision[]>(1 << bitsize);
+					alias = make_unique<size_t[]>(1 << bitsize);
+
+					std::copy(o.arr.get(), o.arr.get() + (1 << bitsize), arr.get());
+					std::copy(o.alias.get(), o.alias.get() + (1 << bitsize), alias.get());
+				}
+				return *this;
+			}
+
+			AliasMethod& operator=(AliasMethod&& o)
+			{
+				msize = o.msize;
+				bitsize = o.bitsize;
+				std::swap(arr, o.arr);
+				std::swap(alias, o.alias);
+				return *this;
+			}
+
+			template<typename _Iter>
+			AliasMethod(_Iter first, _Iter last)
+			{
+				buildTable(first, last);
+			}
+
+			template<typename _Iter>
+			void buildTable(_Iter first, _Iter last)
+			{
+				size_t psize, nbsize;
+				msize = 0;
+				double sum = 0;
+				for (auto it = first; it != last; ++it, ++msize)
+				{
+					sum += *it;
+				}
+
+				if (!std::isfinite(sum)) THROW_ERROR_WITH_INFO(exception::InvalidArgument, "cannot build NaN value distribution");
+
+				// ceil to power of 2
+				nbsize = log2_ceil(msize);
+				psize = (size_t)1 << nbsize;
+
+				if (nbsize != bitsize)
+				{
+					arr = make_unique<_Precision[]>(psize);
+					std::fill(arr.get(), arr.get() + psize, 0);
+					alias = make_unique<size_t[]>(psize);
+					bitsize = nbsize;
+				}
+				
+				sum /= psize;
+
+				auto f = make_unique<double[]>(psize);
+				auto pf = f.get();
+				for (auto it = first; it != last; ++it, ++pf)
+				{
+					*pf = *it / sum;
+				}
+				std::fill(pf, pf + psize - msize, 0);
+
+				size_t over = 0, under = 0, mm;
+				while (over < psize && f[over] < 1) ++over;
+				while (under < psize && f[under] >= 1) ++under;
+				mm = under + 1;
+
+				while (over < psize && under < psize)
+				{
+					arr[under] = f[under] * (std::numeric_limits<_Precision>::max() + 1.0);
+					alias[under] = over;
+					f[over] += f[under] - 1;
+					if (f[over] >= 1 || mm <= over)
+					{
+						for (under = mm; under < psize && f[under] >= 1; ++under);
+						mm = under + 1;
+					}
+					else
+					{
+						under = over;
+					}
+
+					while (over < psize && f[over] < 1) ++over;
+				}
+
+				for (; over < psize; ++over)
+				{
+					if (f[over] >= 1)
+					{
+						arr[over] = std::numeric_limits<_Precision>::max();
+						alias[over] = over;
+					}
+				}
+
+				if (under < psize)
+				{
+					arr[under] = std::numeric_limits<_Precision>::max();
+					alias[under] = under;
+					for (under = mm; under < msize; ++under)
+					{
+						if (f[under] < 1)
+						{
+							arr[under] = std::numeric_limits<_Precision>::max();
+							alias[under] = under;
+						}
+					}
+				}
+			}
+
+			template<typename _Rng>
+			size_t operator()(_Rng& rng) const
+			{
+				auto x = rng();
+				size_t a;
+				if (sizeof(_Precision) < sizeof(typename _Rng::result_type))
+				{
+					a = x >> (sizeof(x) * 8 - bitsize);
+				}
+				else
+				{
+					a = rng() & ((1 << bitsize) - 1);
+				}
+				
+				_Precision b = (_Precision)x;
+				if (b < arr[a])
+				{
+					assert(a < msize);
+					return a;
+				}
+				assert(alias[a] < msize);
+				return alias[a];
+			}
+		};
+	}
+}

data/vendor/tomotopy/src/Utils/Dictionary.h

@@ -0,0 +1,80 @@
+#pragma once
+#include <random>
+#include <exception>
+#include <unordered_map>
+#include <vector>
+#include <iostream>
+#include <sstream>
+#include <cassert>
+#include "serializer.hpp"
+
+namespace tomoto
+{
+	using Vid = uint32_t;
+	using Tid = uint16_t;
+	using Float = float;
+
+	class Dictionary
+	{
+	protected:
+		std::unordered_map<std::string, Vid> dict;
+		std::vector<std::string> id2word;
+	public:
+		Vid add(const std::string& word)
+		{
+			auto it = dict.find(word);
+			if (it == dict.end())
+			{
+				dict.emplace(std::make_pair(word, dict.size()));
+				id2word.emplace_back(word);
+				return (Vid)(dict.size() - 1);
+			}
+			return it->second;
+		}
+
+		size_t size() const { return dict.size(); }
+		
+		std::string toWord(Vid vid) const
+		{
+			assert(vid < id2word.size());
+			return id2word[vid];
+		}
+		
+		Vid toWid(const std::string& word) const
+		{
+			auto it = dict.find(word);
+			if (it == dict.end()) return (Vid)-1;
+			return it->second;
+		}
+
+		void serializerWrite(std::ostream& writer) const
+		{
+			serializer::writeMany(writer, serializer::to_key("Dict"), id2word);
+		}
+		
+		void serializerRead(std::istream& reader)
+		{
+			serializer::readMany(reader, serializer::to_key("Dict"), id2word);
+			for (size_t i = 0; i < id2word.size(); ++i)
+			{
+				dict.emplace(id2word[i], i);
+			}
+		}
+
+		void swap(Dictionary& rhs)
+		{
+			std::swap(dict, rhs.dict);
+			std::swap(id2word, rhs.id2word);
+		}
+
+		void reorder(const std::vector<Vid>& order)
+		{
+			for (auto& p : dict)
+			{
+				p.second = order[p.second];
+				id2word[p.second] = p.first;
+			}
+		}
+	};
+
+}

data/vendor/tomotopy/src/Utils/EigenAddonOps.hpp

@@ -0,0 +1,181 @@
+#pragma once
+#include <type_traits>
+#include <Eigen/Dense>
+#include "math.h"
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<typename PacketType>
+		struct to_int_packet
+		{
+			typedef PacketType type;
+		};
+	}
+}
+
+#ifdef EIGEN_VECTORIZE_AVX
+#include <immintrin.h>
+#include "avx_gamma.h"
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<> struct to_int_packet<Packet8f>
+		{
+			typedef Packet8i type;
+		};
+
+		EIGEN_STRONG_INLINE Packet8f p_to_f32(const Packet8i& a)
+		{
+			return _mm256_cvtepi32_ps(a);
+		}
+
+	}
+}
+
+#elif defined(EIGEN_VECTORIZE_SSE2)
+#include <xmmintrin.h>
+#include "sse_gamma.h"
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<> struct to_int_packet<Packet4f>
+		{
+			typedef Packet4i type;
+		};
+
+		EIGEN_STRONG_INLINE Packet4f p_to_f32(const Packet4i& a)
+		{
+			return _mm_cvtepi32_ps(a);
+		}
+
+	}
+}
+#endif
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<typename Scalar, typename Scalar2> struct scalar_lgamma_subt_op {
+			EIGEN_EMPTY_STRUCT_CTOR(scalar_lgamma_subt_op)
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& z, const Scalar2& a) const { return tomoto::math::lgammaSubt(z, a); }
+			template<typename Packet>
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const Packet& z, const Packet& a) const
+			{
+				return lgamma_subt(z, a);
+			}
+		};
+
+		template<typename Scalar, typename Scalar2>
+		struct functor_traits<scalar_lgamma_subt_op<Scalar, Scalar2> >
+		{
+			enum {
+				Cost = HugeCost,
+				PacketAccess = 1
+			};
+		};
+
+		template<>
+		struct scalar_cast_op<int32_t, float> {
+			EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
+				typedef float result_type;
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const float operator() (const int32_t& a) const { return cast<int32_t, float>(a); }
+			
+			template<typename Packet>
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(const typename to_int_packet<typename std::remove_const<Packet>::type>::type& a) const
+			{
+				return p_to_f32(a);
+			}
+		};
+
+		template<>
+		struct functor_traits<scalar_cast_op<int32_t, float> >
+		{
+			enum { Cost = NumTraits<float>::AddCost, PacketAccess = 1 };
+		};
+
+		template<typename ArgType>
+		struct unary_evaluator<CwiseUnaryOp<scalar_cast_op<int32_t, float>, ArgType>, IndexBased >
+			: evaluator_base<CwiseUnaryOp<scalar_cast_op<int32_t, float>, ArgType> >
+		{
+			typedef CwiseUnaryOp<scalar_cast_op<int32_t, float>, ArgType> XprType;
+
+			enum {
+				CoeffReadCost = evaluator<ArgType>::CoeffReadCost + functor_traits<scalar_cast_op<int32_t, float>>::Cost,
+
+				Flags = evaluator<ArgType>::Flags
+				& (HereditaryBits | LinearAccessBit | (functor_traits<scalar_cast_op<int32_t, float>>::PacketAccess ? PacketAccessBit : 0)),
+				Alignment = evaluator<ArgType>::Alignment
+			};
+
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+				explicit unary_evaluator(const XprType& op)
+				: m_functor(op.functor()),
+				m_argImpl(op.nestedExpression())
+			{
+				EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<float>::AddCost);
+				EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
+			}
+
+			typedef typename XprType::CoeffReturnType CoeffReturnType;
+
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+				CoeffReturnType coeff(Index row, Index col) const
+			{
+				return m_functor(m_argImpl.coeff(row, col));
+			}
+
+			EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
+				CoeffReturnType coeff(Index index) const
+			{
+				return m_functor(m_argImpl.coeff(index));
+			}
+
+			template<int LoadMode, typename PacketType>
+			EIGEN_STRONG_INLINE
+				PacketType packet(Index row, Index col) const
+			{
+				return m_functor.packetOp<PacketType>(m_argImpl.template packet<LoadMode, typename to_int_packet<PacketType>::type>(row, col));
+			}
+
+			template<int LoadMode, typename PacketType>
+			EIGEN_STRONG_INLINE
+				PacketType packet(Index index) const
+			{
+				return m_functor.packetOp<PacketType>(m_argImpl.template packet<LoadMode, typename to_int_packet<PacketType>::type>(index));
+			}
+
+		protected:
+			const scalar_cast_op<int32_t, float> m_functor;
+			evaluator<ArgType> m_argImpl;
+		};
+
+	}
+
+	template <typename Derived, typename T> EIGEN_DEVICE_FUNC inline 
+		const CwiseBinaryOp<internal::scalar_lgamma_subt_op< typename internal::traits<Derived>::Scalar, T >, const Derived,
+		const typename internal::plain_constant_type<Derived, T>::type>
+		lgamma_subt(const Eigen::ArrayBase<Derived>& x, const T& scalar)  {
+		
+		return CwiseBinaryOp<internal::scalar_lgamma_subt_op< typename internal::traits<Derived>::Scalar, T >, const Derived,
+			const typename internal::plain_constant_type<Derived, T>::type>(x.derived(), 
+				typename internal::plain_constant_type<Derived, T>::type(x.derived().rows(), x.derived().cols(), internal::scalar_constant_op<T>(scalar))
+			);
+	}
+
+	template<typename Derived, typename Derived2>
+	inline const CwiseBinaryOp<internal::scalar_lgamma_subt_op<typename Derived::Scalar, typename Derived2::Scalar>, const Derived, const Derived2>
+		lgamma_subt(const Eigen::ArrayBase<Derived>& x, const Eigen::ArrayBase<Derived2>& y)
+	{
+		return CwiseBinaryOp<internal::scalar_lgamma_subt_op<typename Derived::Scalar, typename Derived2::Scalar>, const Derived, const Derived2>(
+			x.derived(),
+			y.derived()
+		);
+	}
+}

data/vendor/tomotopy/src/Utils/LBFGS.h

@@ -0,0 +1,202 @@
+// Copyright (C) 2016-2019 Yixuan Qiu <yixuan.qiu@cos.name>
+// Under MIT license
+// https://github.com/yixuan/LBFGSpp
+// bab2min modified some features
+
+#ifndef LBFGS_H
+#define LBFGS_H
+
+#include <Eigen/Core>
+#include "LBFGS/Param.h"
+#include "LBFGS/LineSearchBacktracking.h"
+#include "LBFGS/LineSearchBracketing.h"
+
+
+namespace LBFGSpp {
+
+
+	///
+	/// LBFGS solver for unconstrained numerical optimization
+	///
+	template < typename Scalar,
+		template<class> class LineSearch = LineSearchBacktracking >
+	class LBFGSSolver
+	{
+	private:
+		typedef Eigen::Matrix<Scalar, Eigen::Dynamic, 1> Vector;
+		typedef Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> Matrix;
+		typedef Eigen::Map<Vector> MapVec;
+
+		static constexpr Scalar epsilon = Scalar(0.001); // add epsilon for preventing division-by-zero
+
+		LBFGSParam<Scalar> m_param;  // Parameters to control the LBFGS algorithm
+		Matrix                    m_s;      // History of the s vectors
+		Matrix                    m_y;      // History of the y vectors
+		Vector                    m_ys;     // History of the s'y values
+		Vector                    m_alpha;  // History of the step lengths
+		Vector                    m_fx;     // History of the objective function values
+		Vector                    m_xp;     // Old x
+		Vector                    m_grad;   // New gradient
+		Vector                    m_gradp;  // Old gradient
+		Vector                    m_drt;    // Moving direction
+
+		inline void reset(int n)
+		{
+			const int m = m_param.m;
+			m_s.resize(n, m);
+			m_y.resize(n, m);
+			m_ys.resize(m);
+			m_alpha.resize(m);
+			m_xp.resize(n);
+			m_grad.resize(n);
+			m_gradp.resize(n);
+			m_drt.resize(n);
+			if (m_param.past > 0)
+				m_fx.resize(m_param.past);
+		}
+
+	public:
+		///
+		/// Constructor for LBFGS solver.
+		///
+		/// \param param An object of \ref LBFGSParam to store parameters for the
+		///        algorithm
+		///
+		LBFGSSolver(const LBFGSParam<Scalar>& param = {}) :
+			m_param(param)
+		{
+			m_param.check_param();
+		}
+
+		///
+		/// Minimizing a multivariate function using LBFGS algorithm.
+		/// Exceptions will be thrown if error occurs.
+		///
+		/// \param f  A function object such that `f(x, grad)` returns the
+		///           objective function value at `x`, and overwrites `grad` with
+		///           the gradient.
+		/// \param x  In: An initial guess of the optimal point. Out: The best point
+		///           found.
+		/// \param fx Out: The objective function value at `x`.
+		///
+		/// \return Number of iterations used.
+		///
+		template <typename Foo>
+		inline int minimize(Foo&& f, Eigen::Ref<Vector> x, Scalar& fx)
+		{
+			const int n = x.size();
+			const int fpast = m_param.past;
+			reset(n);
+
+			// Evaluate function and compute gradient
+			fx = f(x, m_grad);
+
+			Scalar xnorm = x.norm();
+			Scalar gnorm = m_grad.norm();
+			if (fpast > 0)
+				m_fx[0] = fx;
+
+			// Early exit if the initial x is already a minimizer
+			if (gnorm <= m_param.epsilon * std::max(xnorm, Scalar(1.0)))
+			{
+				return 1;
+			}
+
+			// Initial direction
+			m_drt.noalias() = -m_grad;
+			// Initial step
+			Scalar step = Scalar(1.0) / m_drt.norm();
+
+			int k = 1;
+			int end = 0;
+			for (; ; )
+			{
+				// Save the curent x and gradient
+				m_xp.noalias() = x;
+				m_gradp.noalias() = m_grad;
+
+				// Line search to update x, fx and gradient
+				LineSearch<Scalar>::LineSearch(f, fx, x, m_grad, step, m_drt, m_xp, m_param);
+
+				// New x norm and gradient norm
+				xnorm = x.norm();
+				gnorm = m_grad.norm();
+
+				// Convergence test -- gradient
+				if (gnorm <= m_param.epsilon * std::max(xnorm, Scalar(1.0)))
+				{
+					return k;
+				}
+				// Convergence test -- objective function value
+				if (fpast > 0)
+				{
+					if (k >= fpast && std::abs((m_fx[k % fpast] - fx) / fx) < m_param.delta)
+						return k;
+
+					m_fx[k % fpast] = fx;
+				}
+				// Maximum number of iterations
+				if (m_param.max_iterations != 0 && k >= m_param.max_iterations)
+				{
+					return k;
+				}
+
+				// Update s and y
+				// s_{k+1} = x_{k+1} - x_k
+				// y_{k+1} = g_{k+1} - g_k
+				MapVec svec(&m_s(0, end), n);
+				MapVec yvec(&m_y(0, end), n);
+				svec.noalias() = x - m_xp;
+				yvec.noalias() = m_grad - m_gradp;
+
+				// ys = y's = 1/rho
+				// yy = y'y
+				Scalar ys = yvec.dot(svec);
+				Scalar yy = yvec.squaredNorm();
+
+				/* prevent division-by-zero */
+				if (yy == 0 || ys == 0)
+				{
+					ys += epsilon;
+					yy += epsilon;
+				}
+				m_ys[end] = ys;
+
+				// Recursive formula to compute d = -H * g
+				m_drt.noalias() = -m_grad;
+				int bound = std::min(m_param.m, k);
+				end = (end + 1) % m_param.m;
+				int j = end;
+				for (int i = 0; i < bound; i++)
+				{
+					j = (j + m_param.m - 1) % m_param.m;
+					MapVec sj(&m_s(0, j), n);
+					MapVec yj(&m_y(0, j), n);
+					m_alpha[j] = sj.dot(m_drt) / m_ys[j];
+					m_drt.noalias() -= m_alpha[j] * yj;
+				}
+
+				m_drt *= (ys / yy);
+
+				for (int i = 0; i < bound; i++)
+				{
+					MapVec sj(&m_s(0, j), n);
+					MapVec yj(&m_y(0, j), n);
+					Scalar beta = yj.dot(m_drt) / m_ys[j];
+					m_drt.noalias() += (m_alpha[j] - beta) * sj;
+					j = (j + 1) % m_param.m;
+				}
+
+				// step = 1.0 as initial guess
+				step = Scalar(1.0);
+				k++;
+			}
+
+			return k;
+		}
+	};
+
+
+} // namespace LBFGSpp
+
+#endif // LBFGS_H