Maniverse 0.2.1__tar.gz → 0.2.3__tar.gz

{Maniverse-0.2.1 → Maniverse-0.2.3/Maniverse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Maniverse
-Version: 0.2.1
+Version: 0.2.3
 Summary: Function optimization on manifolds
 Home-page: https://github.com/FreemanTheMaverick/Maniverse.git
 Author: FreemanTheMaverick

Maniverse-0.2.3/Maniverse.egg-info/SOURCES.txt

@@ -0,0 +1,41 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+Maniverse.egg-info/PKG-INFO
+Maniverse.egg-info/SOURCES.txt
+Maniverse.egg-info/dependency_links.txt
+Maniverse.egg-info/top_level.txt
+src/Macro.h
+src/Manifold
+src/Maniverse.egg-info
+src/Optimizer
+src/PyManiverse.cpp
+src/makefile
+src/Manifold/Grassmann.cpp
+src/Manifold/Grassmann.h
+src/Manifold/Manifold.cpp
+src/Manifold/Manifold.h
+src/Manifold/Orthogonal.cpp
+src/Manifold/Orthogonal.h
+src/Manifold/PyManifoldIn.h
+src/Manifold/PyManifoldOut.h
+src/Manifold/Simplex.cpp
+src/Manifold/Simplex.h
+src/Manifold/TransRotInvPointCloud.cpp
+src/Manifold/TransRotInvPointCloud.h
+src/Manifold/makefile
+src/Maniverse.egg-info/PKG-INFO
+src/Maniverse.egg-info/SOURCES.txt
+src/Maniverse.egg-info/dependency_links.txt
+src/Maniverse.egg-info/top_level.txt
+src/Optimizer/HessUpdate.cpp
+src/Optimizer/HessUpdate.h
+src/Optimizer/PyOptimizerIn.h
+src/Optimizer/PyOptimizerOut.h
+src/Optimizer/SubSolver.cpp
+src/Optimizer/SubSolver.h
+src/Optimizer/TrustRegion.cpp
+src/Optimizer/TrustRegion.h
+src/Optimizer/makefile

Maniverse-0.2.3/Maniverse.egg-info/top_level.txt

@@ -0,0 +1 @@
+Maniverse

Maniverse-0.2.3/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: Maniverse
+Version: 0.2.3
+Summary: Function optimization on manifolds
+Home-page: https://github.com/FreemanTheMaverick/Maniverse.git
+Author: FreemanTheMaverick
+Classifier: Programming Language :: Python :: 3
+License-File: LICENSE

Maniverse-0.2.3/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "pybind11", "wget"]
+build_backend = "setuptools.build_meta"

Maniverse-0.2.3/setup.py

