Morse.hpp

Go to the documentation of this file.

#pragma once
#include "Chains.hpp"
#include <Eigen/Sparse>
 
 
namespace mackey {
 
    template<typename diff_t>
    class AMT {
    public:
 
        const auto& original_to_reduced() const;
 
        const auto& reduced_to_original() const;
 
        double reduction_ratio() const;
 
        AMT(std::vector<diff_t>& A, bool compute_original_to_reduced, bool compute_reduced_to_original);
 
    protected:
 
        AMT(std::vector<diff_t>& A, bool compute_original_to_reduced, bool compute_reduced_to_original, bool onlyresize);
 
        typedef typename diff_t::StorageIndex ind; 
        typedef typename diff_t::Scalar scalar_t; 
        typedef Eigen::SparseMatrix<scalar_t, 1, ind> row_major_t; 
 
        std::vector<diff_t>& diff; 
        std::vector<std::map<ind, ind>> morse; 
        std::vector<std::vector<ind>> critical; 
 
        void reduce();
 
        void find_Morse_matching(int k, bool normalize);
 
        void normalize(int k);
 
        void erase_matchings(int k, const std::vector<std::pair<ind, ind>>& toremove);
 
    private:
        const bool getf;
        const bool getg;
 
        size_t original_size; 
        std::vector<diff_t> f; 
        std::vector<diff_t> g; 
        std::vector<std::map<ind, ind>> morse_inverse; 
        std::vector<std::map<ind, scalar_t>> normalizing_coefficients; 
        size_t compute_size() const;
        void resize();
        void set_critical();
        void kill_dead_paths();
        auto zig_zag_differential(int k, ind col) const;
        auto zig_zag_f(int k, ind col) const;
        auto zig_zag_g(int k, ind col) const;
        void set_f(int k);
        void set_g(int k);
        void reduce_diff(int k);
 
    };
 
    template<typename rank_t, typename diff_t>
    class EquivariantAMT : public AMT<diff_t> {
 
    public:
        EquivariantAMT(Chains<rank_t, diff_t>& C, bool compute_original_to_reduced, bool compute_reduced_to_original);
 
    private:
 
        using typename AMT<diff_t>::ind;
        using typename AMT<diff_t>::scalar_t;
 
        Chains<rank_t, diff_t>& C;
        std::vector<std::vector<int64_t>> rank_sums;
        auto find_index(int k, ind element) const;
        auto find_orbit(int k, ind element) const;
        auto find_non_equivariant_matching(int k) const;
        void set_rank_sums();
        void compute_ranks();
        void compute();
    };
}
#include "impl/Morse.ipp"