R1Cs: RC Updater¶

#ifndef ROUTE_OPT_RANK1_RC_CONTROLLER_HPP
#define ROUTE_OPT_RANK1_RC_CONTROLLER_HPP

#include <algorithm>
#include "rank1_macro.hpp"
#include "route_opt_macro.hpp"

namespace RouteOpt::Rank1Cuts::RCGetter {

    struct R1CPricingStat {
        int num{};
        int *valid_cut_idx{};
        int *cut_map{};

        void copyFrom(const R1CPricingStat &other) {
            num = other.num;
            std::copy_n(other.valid_cut_idx, num, valid_cut_idx);
            std::copy_n(other.cut_map, MAX_NUM_R1CS_IN_PRICING, cut_map);
        }
    };

    struct R1CUseStates {
        r1cIndex union_map{};
        std::vector<int> v_union_mem;
        std::vector<std::pair<int, int>> sparse;
        r1cIndex sparse_map{};
    };

    class Rank1RCController {
    public:
        explicit Rank1RCController(Rank1CutsDataShared &data_shared)
            : data_shared_ref(std::ref(data_shared)) {
        }

        static void initializeLabel(const R1CPricingStat &r1c) {
            std::fill_n(r1c.cut_map, MAX_NUM_R1CS_IN_PRICING, 0);
        }

        void getRank1DualsInCG(const std::vector<R1c> &cuts,
                               const std::vector<double> &pi_vector);

        void updateR1CStates(double &rc, R1CPricingStat &out_states,
                             const R1CPricingStat &in_states,
                             int from,
                             int to);

        bool doR1CDominance(double &gap,
                            const R1CPricingStat &out_states,
                            const R1CPricingStat &in_states);

        bool concatenateR1CStates(double &rc, double req, R1CPricingStat &out_states,
                                  const R1CPricingStat &in_states, int out, int in);

        template<typename T, typename R1cPtr>
        void assignLabelMem(T *all_label, size_t label_assign, R1cPtr r1c_ptr) {
            if (all_label == nullptr)
                THROW_RUNTIME_ERROR("all_label is nullptr");
            delete[] label_int_space;
            size_t constexpr label_int_space_len = MAX_NUM_R1CS_IN_PRICING + MAX_POSSIBLE_NUM_R1CS_FOR_VERTEX;
            label_int_space = new int[label_int_space_len * label_assign];
            size_t cut_map_beg = 0;
            for (size_t i = 0; i < label_assign; ++i) {
                auto &r1c = all_label[i].*r1c_ptr;
                r1c.cut_map = label_int_space + cut_map_beg;
                cut_map_beg += MAX_NUM_R1CS_IN_PRICING;
                r1c.valid_cut_idx = label_int_space + cut_map_beg;
                cut_map_beg += MAX_POSSIBLE_NUM_R1CS_FOR_VERTEX;
            }
        }

        Rank1RCController() = delete;

        ~Rank1RCController() {
            delete[] label_int_space;
        }

    private:
        int *label_int_space{};
        std::vector<R1CUseStates> cg_v_cut_map{};
        std::vector<std::vector<std::vector<int>>> cg_v_v_use_states{};
        std::vector<int> cg_r1c_denominator{};
        std::vector<double> rank1_dual{};
        std::vector<double> revised_rank1_dual{};
        const std::reference_wrapper<Rank1CutsDataShared> data_shared_ref;
    };
} // namespace RouteOpt::Rank1Cuts::RCGetter

#endif // ROUTE_OPT_RANK1_RC_CONTROLLER_HPP

#include <vector>
#include <iostream>
#include "rank1_rc_controller.hpp"
#include "rank1_macro.hpp"
#include "solver.hpp"

using namespace RouteOpt::Rank1Cuts;
using namespace RouteOpt::Rank1Cuts::RCGetter;

int main() {
    // Initialize shared Rank-1 cuts data with an instance dimension (e.g., 5)
    Rank1CutsDataShared sharedData(5);

    // Create an instance of the Rank1RCController with the shared data
    Rank1RCController rcController(sharedData);

    // assign label memory for a vector of labels (e.g., 10 labels), assuming Label is a struct with r1c as a member
    auto all_label = new Label[10];
    rcController.assignLabelMem(all_label, 10, &Label::r1c);

    // Prepare a dummy R1CPricingStat for demonstration
    R1CPricingStat pricingStat;
    // Allocate memory for valid_cut_idx and cut_map as needed, for example:
    // pricingStat.valid_cut_idx = new int[some_length];
    // pricingStat.cut_map = new int[MAX_NUM_R1CS_IN_PRICING];

    // Initialize the label fields of pricingStat (set all values in cut_map to zero)
    Rank1RCController::initializeLabel(pricingStat);

    // Prepare a dummy π-vector (dual prices)
    std::vector<double> piVector = {1.0, 0.5, 0.2, 0.8, 0.3};

    // Assume an empty vector of Rank-1 cuts for demonstration
    std::vector<R1c> cuts;

    // Retrieve dual values from the column generation process
    rcController.getRank1DualsInCG(cuts, piVector);

    // Update Rank-1 cut states (e.g., transfer state from customer 1 to customer 2)
    double rc = 0.0;
    R1CPricingStat newPricingStat;
    // Ensure newPricingStat is allocated and initialized appropriately.
    rcController.updateR1CStates(rc, newPricingStat, pricingStat, 1, 2);

    // Perform a dominance check between the updated and original pricing statistics
    double gap = -10.0; // Example gap value
    bool isDominant = rcController.doR1CDominance(gap, newPricingStat, pricingStat);
    std::cout << "Dominance check result: "
              << (isDominant ? "Dominant" : "Not Dominant") << std::endl;

    // Concatenate state information with a required value (example: 1.5)
    bool concatenated = rcController.concatenateR1CStates(rc, 1.5, newPricingStat, pricingStat, 2, 1);
    std::cout << "State concatenation "
              << (concatenated ? "succeeded" : "failed") << std::endl;



    // Clean up any dynamically allocated memory if necessary.
    // The destructor of rcController will automatically free label_int_space.

    return 0;
}