@@ -0,0 +1,66 @@
+import os
+import wget
+import tarfile
+import subprocess
+from glob import glob
+from setuptools import setup, find_packages
+from setuptools.command.build import build
+import pybind11
+from pybind11.setup_helpers import Pybind11Extension, ParallelCompile, naive_recompile
+
+__version__ = "0.2.3"
+pwd = os.path.dirname(__file__)
+
+# Checking dependencies
+PYTHON3 = os.getenv("PYTHON3", default = '')
+print("Looking for Python.h at %s ..." % PYTHON3, end='')
+if os.path.isfile(PYTHON3 + "/Python.h"):
+	print("Found!")
+else:
+	raise RuntimeError("Python.h does not exist!")
+EIGEN3 = os.getenv("EIGEN3", default = '')
+if len(EIGEN3) > 0:
+	print("Looking for Eigen3 at %s ..." % EIGEN3, end='')
+	if os.path.exists(EIGEN3 + "/Eigen/") and os.path.exists(EIGEN3 + "/unsupported/") and os.path.isfile(EIGEN3 + "/signature_of_eigen3_matrix_library"):
+		print("Found!")
+	else:
+		raise RuntimeError("Python.h does not exist!")
+else:
+	print("The environment variable $EIGEN3 is not set. -> Downloading ...")
+	filename = wget.download("https://gitlab.com/libeigen/eigen/-/archive/3.4-rc1/eigen-3.4-rc1.tar.gz", bar = None)
+	with tarfile.open(filename) as tar:
+		tar.extractall(path = pwd) # Directory: eigen-3.4-rc1
+	EIGEN3 = pwd + "/eigen-3.4-rc1/"
+	print("EIGEN3 is %s." % EIGEN3)
+PYBIND11 = pybind11.get_include()
+print("PYBIND11 is %s." % PYBIND11)
+
+BASE_DIR = os.path.dirname(__file__)
+os.chdir(BASE_DIR)
+
+ParallelCompile(
+	"NPY_NUM_BUILD_JOBS",
+	needs_recompile = naive_recompile,
+	default = 4
+).install()
+
+ext_modules = [ Pybind11Extension(
+	"Maniverse",
+	sorted(glob("src/*")) + sorted(glob("src/*/*")),
+	define_macros = ["__PYTHON__", "EIGEN_INITIALIZE_MATRICES_BY_ZERO"],
+	undef_macros = ["DEBUG"],
+	include_dirs = [PYTHON3, EIGEN3, PYBIND11],
+	extra_compile_args = ["-O3"],
+	cxx_std = 17,
+	language = "c++"
+)]
+
+setup(
+		name = "Maniverse",
+		version = __version__,
+		author = "FreemanTheMaverick",
+		description = "Function optimization on manifolds",
+		ext_modules = ext_modules,
+		url = "https://github.com/FreemanTheMaverick/Maniverse.git",
+		classifiers = ["Programming Language :: Python :: 3"]
+)

Maniverse-0.2.3/src/Macro.h

@@ -0,0 +1,19 @@
+#define EigenArray Eigen::ArrayXd
+#define EigenVector Eigen::VectorXd
+#define EigenDiagonal Eigen::DiagonalMatrix<double, -1, -1>
+#define EigenMatrix Eigen::MatrixXd
+#define EigenZero Eigen::MatrixXd::Zero
+#define EigenOne Eigen::MatrixXd::Identity
+
+#define Diag(X) (X).diagonal().asDiagonal()
+#define Dot(X, Y) ( (X).transpose() * (Y) ).trace()
+
+#define __Not_Implemented__\
+	std::string func_name = __func__;\
+	std::string class_name = typeid(*this).name();\
+	throw std::runtime_error(func_name + " for " + class_name + " is not implemented!");
+
+#define __True_False__(x) ( x ? "True" : "False" )
+
+#define __now__ std::chrono::high_resolution_clock::now()
+#define __duration__(start, end) std::chrono::duration<double>(end - start).count()

Maniverse-0.2.3/src/Manifold/Grassmann.cpp

