TEST_F(PoliceDepotTest, vehicles) {
PoliceDepot depot(loc, entr, size, name, health);
EXPECT_NO_FATAL_FAILURE(depot.addVehicle(ptrCar0));
EXPECT_EQ(1, depot.getAvailableVehicles());
EXPECT_EQ(1, depot.getNrVehicles());
EXPECT_NO_FATAL_FAILURE(depot.addVehicle(ptrCar1));
EXPECT_EQ(2, depot.getAvailableVehicles());
EXPECT_EQ(2, depot.getNrVehicles());
EXPECT_NO_FATAL_FAILURE(ptrCar0->goUp());
EXPECT_EQ(1, depot.getAvailableVehicles());
EXPECT_EQ(2, depot.getNrVehicles());
EXPECT_NO_FATAL_FAILURE(ptrCar1->goUp());
EXPECT_EQ(0, depot.getAvailableVehicles());
EXPECT_EQ(2, depot.getNrVehicles());
EXPECT_NO_FATAL_FAILURE(ptrCar0->goDown());
EXPECT_EQ(1, depot.getAvailableVehicles());
EXPECT_EQ(2, depot.getNrVehicles());
EXPECT_NO_FATAL_FAILURE(ptrCar1->goDown());
EXPECT_EQ(2, depot.getAvailableVehicles());
EXPECT_EQ(2, depot.getNrVehicles());
}
void mtspSolution::update() {
checkError();
_fitness = 0;
unsigned int _depot = depot();
unsigned int waittime = 0;
unsigned int latetime = 0;
unsigned int movetime = 0;
_come[_route[_depot]] = _graph->early(_route[_depot]);
_move[_route[_depot]] = 0;
for (unsigned int i = 0; i < _size; i++) {
unsigned int here = (_depot + i) % _size;
unsigned int next = (_depot + i + 1) % _size;
_move[_route[here]] = _graph->time(_route[here], _route[next]);
_come[_route[next]] = _come[_route[here]] + _wait[_route[here]]
+ _move[_route[here]];
int wait_here = _graph->early(_route[next]) - _come[_route[next]];
int late_here = _come[_route[next]] - _graph->late(_route[next]);
_wait[_route[next]] = wait_here > 0 ? wait_here : 0;
_late[_route[next]] = late_here > 0 ? late_here : 0;
latetime += _late[_route[next]];
waittime += _wait[_route[next]];
movetime += _move[_route[here]];
}
_fitness -= movetime;
_fitness -= latetime*_graph->latePenalty();
_fitness -= waittime*_graph->waitPenalty();
}
void mtspSolution::info(ostream& os) const {
checkError();
unsigned int _depot = depot();
os << "ID " << "\t" << "Come" << "\t" << "Wait" << "\t" << "Late"
<< "\t" << "Move" << "\t" << "EARLY" << "\t" << "LATE" << endl;
os << _route[_depot] << "\t" << _graph->early(_route[_depot]) << "\t" << 0
<< "\t" << 0 << "\t" << _graph->time(_route[_depot], _route[(_depot + 1)%_size])
<< "\t" << _graph->early(_route[_depot])
<< "\t" << _graph->late(_route[_depot]) << endl;
for (unsigned int i = 1; i <= _size; i++) {
unsigned int here = (_depot + i) % _size;
os << _route[here]
<< "\t" << _come[_route[here]]
<< "\t" << _wait[_route[here]]
<< "\t" << _late[_route[here]]
<< "\t" << _move[_route[here]]
<< "\t" << _graph->early(_route[here])
<< "\t" << _graph->late(_route[here]) << endl;
}
// os << _route[0];
// for (unsigned int i = 1; i < _size; i++) {
// os << " " << _route[i];
// }
}
void mtspSolution::print(ostream& os) const {
checkError();
unsigned int _depot = depot();
for (unsigned int i = 0; i < _size; i++) {
os << _route[(_depot + i) % _size] << " ";
}
}
TEST_F(PoliceDepotTest, getters) {
PoliceDepot depot(loc, entr, size, name, health);
EXPECT_EQ(loc, depot.getLocation());
EXPECT_EQ(size, depot.getSize());
EXPECT_EQ(health, depot.getHealth());
EXPECT_EQ(entr, depot.getEntrance());
EXPECT_EQ(name, depot.getName());
EXPECT_EQ(0, depot.getNrVehicles());
EXPECT_EQ(0, depot.getAvailableVehicles());
}
TEST_F(PoliceDepotTest, fire) {
PoliceDepot depot(loc, entr, size, name, health);
EXPECT_FALSE(depot.isBurning());
EXPECT_DEATH(depot.burningDown(), ""); // ooops, depot is not on fire
EXPECT_DEATH(depot.stopFire(), ""); // oops, depot is not on fire
EXPECT_FALSE(depot.isDead());
EXPECT_FALSE(depot.startSpreadingFire());
EXPECT_FALSE(depot.startRepair());
EXPECT_DEATH(depot.repair(), ""); // oops, Depot has still it's original health
EXPECT_FALSE(depot.isFireTruckAssigned());
EXPECT_DEATH(depot.assignFireTruck(), ""); // oops, the Depot is not on fire
EXPECT_DEATH(depot.withdrawFireTruckAssignment(), ""); // oops, there is no firetruck assigned
// okay, start the fire scenario
EXPECT_NO_FATAL_FAILURE(depot.setFire());
EXPECT_TRUE(depot.isBurning());
EXPECT_NO_FATAL_FAILURE(depot.burningDown());
EXPECT_EQ(health - reducer, depot.getHealth());
EXPECT_FALSE(depot.isDead());
EXPECT_FALSE(depot.startSpreadingFire()); // No, it has lost "only" 2 health points
EXPECT_FALSE(depot.startRepair());
EXPECT_DEATH(depot.repair(), ""); // oops, Depot is still on fire
// let's send a firetruck
EXPECT_NO_FATAL_FAILURE(depot.assignFireTruck());
EXPECT_TRUE(depot.isFireTruckAssigned());
// extinguish fire, repair and sendback firetruck
EXPECT_DEATH(depot.withdrawFireTruckAssignment(), ""); // oops, Depot is still on fire
EXPECT_NO_FATAL_FAILURE(depot.stopFire());
EXPECT_FALSE(depot.isBurning());
EXPECT_TRUE(depot.startRepair());
EXPECT_NO_FATAL_FAILURE(depot.repair());
EXPECT_EQ(health - reducer + 0.5, depot.getHealth());
EXPECT_NO_FATAL_FAILURE(depot.withdrawFireTruckAssignment());
EXPECT_FALSE(depot.isFireTruckAssigned());
EXPECT_FALSE(depot.isDead());
// fire breaks out again
EXPECT_NO_FATAL_FAILURE(depot.setFire());
EXPECT_TRUE(depot.isBurning());
EXPECT_NO_FATAL_FAILURE(depot.burningDown());
EXPECT_EQ(health - reducer + 0.5 - reducer, depot.getHealth());
EXPECT_FALSE(depot.isDead());
EXPECT_TRUE(depot.startSpreadingFire());
// let them burning down 'till death
EXPECT_NO_FATAL_FAILURE(depot.burningDown());
EXPECT_TRUE(depot.isDead());
EXPECT_EQ(health - reducer + 0.5 - reducer - reducer, depot.getHealth());
// now, Depot is not on fire anymore
EXPECT_FALSE(depot.isBurning());
EXPECT_FALSE(depot.startRepair()); // you cannot repair a dead Depot
EXPECT_FALSE(depot.startSpreadingFire());
}
TEST_F(PoliceDepotTest, construct) {
EXPECT_NO_FATAL_FAILURE(PoliceDepot depot(loc, entr, size, name, health));
}
void CVRP::init(VRP V) {
cout.setf(ios::fixed | ios::showpoint);
cout.precision(2);
std::cout.imbue(
std::locale(std::cout.getloc(), new punct_facet<char, ','>));
bool init1 = false;
if (init1) {
setNroCustomers(V.getBusStops().size() + 1);
Customer depot(V.getCoorSchool().getX(), V.getCoorSchool().getY(),
V.getCoorSchool().getCapacity());
std::vector<Stop> a;
a.insert(a.begin() + 0, V.getCoorSchool());
std::vector<Stop> b = V.getBusStops();
//Set AllCustomer but not depot
std::vector<Customer> allCustNotDepot;
for (size_t i = 0; i < V.getBusStops().size(); i++) {
Stop stop = V.getBusStops().at(i);
Customer customer(stop.getX(), stop.getY(), stop.getCapacity());
allCustNotDepot.insert(allCustNotDepot.begin() + i, customer);
}
setAllCustNoDepot(allCustNotDepot);
a.insert(a.end(), b.begin(), b.end());
std::vector<Customer> allCustomers;
for (size_t i = 0; i < a.size(); i++) {
Stop stop = a.at(i);
Customer customer(stop.getX(), stop.getY(), stop.getCapacity());
allCustomers.insert(allCustomers.begin() + i, customer);
}
for (size_t i = 0; i < allCustomers.size(); i++) {
Customer customer = allCustomers.at(i);
cout << "(" << customer.getX() << ", " << customer.getY() << ", "
<< customer.getDemand() << ")" << endl;
}
setDepot(depot);
setAllCustomers(allCustomers);
setK(V.getK());
setC(V.getCk());
setKmin(V.getKmin());
} else {
setNroCustomers(V.getBusAssigned().size() + 1);
Customer depot(V.getCoorSchool().getX(), V.getCoorSchool().getY(),
V.getCoorSchool().getCapacity());
std::vector<Stop> a;
a.insert(a.begin() + 0, V.getCoorSchool());
std::vector<Stop> b = V.getBusAssigned();
//Set AllCustomer but not depot
std::vector<Customer> allCustNotDepot;
for (size_t i = 0; i < V.getBusAssigned().size(); i++) {
Stop stop = V.getBusAssigned().at(i);
Customer customer(stop.getX(), stop.getY(), stop.getCapacity());
allCustNotDepot.insert(allCustNotDepot.begin() + i, customer);
}
setAllCustNoDepot(allCustNotDepot);
a.insert(a.end(), b.begin(), b.end());
std::vector<Customer> allCustomers;
for (size_t i = 0; i < a.size(); i++) {
Stop stop = a.at(i);
Customer customer(stop.getX(), stop.getY(), stop.getCapacity());
allCustomers.insert(allCustomers.begin() + i, customer);
}
cout << "List of customers! the first customert is the depot." << endl;
for (size_t i = 0; i < allCustomers.size(); i++) {
Customer customer = allCustomers.at(i);
cout << "(" << customer.getX() << ", " << customer.getY() << ", "
<< customer.getDemand() << ")" << endl;
}
setDepot(depot);
setAllCustomers(allCustomers);
setK(V.getK());
setC(V.getCk());
setKmin(V.getKmin());
}
//Validation of the numbers of enters to the depot
//Initialization of x
//Initialization of d
std::vector<Customer> allCustomers = getAllCustomers();
int nro_customers = getNroCustomers();
double** d_cvpr = new double*[nro_customers];
double** s_cvpr = new double*[nro_customers];
bool** x_cvpr = new bool*[nro_customers];
for (int i = 0; i < nro_customers; i++) {
d_cvpr[i] = new double[nro_customers];
x_cvpr[i] = new bool[nro_customers];
s_cvpr[i] = new double[nro_customers];
}
cout << "Save the distance in a d array of array" << endl;
for (int i = 0; i < nro_customers; i++) {
Customer customer = allCustomers.at(i);
cout << "(" << customer.getX() << ", " << customer.getY() << ")"
<< endl;
for (int j = 0; j < nro_customers; j++) {
Customer pivot = allCustomers.at(j);
double distance = getDistanceIJ(customer, pivot);
d_cvpr[i][j] = distance;
x_cvpr[i][j] = false;
}
}
cout << "Imprimir distance from i to j:" << endl;
for (int i = 0; i < nro_customers; i++) {
for (int j = 0; j < nro_customers; j++) {
cout << d_cvpr[i][j] << " ";
}
cout << "\n";
}
cout << "Imprimir x from i to j." << endl;
for (int i = 0; i < nro_customers; i++) {
for (int j = 0; j < nro_customers; j++) {
cout << x_cvpr[i][j] << " ";
}
cout << "\n";
}
setD(d_cvpr);
//CREATE CONSTRUCTIVE - Saving Computation
std::vector<Saving> savingList;
int count1 = 0;
int nro_buses = getK();
std::vector<Customer> allCSaving = getAllCustNoDepot();
for (int i = 0; i < nro_buses; i++) {
Customer customer = allCSaving.at(i);
for (int j = 0; j < nro_buses; j++) {
if (i != j) {
Customer pivot = allCSaving.at(j);
double d1 = d_cvpr[i][0];
double d2 = d_cvpr[0][j];
double d3 = d_cvpr[i][j];
s_cvpr[i][j] = d1 + d2 - d3;
Saving save(customer, pivot, s_cvpr[i][j]);
savingList.insert(savingList.begin() + count1, save);
count1++;
}
}
}
//Ordering
Saving temp;
int flag = 1;
for (size_t i = 1; i < savingList.size() && flag; i++) {
flag = 0;
for (size_t j = 0; j < savingList.size() - 1; j++) {
if (savingList.at(j + 1).getSavingPeso()
> savingList.at(j).getSavingPeso()) {
temp = savingList.at(j);
savingList.at(j) = savingList.at(j + 1);
savingList.at(j + 1) = temp;
flag = 1;
}
}
}
cout << "Saving List after ordered." << endl;
int m = 0;
for (size_t i = 0; i < savingList.size(); i++) {
Saving save = savingList.at(i);
Customer c1 = save.getSavingC1();
Customer c2 = save.getSavingC2();
double peso = save.getSavingPeso();
cout << "i = (" << c1.getX() << ", " << c1.getY() << ") j = ("
<< c2.getX() << ", " << c2.getY() << ") peso = " << peso
<< endl;
}
cout << "Insertion." << endl;
std::vector<std::vector<Customer> > routes;
for (int i = 0; i < nro_buses; i++) {
Customer customer = getAllCustNoDepot().at(i);
//Create routes
std::vector<Customer> route;
route.insert(route.begin() + 0, getDepot());
route.insert(route.begin() + 1, customer);
route.insert(route.begin() + 2, getDepot());
routes.insert(routes.begin() + m, route);
m++;
route.clear();
}
//Routes
cout << "Print route for each new route:" << endl;
for (size_t i = 0; i < routes.size(); i++) {
std::vector<Customer> customers = routes.at(i);
map.insert(pair<int, std::vector<Customer> >(i, customers));
cout << "route #" << i << endl;
for (size_t j = 0; j < customers.size(); j++) {
Customer c = customers.at(j);
cout << "(" << c.getX() << ", " << c.getY() << ") - ";
}
cout << "\n";
}
//Best feasible merge
//1.- look for 0, j
/*
* Step 2. Best feasible merge (Parallel version)
Starting from the top of the savings list, execute the following:
Given a saving sij, determine whether there exist two routes that can
feasibility be merged:
One starting with (0,j)
One ending with (i,0)
Combine these two routes by deleting (0,j) and (i,0) and introducing (i,j).
*
*/
cout << "=========================================================="
<< endl;
cout << "Starting saving List process" << endl;
for (size_t i = 0; i < savingList.size(); i++) {
bool firstCondition = false;
unsigned int route_number = 0;
bool secondCondition = false;
unsigned int route_number2 = 0;
Saving saving = savingList.at(i);
Customer customer1 = saving.getSavingC1();
Customer customer2 = saving.getSavingC2();
Customer firstElement;
Customer secondElement;
cout << "=======Print route each time new SavingList is used========="
<< endl;
cout << "For saving customer1 = (" << customer1.getX() << ", "
<< customer1.getY() << ")" << endl;
cout << "For saving customer2 = (" << customer2.getX() << ", "
<< customer2.getY() << ")" << endl;
for (size_t i = 0; i < routes.size(); i++) {
std::vector<Customer> customers = routes.at(i);
cout << "route #" << i << endl;
for (size_t j = 0; j < customers.size(); j++) {
Customer c = customers.at(j);
cout << "(" << c.getX() << ", " << c.getY() << ") - ";
}
cout << "\n";
}
//First Condition
for (size_t j = 0; j < routes.size(); j++) {
std::vector<Customer> customersRoutes = routes.at(j);
bool c1IsFound = false;
bool depotIsFound = false;
unsigned int pivot = 0;
for (size_t k = 0; k < customersRoutes.size(); k++) {
Customer c = customersRoutes.at(k);
if (compareCustomers(c, customer1)) {
c1IsFound = true;
pivot = k;
}
if (c1IsFound && (pivot + 1 == k)) {
if (compareCustomers(getDepot(), c)) {
depotIsFound = true;
firstElement = customersRoutes.at(pivot);
cout << "first Element = (" << firstElement.getX()
<< ", " << firstElement.getY() << ")" << endl;
route_number = j;
}
}
}
if (c1IsFound && depotIsFound) {
map.insert(
pair<int, std::vector<Customer> >(route_number,
routes.at(route_number)));
firstCondition = true;
} else {
cout << "Not" << endl;
}
}
//Second condition
for (size_t j = 0; j < routes.size(); j++) {
std::vector<Customer> customersRoutes = routes.at(j);
bool c2IsFound = false;
bool depot2IsFound = false;
unsigned int pivot2 = 0;
for (size_t k = 0; k < customersRoutes.size(); k++) {
Customer c = customersRoutes.at(k);
if (compareCustomers(getDepot(), c)) {
depot2IsFound = true;
pivot2 = k;
}
if (depot2IsFound && (pivot2 + 1 == k)) {
if (compareCustomers(c, customer2)) {
c2IsFound = true;
secondElement = customersRoutes.at(pivot2 + 1);
cout << "second Element = (" << secondElement.getX()
<< ", " << secondElement.getY() << ")" << endl;
route_number2 = j;
}
}
}
if (depot2IsFound && c2IsFound) {
map.insert(
pair<int, std::vector<Customer> >(route_number2,
routes.at(route_number2)));
secondCondition = true;
} else {
cout << "Not2" << endl;
}
}
if (firstCondition && secondCondition) {
if (route_number != route_number2) {
cout << "route 1 = " << route_number << endl;
cout << "route 2 = " << route_number2 << endl;
cout << "first Element = (" << firstElement.getX() << ", "
<< firstElement.getY() << ")" << endl;
cout << "second Element = (" << secondElement.getX() << ", "
<< secondElement.getY() << ")" << endl;
cout << "soy sensacional" << endl;
std::vector<Customer> route1 = routes.at(route_number);
for (size_t r = 0; r < route1.size(); r++) {
Customer c = route1.at(r);
cout << "(" << c.getX() << ", " << c.getY() << ") -";
}
cout << endl;
//remote the depot
for (size_t r = 0; r < route1.size(); r++) {
Customer customer = route1.at(r);
if (compareCustomers(customer, getDepot())) {
route1.erase(route1.begin() + r);
}
}
std::vector<Customer> route2 = routes.at(route_number2);
for (size_t r = 0; r < route2.size(); r++) {
Customer c = route2.at(r);
cout << "(" << c.getX() << ", " << c.getY() << ") -";
}
cout << endl;
for (size_t r = 0; r < route2.size(); r++) {
Customer customer = route2.at(r);
if (compareCustomers(customer, getDepot())) {
route2.erase(route2.begin() + r);
}
}
route1.insert(route1.end(), route2.begin(), route2.end());
cout << "Nueva ruta generada por las rutas " << route_number
<< " y " << route_number2 << endl;
for (size_t l = 0; l < route1.size(); l++) {
Customer customer = route1.at(l);
cout << "(" << customer.getX() << ", " << customer.getY()
<< ") - ";
}
routes.erase(routes.begin() + route_number);
routes.erase(routes.begin() + route_number2 - 1);
cout << "After remove the routes " << route_number << " and "
<< route_number2 << endl;
for (size_t i = 0; i < routes.size(); i++) {
std::vector<Customer> customers = routes.at(i);
cout << "route #" << i << endl;
for (size_t j = 0; j < customers.size(); j++) {
Customer c = customers.at(j);
cout << "(" << c.getX() << ", " << c.getY() << ") - ";
}
cout << "\n";
}
routes.push_back(route1);
cout << "after add the new route merged." << endl;
for (size_t i = 0; i < routes.size(); i++) {
std::vector<Customer> customers = routes.at(i);
cout << "route #" << i << endl;
for (size_t j = 0; j < customers.size(); j++) {
Customer c = customers.at(j);
cout << "(" << c.getX() << ", " << c.getY() << ") - ";
}
cout << "\n";
}
cout << "routes.size() = " << routes.size() << endl;
}
cout << "=======end saving element from the list=========" << endl;
} else {
//Not to merge
}
}
//Route Extension
//Routes
cout << "Print routes after the first merge process:" << endl;
for (size_t i = 0; i < routes.size(); i++) {
std::vector<Customer> customers = routes.at(i);
cout << "route #" << i << endl;
for (size_t j = 0; j < customers.size(); j++) {
Customer c = customers.at(j);
cout << "(" << c.getX() << ", " << c.getY() << ") - ";
}
cout << "\n";
}
}
TEST_F(HospitalTest, construct) {
EXPECT_NO_FATAL_FAILURE(Hospital depot(loc, entr, size, name, health));
}
