.. _program_listing_file_src_partition_initial.h:

Program Listing for File initial.h
==================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_partition_initial.h>` (``src/partition/initial.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef INITIAL_H
   #define INITIAL_H
   
   #include "coarsen.h"
   #include "ortools/linear_solver/linear_solver.h"
   #include "refine/bucket/MoveBucket.h"
   #include "refine/core/RefineTypes.h"
   
   
   class Initial {
    private:
     bool has_fix;  
     bool force_topo;  
     int multilevel_id = 0;  
     int max_hop;            
     int num_initial_solutions;  
     int num_best_initial_solutions;  
   
     vector<flat_hash_map<int, pair<int, double>>>
         hypergraph;  
   
     void constructGraph(const graph &g);
   
     void improvedSPFA(const graph &g, vector<int> &parts,
                       vector<VectorXi> upper_resources,
                       vector<VectorXi> &occupied_resources);
   
     int selectInitialNodes(const graph &g, vector<int> &parts,
                            vector<VectorXi> upper_resources,
                            vector<VectorXi> &occupied_resources,
                            vector<int> &order);
   
     int randomPart(const graph &g, vector<int> &parts, VectorXi upper_resources,
                    VectorXi lower_resources, vector<VectorXi> &occupied_resources,
                    int seed);
   
     int greedyPart(const graph &g, vector<int> &parts,
                    vector<VectorXi> upper_resources,
                    vector<VectorXi> &occupied_resources, int seed);
   
     int progressiveMinCutPart(const graph &g, vector<int> &parts,
                               vector<VectorXi> upper_resources,
                               vector<VectorXi> &occupied_resources, int seed);
   
     double calculateGain(const graph &g, const vector<int> &parts, int vertex,
                          int to, int type);
   
     int growPart(const graph &g, vector<int> &parts,
                  vector<VectorXi> upper_resources,
                  vector<VectorXi> &occupied_resources, int i, int seed);
   
     int globalGrowPart(const graph &g, vector<int> &parts,
                        vector<VectorXi> upper_resources,
                        vector<VectorXi> &occupied_resources, int type, int seed);
   
     int sequentialGrowPart(const graph &g, vector<int> &parts,
                            vector<VectorXi> upper_resources,
                            vector<VectorXi> &occupied_resources, int type,
                            int seed);
   
     int roundRobinGrowPart(const graph &g, vector<int> &parts,
                            vector<VectorXi> upper_resources,
                            vector<VectorXi> &occupied_resources, int type,
                            int seed);
   
     int initialPartitionTopo(const graph &g, const fpga &fpgas,
                              vector<int> &parts, vector<VectorXi> upper_resources,
                              vector<VectorXi> &occupied_resources, bool has_fix,
                              const vector<int> &fixed_assign,
                              vector<set<int>> candidate, int allow_hop, int i,
                              int seed);
   
    public:
     Initial(const PartitionConstraintConfig &constraints,
             const InitialPartitionConfig &config);
   
     int initialPartition(MultilevelCoarsener &mc, const fpga &fpgas,
                          vector<vector<int>> &candidate_parts,
                          vector<vector<VectorXi>> &candidate_occupied_resources);
   
     bool COCP_ILP(MultilevelCoarsener &mc, const fpga &fpgas, bool has_fix,
                   vector<int> &candidate_parts,
                   vector<VectorXi> &candidate_occupied_resources);
   };
   
   #endif