@@ -0,0 +1,147 @@
+#ifdef __PYTHON__
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/eigen.h>
+#include <pybind11/functional.h>
+#endif
+#include <Eigen/Dense>
+#include <unsupported/Eigen/MatrixFunctions>
+#include <cmath>
+#include <functional>
+#include <tuple>
+#include <cassert>
+#include <memory>
+
+#include "../Macro.h"
+
+#include "Grassmann.h"
+
+#include <iostream>
+
+
+Grassmann::Grassmann(EigenMatrix p, bool matrix_free): Manifold(p, matrix_free){
+	this->Name = "Grassmann";
+	this->P.resize(p.rows(), p.cols());
+	this->Ge.resize(p.rows(), p.cols());
+	this->Gr.resize(p.rows(), p.cols());
+	this->P = p;
+	Eigen::SelfAdjointEigenSolver<EigenMatrix> eigensolver;
+	eigensolver.compute(p);
+	const EigenVector eigenvalues = eigensolver.eigenvalues();
+	const EigenMatrix eigenvectors = eigensolver.eigenvectors();
+	int rank = 0;
+	for ( int i = 0; i < p.rows(); i++ )
+		if ( eigenvalues(i) > 0.5 ) rank++;
+	this->Projector.resize(p.rows(), rank);
+	this->Projector = eigenvectors.rightCols(rank);
+}
+
+int Grassmann::getDimension() const{
+	const double rank = this->Projector.cols();
+	return rank * ( this->P.rows() - rank );
+}
+
+double Grassmann::Inner(EigenMatrix X, EigenMatrix Y) const{
+	return Dot(X, Y);
+}
+
+EigenMatrix Grassmann::Exponential(EigenMatrix X) const{
+	const EigenMatrix Xp = X * this->P - this->P * X;
+	const EigenMatrix pX = - Xp;
+	const EigenMatrix expXp = Xp.exp();
+	const EigenMatrix exppX = pX.exp();
+	return expXp * this->P * exppX;
+}
+
+EigenMatrix Grassmann::Logarithm(Manifold& N) const{
+	for ( auto& [cached_NP, cached_Log] : this->LogCache )
+		if ( N.P.isApprox(cached_NP) ) return cached_Log;
+	__Check_Log_Map__
+	Grassmann& N_ = dynamic_cast<Grassmann&>(N);
+	const EigenMatrix U = this->Projector;
+	const EigenMatrix Y = N_.Projector;
+	Eigen::JacobiSVD<EigenMatrix> svd;
+	svd.compute(Y.transpose() * U, Eigen::ComputeFullU | Eigen::ComputeFullV);
+	const EigenMatrix Ystar = Y * svd.matrixU() * svd.matrixV().transpose();
+	svd.compute( (EigenOne(U.rows(), U.rows()) - U * U.transpose() ) * Ystar);
+	const EigenArray Sigma = svd.singularValues().array().asin();
+	EigenMatrix SIGMA = EigenZero(U.rows(), U.cols());
+	for ( int i = 0; i < Sigma.size(); i++ ) SIGMA(i, i) = Sigma[i];
+	const EigenMatrix Delta = svd.matrixU() * SIGMA * svd.matrixV().transpose();
+	const EigenMatrix Log = Delta * U.transpose() + U * Delta.transpose();
+	const EigenMatrix result = this->TangentPurification(Log);
+	this->LogCache.push_back(std::make_tuple(N_.P, result));
+	return result;
+}
+
+EigenMatrix Grassmann::TangentProjection(EigenMatrix X) const{
+	// X must be symmetric.
+	// https://sites.uclouvain.be/absil/2013.01
+	const EigenMatrix adPX = this->P * X - X * this->P;
+	return this->P * adPX - adPX * this->P;
+}
+
+EigenMatrix Grassmann::TangentPurification(EigenMatrix A) const{
+	const EigenMatrix symA = 0.5 * ( A + A.transpose() );
+	const EigenMatrix pureA = symA - this->P * symA * this->P;
+	return 0.5 * ( pureA + pureA.transpose() );
+}
+
+EigenMatrix Grassmann::TransportTangent(EigenMatrix X, EigenMatrix Y) const{
+	// X - Vector to transport from P
+	// Y - Destination on the tangent space of P
+	for ( auto& [cached_Y, cached_expdp, cached_exppd]: this->TransportTangentCache )
+		if ( Y.isApprox(cached_Y) ) return cached_expdp * X * cached_exppd;
+	const EigenMatrix dp = Y * this->P - this->P * Y;
+	const EigenMatrix pd = - dp;
+	const EigenMatrix expdp = dp.exp();
+	const EigenMatrix exppd = pd.exp();
+	this->TransportTangentCache.push_back(std::make_tuple(Y, expdp, exppd));
+	return expdp * X * exppd;
+}
+
+EigenMatrix Grassmann::TransportManifold(EigenMatrix X, Manifold& N) const{
+	// X - Vector to transport from P
+	__Check_Vec_Transport__
+	Grassmann& N_ = dynamic_cast<Grassmann&>(N);
+	const EigenMatrix Y = this->Logarithm(N_);
+	return this->TransportTangent(X, Y);
+}
+
+void Grassmann::Update(EigenMatrix p, bool purify){
+	this->P = p;
+	Eigen::SelfAdjointEigenSolver<EigenMatrix> eigensolver;
+	eigensolver.compute(p);
+	const EigenMatrix eigenvectors = eigensolver.eigenvectors();
+	const int ncols = this->Projector.cols();
+	this->Projector = eigenvectors.rightCols(ncols);
+	this->LogCache.clear();
+	this->TransportTangentCache.clear();
+	if (purify) this->P = this->Projector * this->Projector.transpose();
+}
+
+void Grassmann::getGradient(){
+	this->Gr = this->TangentPurification(this->TangentProjection(this->Ge));
+}
+
+void Grassmann::getHessian(){
+	// https://arxiv.org/abs/0709.2205
+	this->Hr = [P = this->P, Ge = this->Ge, He = this->He](EigenMatrix v){
+		const EigenMatrix he = He(v);
+		const EigenMatrix partA = P * he - he * P;
+		const EigenMatrix partB = Ge * v - v * Ge;
+		const EigenMatrix sum = partA - partB;
+		return (EigenMatrix)(P * sum - sum * P);
+	};
+}
+
+std::unique_ptr<Manifold> Grassmann::Clone() const{
+	return std::make_unique<Grassmann>(*this);
+}
+
+#ifdef __PYTHON__
+void Init_Grassmann(pybind11::module_& m){
+	pybind11::class_<Grassmann, Manifold>(m, "Grassmann")
+		.def(pybind11::init<EigenMatrix, bool>());
+}
+#endif

