Maniverse 0.3.4__tar.gz → 1.0.0__tar.gz

{maniverse-0.3.4 → maniverse-1.0.0/Maniverse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Maniverse
-Version: 0.3.4
+Version: 1.0.0
 Summary: Numerical optimization on manifolds
 Home-page: https://github.com/FreemanTheMaverick/Maniverse.git
 Author: FreemanTheMaverick
@@ -57,9 +57,9 @@ The good thing is that the current codes do work as they are expected, at least
 
 ## Installation
 ### Manual build
-* Cloning the repository
+* Downloading the latest stable release
 ```
-$ git clone https://github.com/FreemanTheMaverick/Maniverse.git
+$ wget https://github.com/FreemanTheMaverick/Maniverse/archive/refs/tags/v0.3.5.tar.gz
 ```
 * Edit the first few lines of `/Maniverse/makefile` for your own computer configuration, including
   * the commands that call the C++ compiler, the GNU make and `ar`

{maniverse-0.3.4 → maniverse-1.0.0}/Maniverse.egg-info/SOURCES.txt

@@ -8,23 +8,31 @@ Maniverse.egg-info/dependency_links.txt
 Maniverse.egg-info/top_level.txt
 src/Macro.h
 src/PyManiverse.cpp
+src/Manifold/Euclidean.cpp
+src/Manifold/Euclidean.h
+src/Manifold/Flag.cpp
+src/Manifold/Flag.h
 src/Manifold/Grassmann.cpp
 src/Manifold/Grassmann.h
+src/Manifold/Iterate.cpp
 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/PyManifold.h
+src/Manifold/RealSymmetric.cpp
+src/Manifold/RealSymmetric.h
 src/Manifold/Simplex.cpp
 src/Manifold/Simplex.h
+src/Manifold/Stiefel.cpp
+src/Manifold/Stiefel.h
 src/Manifold/TransRotInvPointCloud.cpp
 src/Manifold/TransRotInvPointCloud.h
 src/Optimizer/HessUpdate.cpp
 src/Optimizer/HessUpdate.h
-src/Optimizer/PyOptimizerIn.h
-src/Optimizer/PyOptimizerOut.h
+src/Optimizer/PyOptimizer.h
 src/Optimizer/SubSolver.cpp
 src/Optimizer/SubSolver.h
 src/Optimizer/TrustRegion.cpp
-src/Optimizer/TrustRegion.h
+src/Optimizer/TrustRegion.h
+test/test.py

{maniverse-0.3.4/Maniverse.egg-info → maniverse-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Maniverse
-Version: 0.3.4
+Version: 1.0.0
 Summary: Numerical optimization on manifolds
 Home-page: https://github.com/FreemanTheMaverick/Maniverse.git
 Author: FreemanTheMaverick
@@ -57,9 +57,9 @@ The good thing is that the current codes do work as they are expected, at least
 
 ## Installation
 ### Manual build
-* Cloning the repository
+* Downloading the latest stable release
 ```
-$ git clone https://github.com/FreemanTheMaverick/Maniverse.git
+$ wget https://github.com/FreemanTheMaverick/Maniverse/archive/refs/tags/v0.3.5.tar.gz
 ```
 * Edit the first few lines of `/Maniverse/makefile` for your own computer configuration, including
   * the commands that call the C++ compiler, the GNU make and `ar`

{maniverse-0.3.4 → maniverse-1.0.0}/README.md

@@ -40,9 +40,9 @@ The good thing is that the current codes do work as they are expected, at least
 
 ## Installation
 ### Manual build
-* Cloning the repository
+* Downloading the latest stable release
 ```
-$ git clone https://github.com/FreemanTheMaverick/Maniverse.git
+$ wget https://github.com/FreemanTheMaverick/Maniverse/archive/refs/tags/v0.3.5.tar.gz
 ```
 * Edit the first few lines of `/Maniverse/makefile` for your own computer configuration, including
   * the commands that call the C++ compiler, the GNU make and `ar`

{maniverse-0.3.4 → maniverse-1.0.0}/setup.py

@@ -2,12 +2,12 @@ import os
 import urllib.request
 import tarfile
 from glob import glob
-from setuptools import setup, find_packages
+from setuptools import setup
 from setuptools.command.build import build
 import pybind11
 from pybind11.setup_helpers import Pybind11Extension, ParallelCompile, naive_recompile
 
-__version__ = "0.3.4"
+__version__ = "1.0.0"
 
 # Downloading Eigen3
 pwd = os.path.dirname(__file__)
@@ -30,25 +30,25 @@ ParallelCompile(
 
 MV_CPP = sorted(glob("src/*.cpp") + glob("src/*/*.cpp"))
 MV_HEADER = sorted(glob("src/*.h") + glob("src/*/*.h"))
-ext_modules = [ Pybind11Extension(
+ext_module = Pybind11Extension(
 	"Maniverse",
 	MV_CPP,
 	include_dirs = [EIGEN3],
 	depends = MV_HEADER,
 	extra_compile_args = ["-O3", "-D__PYTHON__", "-DEIGEN_INITIALIZE_MATRICES_BY_ZERO"],
-	cxx_std = 17,
-	language = "c++"
-)]
+	language = "c++",
+	cxx_std = 17
+)
 
 setup(
-		name = "Maniverse",
-		version = __version__,
-		author = "FreemanTheMaverick",
-		description = "Numerical optimization on manifolds",
-		long_description = open("README.md").read(),
-		long_description_content_type = "text/markdown",
-		url = "https://github.com/FreemanTheMaverick/Maniverse.git",
-		cmdclass = {"build": CustomBuild},
-		ext_modules = ext_modules,
-		classifiers = ["Programming Language :: Python :: 3"]
+	name = "Maniverse",
+	version = __version__,
+	author = "FreemanTheMaverick",
+	description = "Numerical optimization on manifolds",
+	long_description = open("README.md").read(),
+	long_description_content_type = "text/markdown",
+	url = "https://github.com/FreemanTheMaverick/Maniverse.git",
+	cmdclass = {"build": CustomBuild},
+	ext_modules = [ext_module],
+	classifiers = ["Programming Language :: Python :: 3"]
 )

maniverse-1.0.0/src/Manifold/Euclidean.cpp

@@ -0,0 +1,68 @@
+#ifdef __PYTHON__
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/eigen.h>
+#include <pybind11/functional.h>
+#endif
+#include <Eigen/Dense>
+#include <cmath>
+#include <functional>
+#include <memory>
+
+#include "../Macro.h"
+
+#include "Euclidean.h"
+
+Euclidean::Euclidean(EigenMatrix p): Manifold(p){
+	this->Name = "Euclidean(" + std::to_string(p.rows()) + ", " + std::to_string(p.cols()) + ")";
+}
+
+int Euclidean::getDimension() const{
+	return this->P.size();
+}
+
+double Euclidean::Inner(EigenMatrix X, EigenMatrix Y) const{
+	return (X.cwiseProduct(Y)).sum();
+}
+
+EigenMatrix Euclidean::Exponential(EigenMatrix X) const{
+	return this->P + X;
+}
+
+EigenMatrix Euclidean::Logarithm(Manifold& N) const{
+	return N.P - this->P;
+}
+
+EigenMatrix Euclidean::TangentProjection(EigenMatrix A) const{
+	return A;
+}
+
+EigenMatrix Euclidean::TangentPurification(EigenMatrix A) const{
+	return A;
+}
+
+void Euclidean::setPoint(EigenMatrix p, bool /*purify*/){
+	this->P = p;
+}
+
+void Euclidean::getGradient(){
+	this->Gr = this->Ge;
+}
+
+std::function<EigenMatrix (EigenMatrix)> Euclidean::getHessian(std::function<EigenMatrix (EigenMatrix)> He, bool /*weingarten*/) const{
+	std::function<EigenMatrix (EigenMatrix)> Hr = [He](EigenMatrix v){
+		return (EigenMatrix)(He(v));
+	};
+	return Hr;
+}
+
+std::unique_ptr<Manifold> Euclidean::Clone() const{
+	return std::make_unique<Euclidean>(*this);
+}
+
+#ifdef __PYTHON__
+void Init_Euclidean(pybind11::module_& m){
+	pybind11::classh<Euclidean, Manifold>(m, "Euclidean")
+		.def(pybind11::init<EigenMatrix>());
+}
+#endif

maniverse-0.3.4/src/Manifold/Orthogonal.h → maniverse-1.0.0/src/Manifold/Euclidean.h

@@ -1,7 +1,7 @@
 #include "Manifold.h"
 
-class Orthogonal: public Manifold{ public:
-	Orthogonal(EigenMatrix p, bool matrix_free);
+class Euclidean: public Manifold{ public:
+	Euclidean(EigenMatrix p);
 
 	int getDimension() const override;
 	double Inner(EigenMatrix X, EigenMatrix Y) const override;
@@ -12,12 +12,12 @@ class Orthogonal: public Manifold{ public:
 	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;
+	//EigenMatrix TransportTangent(EigenMatrix X, EigenMatrix Y) override;
+	//EigenMatrix TransportManifold(EigenMatrix X, Manifold& N) override;
 
-	void Update(EigenMatrix p, bool purify) override;
+	void setPoint(EigenMatrix p, bool purify) override;
 	void getGradient() override;
-	void getHessian() override;
+	std::function<EigenMatrix (EigenMatrix)> getHessian(std::function<EigenMatrix (EigenMatrix)> h, bool weingarten) const override;
 
 	std::unique_ptr<Manifold> Clone() const override;
 };

maniverse-1.0.0/src/Manifold/Flag.cpp

@@ -0,0 +1,86 @@
+#ifdef __PYTHON__
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/eigen.h>
+#include <pybind11/functional.h>
+#endif
+#include <Eigen/Core>
+#include <unsupported/Eigen/MatrixFunctions>
+#include <cmath>
+#include <functional>
+#include <tuple>
+#include <memory>
+
+#include "../Macro.h"
+
+#include "Flag.h"
+#include <iostream>
+
+void Flag::setBlockParameters(std::vector<int> sizes){
+	this->BlockParameters.clear();
+	this->Name = "Flag(";
+	int tot_size = 0;
+	for ( int size : sizes ){
+		if ( size <= 0 ) throw std::runtime_error("Invalid sizes of subspaces!");
+		this->BlockParameters.push_back(std::make_tuple(tot_size, size));
+		if ( tot_size > 0 ) this->Name += ", ";
+		tot_size += size;
+		this->Name += std::to_string(tot_size);
+	}
+	if ( tot_size > this->P.rows() ) throw std::runtime_error("Invalid sizes of subspaces!");
+	this->Name += "; " + std::to_string(this->P.rows()) + ")";
+}
+
+Flag::Flag(EigenMatrix p): Stiefel(p){} // Be sure to Flag::setBlockParameters after construction.
+
+int Flag::getDimension() const{
+	const int N = this->P.rows();
+	int ndim = 0;
+	int n = 0;
+	for ( auto block_parameter : this->BlockParameters ){
+		const int delta_n = std::get<1>(block_parameter);
+		n += delta_n;
+		ndim += delta_n * ( N - n );
+	}
+	return ndim;
+}
+
+inline static EigenMatrix TangentProjection(EigenMatrix P, std::vector<std::tuple<int, int>> BlockParameters, EigenMatrix X){
+	EigenMatrix Y = X;
+	for ( int i = 0; i < (int)BlockParameters.size(); i++ ){
+		FlagGetBlock(Y, i) -= FlagGetBlock(P, i) * FlagGetBlock(P, i).transpose() * FlagGetBlock(X, i);
+		for ( int j = 0; j < (int)BlockParameters.size(); j++ ){
+			if ( i != j ) FlagGetBlock(Y, i) -= FlagGetBlock(P, j) * FlagGetBlock(X, j).transpose() * FlagGetBlock(P, i);
+		}
+	}
+	return Y;
+}
+
+EigenMatrix Flag::TangentProjection(EigenMatrix X) const{
+	return ::TangentProjection(this->P, this->BlockParameters, X);
+}
+
+std::function<EigenMatrix (EigenMatrix)> Flag::getHessian(std::function<EigenMatrix (EigenMatrix)> He, bool weingarten) const{
+	//https://juliamanifolds.github.io/Manifolds.jl/stable/manifolds/stiefel
+	const EigenMatrix P = this->P;
+	const std::vector<std::tuple<int, int>> B = this->BlockParameters;
+	const EigenMatrix tmp = this->Ge.transpose() * this->P + this->P.transpose() * this->Ge;
+	if ( weingarten ) return [P, B, tmp, He](EigenMatrix v){
+		return ::TangentProjection(P, B, He(v) - 0.5 * v * tmp);
+	};
+	else return [P, B, He](EigenMatrix v){
+		return ::TangentProjection(P, B, He(v));
+	};
+}
+
+std::unique_ptr<Manifold> Flag::Clone() const{
+	return std::make_unique<Flag>(*this);
+}
+
+#ifdef __PYTHON__
+void Init_Flag(pybind11::module_& m){
+	pybind11::classh<Flag, Stiefel>(m, "Flag")
+		.def(pybind11::init<EigenMatrix>())
+		.def("setBlockParameters", &Flag::setBlockParameters);
+}
+#endif

maniverse-1.0.0/src/Manifold/Flag.h

@@ -0,0 +1,22 @@
+#include "Stiefel.h"
+
+class Flag: public Stiefel{ public:
+	std::vector<std::tuple<int, int>> BlockParameters;
+	void setBlockParameters(std::vector<int>);
+
+	Flag(EigenMatrix p);
+
+	int getDimension() const override;
+
+	EigenMatrix TangentProjection(EigenMatrix A) const override;
+
+	std::function<EigenMatrix (EigenMatrix)> getHessian(std::function<EigenMatrix (EigenMatrix)> He, bool weingarten) const override;
+
+	std::unique_ptr<Manifold> Clone() const override;
+};
+
+#define FlagGetBlock(big_mat, imat)\
+	big_mat( Eigen::placeholders::all, Eigen::seqN(\
+			std::get<0>(BlockParameters[imat]),\
+			std::get<1>(BlockParameters[imat])\
+	) )

{maniverse-0.3.4 → maniverse-1.0.0}/src/Manifold/Grassmann.cpp

@@ -5,26 +5,41 @@
 #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>
-
+EigenMatrix RealSkewExpm(EigenMatrix A){
+	Eigen::RealSchur<EigenMatrix> schur(A);
+	const EigenMatrix Q = schur.matrixU();
+	const EigenMatrix T = schur.matrixT();
+	const int n = T.cols();
+	EigenMatrix expT = EigenZero(n, n);
+	int i = 0;
+	while ( i < n ){
+		const double a = ( i == n - 1 ) ? 0 : T(i, i + 1);
+		if ( i == n - 1 || std::abs(a) < 1e-12 ){
+			expT(i, i) = 1;
+			i += 1;
+		}else{
+			const double sina = std::sin(a);
+			const double cosa = std::cos(a);
+			expT(i, i) = expT(i + 1, i + 1) = cosa;
+			expT(i, i + 1) = sina;
+			expT(i + 1, i) = - sina;
+			i += 2;
+		}
+	}
+	const EigenMatrix expA = Q * expT * Q.transpose();
+	return expA;
+}
 
-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;
+Grassmann::Grassmann(EigenMatrix p): Manifold(p){
 	Eigen::SelfAdjointEigenSolver<EigenMatrix> eigensolver;
 	eigensolver.compute(p);
 	const EigenVector eigenvalues = eigensolver.eigenvalues();
@@ -34,6 +49,8 @@ Grassmann::Grassmann(EigenMatrix p, bool matrix_free): Manifold(p, matrix_free){
 		if ( eigenvalues(i) > 0.5 ) rank++;
 	this->Projector.resize(p.rows(), rank);
 	this->Projector = eigenvectors.rightCols(rank);
+	this->P = this->Projector * this->Projector.transpose();
+	this->Name = "Grassmann(" + std::to_string(p.rows()) + ", " + std::to_string(rank) + ")";
 }
 
 int Grassmann::getDimension() const{
@@ -48,8 +65,8 @@ double Grassmann::Inner(EigenMatrix X, EigenMatrix Y) const{
 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();
+	const EigenMatrix expXp = RealSkewExpm(Xp);
+	const EigenMatrix exppX = RealSkewExpm(pX);
 	return expXp * this->P * exppX;
 }
 
@@ -94,8 +111,8 @@ EigenMatrix Grassmann::TransportTangent(EigenMatrix X, EigenMatrix Y) const{
 		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();
+	const EigenMatrix expdp = RealSkewExpm(dp);
+	const EigenMatrix exppd = RealSkewExpm(pd);
 	this->TransportTangentCache.push_back(std::make_tuple(Y, expdp, exppd));
 	return expdp * X * exppd;
 }
@@ -108,7 +125,7 @@ EigenMatrix Grassmann::TransportManifold(EigenMatrix X, Manifold& N) const{
 	return this->TransportTangent(X, Y);
 }
 
-void Grassmann::Update(EigenMatrix p, bool purify){
+void Grassmann::setPoint(EigenMatrix p, bool purify){
 	this->P = p;
 	Eigen::SelfAdjointEigenSolver<EigenMatrix> eigensolver;
 	eigensolver.compute(p);
@@ -124,14 +141,20 @@ void Grassmann::getGradient(){
 	this->Gr = this->TangentPurification(this->TangentProjection(this->Ge));
 }
 
-void Grassmann::getHessian(){
+std::function<EigenMatrix (EigenMatrix)> Grassmann::getHessian(std::function<EigenMatrix (EigenMatrix)> He, bool weingarten) const{
 	// 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;
+	if ( weingarten ) return [P = this->P, Ge = this->Ge, He](EigenMatrix v){
+		const EigenMatrix Phe = P * He(v);
+		const EigenMatrix partA = Phe - Phe.transpose();
+		const EigenMatrix Gev = Ge * v;
+		const EigenMatrix partB = Gev - Gev.transpose();
 		const EigenMatrix sum = partA - partB;
-		return (EigenMatrix)(P * sum - sum * P);
+		return (EigenMatrix)(2 * P * sum);
+	};
+	else return [P = this->P, He](EigenMatrix v){
+		const EigenMatrix Phe = P * He(v);
+		const EigenMatrix partA = Phe - Phe.transpose();
+		return (EigenMatrix)(2 * P * partA);
 	};
 }
 
@@ -141,7 +164,7 @@ std::unique_ptr<Manifold> Grassmann::Clone() const{
 
 #ifdef __PYTHON__
 void Init_Grassmann(pybind11::module_& m){
-	pybind11::class_<Grassmann, Manifold>(m, "Grassmann")
-		.def(pybind11::init<EigenMatrix, bool>());
+	pybind11::classh<Grassmann, Manifold>(m, "Grassmann")
+		.def(pybind11::init<EigenMatrix>());
 }
 #endif

{maniverse-0.3.4 → maniverse-1.0.0}/src/Manifold/Grassmann.h

@@ -5,7 +5,7 @@ class Grassmann: public Manifold{ public:
 	mutable std::vector<std::tuple<EigenMatrix, EigenMatrix>> LogCache;
 	mutable std::vector<std::tuple<EigenMatrix, EigenMatrix, EigenMatrix>> TransportTangentCache;
 
-	Grassmann(EigenMatrix p, bool matrix_free);
+	Grassmann(EigenMatrix p);
 
 	int getDimension() const override;
 	double Inner(EigenMatrix X, EigenMatrix Y) const override;
@@ -19,9 +19,10 @@ class Grassmann: public Manifold{ public:
 	EigenMatrix TransportTangent(EigenMatrix X, EigenMatrix Y) const override;
 	EigenMatrix TransportManifold(EigenMatrix X, Manifold& N) const override;
 
-	void Update(EigenMatrix p, bool purify) override;
+	void setPoint(EigenMatrix p, bool purify) override;
+
 	void getGradient() override;
-	void getHessian() override;
+	std::function<EigenMatrix (EigenMatrix)> getHessian(std::function<EigenMatrix (EigenMatrix)> h, bool weingarten) const override;
 
 	std::unique_ptr<Manifold> Clone() const override;
 };