int main () {
PGR_LOG("message 1");
PGR_LOGF("%s at epoch %d\n", "message 2", (int)time(NULL));
PGR_LOG("message 3");
return 0;
}
void loadOrders(vrp_orders_t *orders, int order_count, int depotId) {
int i;
PGR_LOGF("%s: %d\n", "Depot ID", id);
for (i = 0; i < order_count; i++) {
int id = orders[i].id;
PGR_LOGF("%s: %d\n", "Order ID", id);
if (id == depotId) {
PGR_LOG("Got depot");
// This order represents Deopot
CDepotInfo depot;
depot.setDepotId(id);
Point pt;
pt.X = orders[i].x;
pt.Y = orders[i].y;
depot.setDepotLocation(pt);
int openTime = orders[i].open_time;
depot.setOpenTime(openTime);
int closeTime = orders[i].close_time;
depot.setCloseTime(closeTime);
solver.addDepot(depot);
} else {
// This is an order
COrderInfo order;
order.setOrderId(id);
Point pt;
pt.X = orders[i].x;
pt.Y = orders[i].y;
order.setOrderLocation(pt);
int demand = orders[i].order_unit;
order.setOrderUnit(demand);
int openTime = orders[i].open_time;
order.setOpenTime(openTime);
int closeTime = orders[i].close_time;
order.setCloseTime(closeTime);
int serviceTime = orders[i].service_time;
order.setServiceTime(serviceTime);
solver.addOrder(order);
}
}
}
bool CVRPSolver::solveVRP(std::string& strError) {
// if (!m_bIsReadyToSolve)
// {
// strError = "Scenario is not ready to solve. Configure all parameter";
// return false;
// }
PGR_LOG("Inside Solve VRP");
std::vector<int> vecOrders, vecVehicles;
for(auto &rule:m_vOrderInfos)
{
vecOrders.push_back(rule.getOrderId());
}
for (auto &rule:m_vVehicleInfos) {
vecVehicles.push_back(rule.getId());
}
m_solutionFinal.init(vecOrders, static_cast<int>(vecOrders.size()), vecVehicles);
PGR_LOG("After init solution");
int iAttemptCount = 0;
while (iAttemptCount < MAXIMUM_TRY) {
bool bUpdateFound = false;
CSolutionInfo initialSolution = generateInitialSolution();
PGR_LOG("After Generate initial Solution");
iAttemptCount++;
bUpdateFound = updateFinalSolution(initialSolution);
PGR_LOG("After update final Solution");
bool bUpdateFound2 = tabuSearch(initialSolution);
PGR_LOG("After Tabu Search");
if ((bUpdateFound == true) || (bUpdateFound2 == true)) {
iAttemptCount = 0;
}
}
m_bIsSolutionReady = true;
strError += " ";
return true;
}
int find_vrp_solution(vrp_vehicles_t *vehicles, size_t vehicle_count,
vrp_orders_t *orders, size_t order_count,
vrp_cost_element_t *costmatrix, size_t cost_count,
int depot_id,
vrp_result_element_t **results, size_t *result_count, char **err_msg) {
int res;
std::string strError;
try {
PGR_LOG("Before load order");
loadOrders(orders, static_cast<int>(order_count), depot_id);
PGR_LOG("After load order");
loadVehicles(vehicles, static_cast<int>(vehicle_count));
PGR_LOG("After load vehicles");
loadDistanceMatrix(costmatrix, static_cast<int>(cost_count), depot_id);
PGR_LOG("After load distance matrix");
res = solver.solveVRP(strError);
PGR_LOG("After VRP Solve");
}
catch(std::exception& e) {
*err_msg = (char *) e.what();
return -1;
}
catch(...) {
*err_msg = (char *) "Caught unknown exception!";
return -1;
}
if (res < 0) {
return res;
} else {
try {
CSolutionInfo solution;
CTourInfo ctour;
// bool bOK =
solver.getSolution(solution, strError);
auto totalRoute = solution.getTourInfoVector().size();
size_t totRows = 0;
for (size_t i = 0; i < totalRoute; i++) {
totRows += (solution.getTour(static_cast<int>(i)).getServedOrderCount() + 2);
}
*results = (vrp_result_element_t *) malloc(totRows * sizeof(vrp_result_element_t));
*result_count = totRows;
int cnt = 0;
for (size_t i = 0; i < totalRoute; i++) {
ctour = solution.getTour(static_cast<int>(i));
std::vector<int> vecOrder = ctour.getOrderVector();
auto totalOrder = vecOrder.size();
// For start depot
(*results)[cnt].order_id = ctour.getStartDepot();
(*results)[cnt].order_pos = 0;
(*results)[cnt].vehicle_id = ctour.getVehicleId();
(*results)[cnt].arrival_time = -1;
(*results)[cnt].depart_time = ctour.getStartTime(0);
cnt++;
// For each order
for (size_t j = 0; j < totalOrder; j++) {
(*results)[cnt].order_id = vecOrder[j];
(*results)[cnt].order_pos = static_cast<int>(j) + 1;
(*results)[cnt].vehicle_id = ctour.getVehicleId();
(*results)[cnt].depart_time = ctour.getStartTime(static_cast<int>(j) + 1);
(*results)[cnt].arrival_time = ctour.getStartTime(static_cast<int>(j) + 1) - solver.getServiceTime(vecOrder[j]);
cnt++;
}
// For return depot
(*results)[cnt].order_id = ctour.getEndDepot();
(*results)[cnt].order_pos = static_cast<int>(totalOrder) + 1;
(*results)[cnt].vehicle_id = ctour.getVehicleId();
(*results)[cnt].arrival_time = ctour.getStartTime(static_cast<int>(totalOrder) + 1);
(*results)[cnt].depart_time = -1;
cnt++;
}
}
catch(std::exception& e) {
*err_msg = (char *) e.what();
return -1;
}
catch(...) {
*err_msg = (char *) "Caught unknown exception!";
return -1;
}
}
return EXIT_SUCCESS;
}
CSolutionInfo CVRPSolver::generateInitialSolution() {
CSolutionInfo initialSolution;
PGR_LOG("Inside gen ini sol");
std::vector<int> vecOrders, vecVehicles;
for (unsigned int i = 0; i < m_vOrderInfos.size(); i++) {
vecOrders.push_back(m_vOrderInfos[i].getOrderId());
}
for (unsigned int i = 0; i < m_vVehicleInfos.size(); i++) {
vecVehicles.push_back(m_vVehicleInfos[i].getId());
}
initialSolution.init(vecOrders, static_cast<int>(vecOrders.size()), vecVehicles);
int iUnusedVehicles = static_cast<int>(initialSolution.getUnusedVehicleCount());
int iUnservedOrders = static_cast<int>(initialSolution.getUnservedOrderCount()); // m_viUnservedOrderIndex.size();
PGR_LOG("before while");
while (iUnusedVehicles && iUnservedOrders) {
CTourInfo curTour;
int vehicleIndex = rand() % iUnusedVehicles--;
int vehicleInd = m_mapVehicleIdToIndex[initialSolution.getUnusedVehicleAt(vehicleIndex)];
curTour.setVehicleInfo(m_vVehicleInfos[vehicleInd]); // m_viUnusedVehicleIndex[vehicleIndex]
initialSolution.removeVehicle(vehicleIndex);
curTour.setStartDepot(m_vDepotInfos[0].getDepotId());
curTour.setEndDepot(m_vDepotInfos[0].getDepotId());
// use a random seed to start to tour. (we can use better approach in future)
bool insertAvailable = true;
while (insertAvailable) {
insertAvailable = false;
std::pair<int, int> PotentialInsert; // first = insert_index, second = removed_order_index;
std::pair<int, double> bestInsert = std::make_pair(-1, DOUBLE_MAX); // first = order_insert_index, second = cost;
for (int i = 0; i < iUnservedOrders; ++i) {
int orderInd = m_mapOrderIdToIndex[initialSolution.getUnservedOrderAt(i)];
COrderInfo curOrder = m_vOrderInfos[orderInd];
std::pair<int, double> curInsert = getPotentialInsert(curTour, curOrder);
if (curInsert.second < bestInsert.second) {
insertAvailable = true;
bestInsert = curInsert;
PotentialInsert = std::make_pair(curInsert.first, i);
}
}
if (insertAvailable) {
if (insertOrder(curTour, initialSolution.getUnservedOrderAt(PotentialInsert.second), PotentialInsert.first)) {
iUnservedOrders--;
initialSolution.removeOrder(PotentialInsert.second);
}
}
}
initialSolution.addTour(curTour);
}
return initialSolution;
}