Maniverse-0.2.3/src/Manifold/Grassmann.h

@@ -0,0 +1,27 @@
+#include "Manifold.h"
+
+class Grassmann: public Manifold{ public:
+	EigenMatrix Projector;
+	mutable std::vector<std::tuple<EigenMatrix, EigenMatrix>> LogCache;
+	mutable std::vector<std::tuple<EigenMatrix, EigenMatrix, EigenMatrix>> TransportTangentCache;
+
+	Grassmann(EigenMatrix p, bool matrix_free);
+
+	int getDimension() const override;
+	double Inner(EigenMatrix X, EigenMatrix Y) const override;
+
+	EigenMatrix Exponential(EigenMatrix X) const override;
+	EigenMatrix Logarithm(Manifold& N) const override;
+
+	EigenMatrix TangentProjection(EigenMatrix A) const override;
+	EigenMatrix TangentPurification(EigenMatrix A) const override;
+
+	EigenMatrix TransportTangent(EigenMatrix X, EigenMatrix Y) const override;
+	EigenMatrix TransportManifold(EigenMatrix X, Manifold& N) const override;
+
+	void Update(EigenMatrix p, bool purify) override;
+	void getGradient() override;
+	void getHessian() override;
+
+	std::unique_ptr<Manifold> Clone() const override;
+};

Maniverse-0.2.3/src/Manifold/Manifold.cpp

