GroupPartition.hpp

Go to the documentation of this file.

#pragma once
 
 
#include "stats/Stats.hpp"
#include "utils/Types.hpp"
#include "utils/Map.hpp"
#include "utils/Invariant.hpp"
 
#include <map>
#include <optional>
#include <set>
#include <vector>
#include <Eigen/Dense>
 
namespace ppforest2::stats {
  class GroupPartition {
    using Group       = types::Response;
    using GroupSet    = std::set<types::Response>;
    using GroupMap    = std::map<types::Response, types::Response>;
    using GroupInvMap = std::map<types::Response, GroupSet>;
    using GroupVector = types::Vector<types::Response>;
 
  public:
    static bool is_contiguous(GroupVector const& y);

    GroupPartition(types::ResponseVector const& y);

    int group_start(Group const& group) const;
    int group_end(Group const& group) const;
    int group_size(Group const& group) const;

    auto group(types::FeatureMatrix const& x, Group const& group) const {
      std::vector<int> indices;
 
      auto const& subs = this->subgroups.at(group);
 
      for (auto const& g : subs) {
        for (int i = group_start(g); i <= group_end(g); ++i) {
          invariant(i >= 0 && i < x.rows(), "GroupPartition::group: index out of bounds");
          indices.push_back(i);
        }
      }
 
      return x(indices, Eigen::all);
    }

    auto data(types::FeatureMatrix const& x) const {
      std::vector<int> indices;
 
      for (auto const& kv : Blocks) {
        auto const& g = kv.first;
        for (int i = group_start(g); i <= group_end(g); ++i) {
          indices.push_back(i);
        }
      }
 
      return x(indices, Eigen::all);
    }

    types::FeatureVector mean(types::FeatureMatrix const& x) const;
    types::FeatureMatrix bgss(types::FeatureMatrix const& x) const;
    types::FeatureMatrix wgss(types::FeatureMatrix const& x) const;

    GroupPartition subset(GroupSet groups) const;

    GroupPartition remap(GroupMap const& mapping) const;

    GroupPartition collapse() const;

    GroupSet const groups;
    GroupMap const supergroups;
    GroupInvMap const subgroups;
 
  private:
    struct Block {
      int start;
      int end;
      int size;
      std::optional<types::Response> next;
      std::optional<types::Response> prev;
    };
 
    using BlockMap = std::map<types::Response, Block>;
    BlockMap const Blocks;
 
    BlockMap init_Blocks(GroupVector const& y);
    GroupMap init_supergroups();
 
    GroupPartition(BlockMap const& Blocks, GroupSet const& groups);
 
    GroupPartition(BlockMap const& Blocks, GroupMap const& supergroups);
 
    GroupPartition(BlockMap const& Blocks, GroupSet const& groups, GroupMap const& supergroups);
  };
}