FMBiGainMgr.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <span>
 
#include "FMBiGainCalc.hpp"
#include "FMGainMgr.hpp"
#include "moveinfo.hpp"  // for MoveInfo
 
// struct FMBiGainMgr;
 
template <typename Gnl> class FMBiGainMgr
    : public FMGainMgr<Gnl, FMBiGainCalc<Gnl>, FMBiGainMgr<Gnl>> {
  public:
    using Base = FMGainMgr<Gnl, FMBiGainCalc<Gnl>, FMBiGainMgr<Gnl>>;
    using GainCalc_ = FMBiGainCalc<Gnl>;
    using node_t = typename Gnl::node_t;
 
    explicit FMBiGainMgr(const Gnl& hyprgraph) : Base{hyprgraph, 2} {}
 
    FMBiGainMgr(const Gnl& hyprgraph, std::uint8_t /* num_parts */) : Base{hyprgraph, 2} {}
 
    auto init(std::span<const std::uint8_t> part) -> int;
 
    auto modify_key(const node_t& w, std::uint8_t part_w, int key) -> void {
        auto& item = this->gain_calc.vertex_list[w];
        if (item.is_locked()) {
            return;
        }
        this->gain_bucket[1 - part_w].modify_key(item, key);
    }
 
    auto update_move_v(const MoveInfoV<node_t>& move_info_v, int gain) -> void {
        // this->vertex_list[node_v].data.second -= 2 * gain;
        // auto [from_part, _ = move_info_v;
        this->_set_key(move_info_v.from_part, move_info_v.v, -gain);
    }
 
    auto lock(uint8_t whichPart, const node_t& v) -> void {
        auto& vlink = this->gain_calc.vertex_list[v];
        this->gain_bucket[whichPart].detach(vlink);
        vlink.lock();
    }
 
    auto lock_all(uint8_t from_part, const node_t& v) -> void { this->lock(1 - from_part, v); }
 
  private:
    auto _set_key(uint8_t whichPart, const node_t& v, int key) -> void {
        this->gain_bucket[whichPart].set_key(this->gain_calc.vertex_list[v], key);
    }
};