@@ -0,0 +1,220 @@
+#ifdef __PYTHON__
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/eigen.h>
+#include <pybind11/functional.h>
+#endif
+#include <Eigen/Dense>
+#include <typeinfo>
+#include <memory>
+
+#include "../Macro.h"
+
+#include "Manifold.h"
+
+#include <iostream>
+
+
+Manifold::Manifold(EigenMatrix p, bool matrix_free){
+	this->P.resize(p.rows(), p.cols());
+	this->Ge.resize(p.rows(), p.cols());
+	this->Gr.resize(p.rows(), p.cols());
+	this->P = p;
+	this->MatrixFree = matrix_free;
+	if (this->MatrixFree){
+		this->Hem.resize(0, 0);
+		this->Hrm.resize(0);
+	}
+}
+
+int Manifold::getDimension() const{
+	__Not_Implemented__
+	return 0;
+}
+
+double Manifold::Inner(EigenMatrix X, EigenMatrix Y) const{
+	__Not_Implemented__
+	return X.rows() * Y.cols() * 0; // Avoiding the unused-variable warning
+}
+
+static std::tuple<EigenVector, EigenMatrix> ThinEigen(EigenMatrix A, int m){
+	// n - Total number of eigenvalues
+	// m - Number of non-trivial eigenvalues
+	const int n = A.rows();
+	Eigen::SelfAdjointEigenSolver<EigenMatrix> es;
+	es.compute(A);
+	std::vector<std::tuple<double, EigenVector>> eigen_tuples;
+	eigen_tuples.reserve(n);
+	for ( int i = 0; i < n; i++ )
+		eigen_tuples.push_back(std::make_tuple(es.eigenvalues()(i), es.eigenvectors().col(i)));
+	std::sort( // Sorting the eigenvalues in decreasing order of magnitude.
+			eigen_tuples.begin(), eigen_tuples.end(),
+			[](std::tuple<double, EigenVector>& a, std::tuple<double, EigenVector>& b){
+				return std::abs(std::get<0>(a)) > std::abs(std::get<0>(b));
+			}
+	); // Now the eigenvalues closest to zero are in the back.
+	eigen_tuples.resize(m); // Deleting them.
+	std::sort( // Resorting the eigenvalues in increasing order.
+			eigen_tuples.begin(), eigen_tuples.end(),
+			[](std::tuple<double, EigenVector>& a, std::tuple<double, EigenVector>& b){
+				return std::get<0>(a) < std::get<0>(b);
+			}
+	);
+	EigenVector eigenvalues = EigenZero(m, 1);
+	EigenMatrix eigenvectors = EigenZero(n, m);
+	for ( int i = 0; i < m; i++ ){
+		eigenvalues(i) = std::get<0>(eigen_tuples[i]);
+		eigenvectors.col(i) = std::get<1>(eigen_tuples[i]);
+	}
+	return std::make_tuple(eigenvalues, eigenvectors);
+}
+
+void Manifold::getBasisSet(){
+	const int nrows = this->P.rows();
+	const int ncols = this->P.cols();
+	const int size = nrows * ncols;
+	const int rank = this->getDimension();
+	EigenMatrix euclidean_basis = EigenZero(nrows, ncols);
+	std::vector<EigenMatrix> unorthogonal_basis_set(size, EigenZero(nrows, ncols));
+	for ( int i = 0, n = 0; i < nrows; i++ ) for ( int j = 0; j < ncols; j++ , n++){
+		euclidean_basis(i, j) = 1;
+		unorthogonal_basis_set[n] = TangentProjection(euclidean_basis);
+		euclidean_basis(i, j) = 0;
+	}
+	EigenMatrix gram = EigenZero(size, size);
+	for ( int i = 0; i < size; i++ ) for ( int j = 0; j <= i; j++ ){
+		gram(i, j) = gram(j, i) = this->Inner(unorthogonal_basis_set[i], unorthogonal_basis_set[j]);
+	}
+	auto [Sigma, U] = ThinEigen(gram, rank);
+	const EigenMatrix C = U * Sigma.cwiseSqrt().asDiagonal();
+	this->BasisSet.resize(rank);
+	for ( int i = 0; i < rank; i++ ){
+		this->BasisSet[i].resize(nrows, ncols); this->BasisSet[i].setZero();
+		for ( int j = 0; j < size; j++ ){
+			this->BasisSet[i] += C(j, i) * unorthogonal_basis_set[j].reshaped<Eigen::RowMajor>(nrows, ncols);
+		}
+	}
+}
+
+std::vector<std::tuple<double, EigenMatrix>> Diagonalize(
+		EigenMatrix& A, std::vector<EigenMatrix>& basis_set){
+	Eigen::SelfAdjointEigenSolver<EigenMatrix> es;
+	es.compute( ( A + A.transpose() ) / 2 );
+	const EigenMatrix Lambda = es.eigenvalues();
+	const EigenMatrix Y = es.eigenvectors();
+	const int nrows = basis_set[0].rows();
+	const int ncols = basis_set[0].cols();
+	const int rank = basis_set.size();
+	std::vector<std::tuple<double, EigenMatrix>> hrm(rank, std::tuple(0, EigenZero(nrows, ncols)));
+	for ( int i = 0; i < rank; i++ ){
+		std::get<0>(hrm[i]) = Lambda(i);
+		for ( int j = 0; j < rank; j++ ){
+			std::get<1>(hrm[i]) += basis_set[j] * Y(j, i);
+		}
+	}
+	return hrm;
+}
+
+void Manifold::getHessianMatrix(){
+	// Representing the Riemannian hessian with the orthogonal basis set
+	const int rank = this->getDimension();
+	EigenMatrix hrm = EigenZero(rank, rank);
+	for ( int i = 0; i < rank; i++ ) for ( int j = 0; j <= i; j++ ){
+		hrm(i, j) = hrm(j, i) = this->Inner(this->BasisSet[i], this->Hr(this->BasisSet[j]));
+	}
+
+	// Diagonalizing the Riemannian hessian and representing the eigenvectors in Euclidean space
+	this->Hrm = Diagonalize(hrm, this->BasisSet);
+
+	// Updating the Riemannian hessian operator
+	this->Hr = [&hrm = this->Hrm](EigenMatrix v){ // Passing reference instead of value to std::function, so that the eigenvalues can be modified elsewhere without rewriting this part.
+		EigenMatrix Hv = EigenZero(v.rows(), v.cols());
+		for ( auto [eigenvalue, eigenvector] : hrm ){
+			Hv += eigenvalue * eigenvector.cwiseProduct(v).sum() * eigenvector;
+		}
+		return Hv;
+	};
+}
+
+EigenMatrix Manifold::Exponential(EigenMatrix X) const{
+	__Not_Implemented__
+	return EigenZero(X.rows(), X.cols());
+}
+
+EigenMatrix Manifold::Logarithm(Manifold& N) const{
+	__Not_Implemented__
+	return EigenZero(N.P.rows(), N.P.cols());
+}
+
+EigenMatrix Manifold::TangentProjection(EigenMatrix A) const{
+	__Not_Implemented__
+	return EigenZero(A.rows(), A.cols());
+}
+
+EigenMatrix Manifold::TangentPurification(EigenMatrix A) const{
+	__Not_Implemented__
+	return EigenZero(A.rows(), A.cols());
+}
+
+EigenMatrix Manifold::TransportTangent(EigenMatrix X, EigenMatrix Y) const{
+	__Not_Implemented__
+	return EigenZero(X.rows(), Y.cols());
+}
+
+EigenMatrix Manifold::TransportManifold(EigenMatrix X, Manifold& N) const{
+	__Not_Implemented__
+	return EigenZero(X.rows(), N.P.cols());
+}
+
+void Manifold::Update(EigenMatrix p, bool purify){
+	if ( purify ? p.rows() : p.cols() ){ // To avoid the unused-variable warning.
+		__Not_Implemented__
+	}else{
+		__Not_Implemented__
+	}
+}
+
+void Manifold::getGradient(){
+	__Not_Implemented__
+}
+
+void Manifold::getHessian(){
+	__Not_Implemented__
+}
+
+std::unique_ptr<Manifold> Manifold::Clone() const{
+	__Not_Implemented__
+	return std::make_unique<Manifold>(*this);
+}
+
+#ifdef __PYTHON__
+void Init_Manifold(pybind11::module_& m){
+	pybind11::class_<Manifold>(m, "Manifold")
+		.def_readwrite("Name", &Manifold::Name)
+		.def_readwrite("P", &Manifold::P)
+		.def_readwrite("Ge", &Manifold::Ge)
+		.def_readwrite("Gr", &Manifold::Gr)
+		.def_readwrite("MatrixFree", &Manifold::MatrixFree)
+		.def_readwrite("Hem", &Manifold::Hem)
+		.def_readwrite("Hrm", &Manifold::Hrm)
+		.def_readwrite("He", &Manifold::He)
+		.def_readwrite("Hr", &Manifold::Hr)
+		.def_readwrite("BasisSet", &Manifold::BasisSet)
+		.def(pybind11::init<EigenMatrix, bool>())
+		.def("getDimension", &Manifold::getDimension)
+		.def("Inner", &Manifold::Inner)
+		.def("getBasisSet", &Manifold::getBasisSet)
+		.def("getHessianMatrix", &Manifold::getHessianMatrix)
+		.def("Exponential", &Manifold::Exponential)
+		.def("Logarithm", &Manifold::Logarithm)
+		.def("TangentProjection", &Manifold::TangentProjection)
+		.def("TangentPurification", &Manifold::TangentPurification)
+		.def("TransportTangent", &Manifold::TransportTangent)
+		.def("TransportManifold", &Manifold::TransportManifold)
+		.def("Update", &Manifold::Update)
+		.def("getGradient", &Manifold::getGradient)
+		.def("getHessian", &Manifold::getHessian)
+		.def("Clone", &Manifold::Clone);
+	m.def("Diagonalize", &Diagonalize);
+}
+#endif

