Green.hpp

Go to the documentation of this file.

#pragma once
#include "Mackey_Functors/Levels.hpp"
#include "Mackey_Functors/Identify.hpp"
#include "Chain_Complexes/Box.hpp"
 
 
namespace mackey
{
 
    template <typename group_t>
    typename group_t::rank_t multiply(const chains_t<group_t> &C, const chains_t<group_t> &D, int level, int degreeC, int degreeD, int selectC = 0, int selectD = 0);
 
    //forward declaration for Clang
    namespace internal
    {
        template <typename>
        class GreenCompute;
    }
 
    template <typename group_t>
    class Green
    {
        typedef typename group_t::rank_t rank_t;
        typedef typename group_t::diff_t diff_t;
 
    public:
        AbelianGroup<rank_t> group;  
        bool isZero;                 
        IDGenerators<rank_t> boxID;  
 
        Green();
 
        Green(const Chains<rank_t, diff_t> &, const Chains<rank_t, diff_t> &, int, int, int);
 
        rank_t getNormalBasis(const rank_t &, const rank_t&) const;
 
        rank_t getNormalBasis(int i, const rank_t &b) const;
 
        rank_t getNormalBasis(const rank_t&a, int j) const;
 
        rank_t getNormalBasis(int i, int j) const;
 
        bool operator==(const Green<group_t> &) const;
 
        std::vector<rank_t> basis; 
        int first_number_selections;  
        int second_number_selections; 
 
    private:
 
        int select(int, int) const;
 
        template <typename>
        friend class internal::GreenCompute;
    };
 
    namespace internal
    {
 
        template <typename group_t>
        class ChainsLevelGen
        {
            typedef typename group_t::rank_t rank_t;
            typedef typename group_t::diff_t diff_t;
 
            typename Homology<rank_t, diff_t>::Gens_t Gens;
            gen_t<rank_t, diff_t> gen, res_gen;
            rank_t rank_level;
            bool isZero;
            ChainsLevelGen(const Chains<rank_t, diff_t> &C, int level, int degree);
            ChainsLevelGen(const Chains<rank_t, diff_t> &C, int level, int degree, int selection);
 
            template <typename>
            friend class GreenCompute;
 
            template <typename>
            friend class MasseyCompute;
        };
 
        template <typename rank_t, typename diff_t>
        class ProductGen
        {
            gen_t<rank_t, diff_t> product;
            int padright, padleft;
            const Chains<rank_t, diff_t> &C, D;
            int degreeC, degreeD;
            ProductGen(const Chains<rank_t, diff_t> &C, const Chains<rank_t, diff_t> &D, int degreeC, int degreeD);
 
            void pad(const std::vector<int64_t> &detailedrank);
 
            void multiply(gen_t<rank_t, diff_t> gen1, gen_t<rank_t, diff_t> gen2);
 
            template <typename>
            friend class GreenCompute;
 
            template <typename>
            friend class MasseyCompute;
        };
 
        template <typename group_t>
        class GreenCompute
        {
            typedef typename group_t::rank_t rank_t;
            typedef typename group_t::diff_t diff_t;
 
            Green<group_t> G; 
            gen_t<rank_t, diff_t> product;
            const Chains<rank_t, diff_t> &C, D;
            typename Homology<rank_t, diff_t>::Gens_t GenC, GenD;
            rank_t rank_bottom, rank_level;
            const int level, degreeC, degreeD;
            Homology<rank_t, diff_t> H_Level;
            ChainsLevelGen<group_t> C_Variables, D_Variables;
            ProductGen<rank_t, diff_t> Restricted;
 
            GreenCompute(const Chains<rank_t, diff_t> &C, const Chains<rank_t, diff_t> &D, int level, int degreeC, int degreeD);
 
            void getGens();
            void box();
            void compute();
 
            template <typename>
            friend class mackey::Green;
        };
    }
}
#include "impl/Green.ipp"