Maniverse-0.2.3/src/Manifold/Manifold.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#define __Check_Log_Map__\
+	if ( typeid(N) != typeid(*this) )\
+		throw std::runtime_error("The point to logarithm map is not in " + std::string(typeid(*this).name()) + "but in " + std::string(typeid(N).name()) + "!");
+
+#define __Check_Vec_Transport__\
+	if ( typeid(N) != typeid(*this) )\
+		throw std::runtime_error("The destination of vector transport is not in " + std::string(typeid(*this).name()) + "but in " + std::string(typeid(N).name()) + "!");
+
+class Manifold{ public:
+	std::string Name;
+	EigenMatrix P;
+	EigenMatrix Ge;
+	EigenMatrix Gr;
+	bool MatrixFree;
+	EigenMatrix Hem;
+	std::vector<std::tuple<double, EigenMatrix>> Hrm;
+	std::function<EigenMatrix (EigenMatrix)> He;
+	std::function<EigenMatrix (EigenMatrix)> Hr;
+	std::vector<EigenMatrix> BasisSet;
+
+	Manifold(EigenMatrix p, bool matrix_free);
+	virtual int getDimension() const;
+	virtual double Inner(EigenMatrix X, EigenMatrix Y) const;
+	void getBasisSet();
+	void getHessianMatrix();
+
+	virtual EigenMatrix Exponential(EigenMatrix X) const;
+	virtual EigenMatrix Logarithm(Manifold& N) const;
+
+	virtual EigenMatrix TangentProjection(EigenMatrix A) const;
+	virtual EigenMatrix TangentPurification(EigenMatrix A) const;
+
+	virtual EigenMatrix TransportTangent(EigenMatrix X, EigenMatrix Y) const;
+	virtual EigenMatrix TransportManifold(EigenMatrix X, Manifold& N) const;
+
+	virtual void Update(EigenMatrix p, bool purify);
+	virtual void getGradient();
+	virtual void getHessian();
+
+	virtual ~Manifold() = default;
+	virtual std::unique_ptr<Manifold> Clone() const;
+};
+
+std::vector<std::tuple<double, EigenMatrix>> Diagonalize(
+		EigenMatrix& A, std::vector<EigenMatrix>& basis_set);