VRPSolverEasy

https://vrpsolvereasy.readthedocs.io/en/latest/
Admin
VRPSolverEasy is a Python library for modeling and solving rich vehicle routing problems using exact...
Tokens:25,222
Snippets:238
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install via pip

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Installation/index.html

Standard command to install the free version of VRPSolverEasy.

```bash
python -m pip install VRPSolverEasy
```

--------------------------------

### Install via git

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Installation/index.html

Command to install the package after downloading and extracting it into a local directory.

```bash
python -m pip install .
```

--------------------------------

### Example output for toy instance

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Example output for the toy instance after printing the solution. Shows customer IDs with time windows, solution cost, and routes with end times, loads, and total costs.

```text
Customer IDs and time windows:
Customer 2: (id: 2, tw: [20, 100])
Customer 3: (id: 3, tw: [0, 100])
Customer 4: (id: 4, tw: [180, 250])
Customer 5: (id: 5, tw: [0, 100]), (id: 8, tw: [200, 300]), (id: 9, tw: [400, 500])
Customer 6: (id: 6, tw: [80, 130])
Customer 7: (id: 7, tw: [0, 50]), (id: 10, tw: [500, 600])

Solution cost : 980.2435999992152 

Route for vehicle 2:
ID : 0 --> 8 --> 10
End time : 0.0 --> 250.0 --> 550.0
Load : 0.0 --> 20.0 --> 50.0
Total cost : 158.767

Route for vehicle 2:
ID : 0 --> 2
End time : 0.0 --> 70.0
Load : 0.0 --> 35.0
Total cost : 35.811

Route for vehicle 3:
ID : 1 --> 6 --> 4
End time : 0.0 --> 130.0 --> 230.0
Load : 0.0 --> 80.0 --> 180.0
Total cost : 784.6656
```

--------------------------------

### Example solution output

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Example/index.html

Example output of the solved VRPTW instance, showing three routes with IDs, names, end times, loads, and total costs.

```text
Route for vehicle 1:
    ID : 0 --> 2 --> 5 --> 0
    Name : DEPOT --> Vermont, USA --> Rhode Island, the US --> DEPOT
    End time : 0.0 --> 16.807 --> 19.259 --> 37.230000000000004
    Load : 0.0 --> 300.0 --> 1041.0 --> 1041.0
    Total cost : 372.29999999999995

Route for vehicle 1:
    ID : 0 --> 1 --> 3 --> 0
    Name : DEPOT --> West Virginia, USA --> Texas, the USA --> DEPOT
    End time : 0.0 --> 10.548 --> 31.625 --> 48.728
    Load : 0.0 --> 500.0 --> 1100.0 --> 1100.0
    Total cost : 487.2800000000001

Route for vehicle 1:
    ID : 0 --> 4 --> 6 --> 0
    Name : DEPOT --> South Dakota, the US --> Oregon, the US --> DEPOT
    End time : 0.0 --> 10.5 --> 31.006 --> 62.010000000000005
    Load : 0.0 --> 658.0 --> 1094.0 --> 1094.0
    Total cost : 620.1

```

--------------------------------

### Example instance toy.txt

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Example instance content from demos/data/RichVRP/toy.txt. It defines two depots, one big vehicle type, one small vehicle type, and six customers with their attributes.

```text
2
0 0 0 0 1000
1 100 100 0 500
200 400 3.2 1
50 20 1.0 4
6
2 5 15 35 50 0 1 1 20 100
3 5 25 15 50 1 1 1 0 100
4 15 15 100 50 0 0 1 180 250
5 75 60 20 50 0 1 3 0 100 200 300 400 500
6 50 50 80 50 0 0 1 80 130
7 35 75 30 50 0 0 2 0 50 500 600
```

--------------------------------

### Upgrade setuptools

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Installation/index.html

Recommended command to upgrade the setuptools package before installation.

```bash
python -m pip install --upgrade setuptools
```

--------------------------------

### Example solution output

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/RichVRP.html

Displays the expected output format for customer IDs, time windows, and vehicle routes.

```text
Customer IDs and time windows:
Customer 2: (id: 2, tw: [20, 100])
Customer 3: (id: 3, tw: [0, 100])
Customer 4: (id: 4, tw: [180, 250])
Customer 5: (id: 5, tw: [0, 100]), (id: 8, tw: [200, 300]), (id: 9, tw: [400, 500])
Customer 6: (id: 6, tw: [80, 130])
Customer 7: (id: 7, tw: [0, 50]), (id: 10, tw: [500, 600])

Solution cost : 980.2435999992152

Route for vehicle 2:
ID : 0 --> 8 --> 10
End time : 0.0 --> 250.0 --> 550.0
Load : 0.0 --> 20.0 --> 50.0
Total cost : 158.767

Route for vehicle 2:
ID : 0 --> 2
End time : 0.0 --> 70.0
Load : 0.0 --> 35.0
Total cost : 35.811

Route for vehicle 3:
ID : 1 --> 6 --> 4
End time : 0.0 --> 130.0 --> 230.0
Load : 0.0 --> 80.0 --> 180.0
Total cost : 784.6656
```

--------------------------------

### Example data object contents

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/CVRP.rst.txt

Example contents of the data object returned by read_instance. Shows the structure of the instance data.

```python
vehicle_capacity = 300
nb_customers = 3
cust_demands = [15,52,65]
cust_coordinates = [[55.21,44.36],[54.31,65.23],[57.81,53.27]]
depot_coordinates = [54.69,57.36]
```

--------------------------------

### Example data structure

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Example of the contents of the 'data' dictionary returned by read_instance, showing vehicle capacity, number of customers, customer demands, customer coordinates, and depot coordinates.

```python
vehicle_capacity = 300
nb_customers = 3
cust_demands = [15,52,65]
cust_coordinates = [[55.21,44.36],[54.31,65.23],[57.81,53.27]]
depot_coordinates = [54.69,57.36]

```

--------------------------------

### Install Python for Apple Silicon

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Installation/index.html

Command to install the x86_64 version of Python using Homebrew on Apple Silicon processors.

```bash
arch -x86_64 /usr/local/homebrew/bin/brew install python
```

--------------------------------

### Example MDVRP data structure

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/MDVRP.html

Example contents of the data object returned by read_instance. Shows the structure of the instance data for a small MDVRP instance.

```python
nb_depots = 2
nb_customers = 3
vehicle_capacity = 60
cust_demands = [15,52,65]
cust_coordinates = [[55.21,44.36],[57.81,53.27]]
depot_coordinates = [[54.69,57.36],[54.31,65.23]]

```

--------------------------------

### Example HFVRP data object

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/HFVRP.rst.txt

Example contents of the data object returned by read_hfvrp_instance. Shows the structure of the instance data used in the demo.

```python
nb_vehicle_types = 2
nb_customers = 3
vehicle_capacities = [300,250]
vehicle_fixed_costs = [12,24]
vehicle_var_costs = [12,24]
vehicle_max_numbers = [3,3]
cust_demands = [15,52,65]
cust_coordinates = [[55.21,44.36],[54.31,65.23],[57.81,53.27]]
depot_coordinates = [54.69,57.36]
```

--------------------------------

### Run VRPSolverEasy on Apple Silicon

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Installation/index.html

Commands to install and run VRPSolverEasy using the x86_64 Python executable.

```bash
/usr/local/homebrew/bin/python3 -m pip install VRPSolverEasy
/usr/local/homebrew/bin/python3 VRPSolverEasy/demos/CVRP.py -i VRPSolverEasy/demos/data/CVRP/A-n32-k5.vrp
```

--------------------------------

### Run CVRPTW instance from command line

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/CVRPTW.rst.txt

Run a CVRPTW instance from the command line after installation. Specify the instance path, time limit, and solver name. CPLEX requires the academic version and, on Windows, its path via -p.

```text
python CVRPTW.py -i <instance path> -t <time limit> -s <solver_name>
```

--------------------------------

### Add depots and customers

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/MDVRP.html

Add depots and customers to the model. Depot IDs start at 0 and customer IDs start at nb_depots + 1. Depot and customer IDs must be different.

```python
# add depots
for i in range(data.nb_depots):
    model.add_depot(id=i)

# add all customers
for i in range(data.nb_customers):
    model.add_customer(id=i + data.nb_depots + 1,
                       demand=data.cust_demands[i])

```

--------------------------------

### Add depot and customers

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Adds a depot with ID 0 and then adds all customers with IDs starting from 1, each with a demand from the data.

```python
# add depot
model.add_depot(id=0)

# add all customers
for i in range(data.nb_customers):
    model.add_customer(id=i+1,
                       demand=data.cust_demands[i])
```

--------------------------------

### Example of data contents

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRPTW.html

Shows the structure of the data returned by read_cvrptw_instance, including vehicle capacity, max number of vehicles, customer demands, coordinates, depot info, and time windows.

```python
vehicle_capacity = 300
max_number = 2 #maximum number of vehicles
nb_customers = 3
cust_demands = [15,52,65]
cust_coordinates = [[55.21,44.36],[54.31,65.23],[57.81,53.27]]
depot_coordinates = [54.69,57.36]
depot_service_time = 0
depot_tw_end = 1
depot_tw_begin = 5
cust_tw_begin = [2,3,5]
cust_tw_end = [4,8,10]
cust_service_time = [1,1,1.3]

```

--------------------------------

### Add depots and customers

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/MDVRP.rst.txt

Add depots and customers to the model. Depot and customer IDs must be different; customer IDs start after the depot IDs.

```python
# add depots
    for i in range(data.nb_depots):
        model.add_depot(id=i)

    # add all customers
    for i in range(data.nb_customers):
        model.add_customer(id=i + data.nb_depots + 1,
                           demand=data.cust_demands[i])
```

--------------------------------

### Add depot and customers to HFVRP model

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/HFVRP.rst.txt

Add the depot (id 0) and all customers with their demands. Customer ids start at 1.

```python
# add depot
model.add_depot(id=0)

# add all customers
for i in range(data.nb_customers):
    model.add_customer(id=i+1, 
                       demand=data.cust_demands[i])
```

--------------------------------

### Create model and add vehicle type

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Creates a solver model and adds a vehicle type with ID 1, start and end point at depot 0, maximum number of vehicles equal to the number of customers, capacity from data, and variable cost per distance of 1. The ID must be at least 1.

```python
# create model
model = solver.Model()

# add vehicle type
model.add_vehicle_type(id=1, #id cannot be less than 1
                       start_point_id=0,
                       end_point_id=0,
                       max_number=data.nb_customers,
                       capacity=data.vehicle_capacity,
                       var_cost_dist=1)
```

--------------------------------

### Initialize and Configure VRPSolverEasy Model

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Example/index.rst.txt

Initializes the solver model and adds vehicle types, the depot, customers, and links between points.

```python
# Initialisation
model = solver.Model()

# Add vehicle type
model.add_vehicle_type(
    id=1,
    start_point_id=0,
    end_point_id=0,
    name="VEH1",
    capacity=1100,
    max_number=6,
    var_cost_dist=cost_per_distance,
    tw_end=5000)

# Add depot
model.add_depot(id=0, name="D1", tw_begin=0, tw_end=5000)

coordinates_keys = list(coordinates.keys())
# Add Customers
for i in range(1, nb_point):
    model.add_customer(
        id=i,
        name=coordinates_keys[i],
        demand=demands[i],
        tw_begin=begin_time,
        tw_end=end_time)

# Add links
coordinates_values = list(coordinates.values())
for i in range(0, 7):
    for j in range(i + 1, 7):
        dist = compute_euclidean_distance(coordinates_values[i][0],
                                          coordinates_values[j][0],
                                          coordinates_values[i][1],
                                          coordinates_values[j][1])
        model.add_link(
            start_point_id=i,
            end_point_id=j,
            distance=dist,
            time=dist)
```

--------------------------------

### Run MDVRP instance from command line

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/MDVRP.html

Run the MDVRP demo from the command line. Specify the instance path, time limit, and solver name. The CPLEX solver requires the academic version and, on Windows, its path must be given with the -p flag.

```bash
python MDVRP.py -i <instance path> -t <time limit> -s <solver_name>

```

--------------------------------

### Read instance and create model

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Reads the instance file and creates the solver model. The returned data object is of class DataRichVrp and holds lists of Depot, Vehicle, and Customer objects.

```python
data = read_richvrp_instance(instance_name)
model = solver.Model()
```

--------------------------------

### Run HFVRP demo from Python file

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/HFVRP.rst.txt

Run the demo by uncommenting this line in HFVRP.py and specifying the instance name directly in the file.

```python
solve_demo("c50_13fsmd.txt")
```

--------------------------------

### Run CVRP instance via command line

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Run the CVRP demo from the command line, specifying the instance path, time limit, and solver name. The CPLEX solver requires the academic version and, on Windows, its path must be given with the -p option.

```bash
python CVRP.py -i <instance path> -t <time limit> -s <solver_name>

```

--------------------------------

### Initialize Model and Vehicle Type

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRPTW.html

Create a new solver model and define the vehicle type with capacity and time window constraints.

```python
# create model
model = solver.Model()

# add vehicle type
model.add_vehicle_type(id=1,
                       start_point_id=0,
                       end_point_id=0,
                       max_number=data.max_number,
                       capacity=data.vehicle_capacity,
                       tw_begin=data.depot_tw_begin,
                       tw_end=data.depot_tw_end,
                       var_cost_dist=1
                       )
```

--------------------------------

### Run HFVRP.py from command line

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/HFVRP.rst.txt

Run the HFVRP demo from the command line. The -i flag specifies the instance file, -t sets the time limit, and -s selects the solver. When using the CPLEX solver on Windows, add -p <path to CPLEX>.

```bash
python HFVRP.py -i <instance path> -t <time limit> -s <solver_name>
```

--------------------------------

### Run CVRP instance via Python file

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Run the CVRP demo by uncommenting the last line in CVRP.py and specifying the instance name directly in the file.

```python
solve_demo("A-n36-k5.vrp")

```

--------------------------------

### Depot

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Solver%20API/index.html

The Depot class represents a depot point in the graph. It is used to define the starting and ending points for vehicles in the routing problem.

```APIDOC
## Depot

### Description
Define a point depot of graph.

### Constructor

Depot(id, name='', cost=0.0, service_time=0.0, ...)

### Parameters
- **id** (int) - Required - The unique identifier of the depot.
- **name** (str) - Optional - The name of the depot.
- **cost** (float) - Optional - The cost associated with the depot.
- **service_time** (float) - Optional - The service time at the depot.
- **...** - Additional parameters as defined in the source.
```

--------------------------------

### Print customer IDs and time windows, then print solution

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Prints the customer IDs and time windows, then prints the solution if defined. The first block iterates over customers and their time windows; the second checks whether a solution exists before printing it.

```python
print("\nCustomer IDs and time windows:")
for customer in data.customers:
    ids_and_tws = []
    for i, point_id in enumerate(customer_ids[customer.id]):
        ids_and_tws.append(f"(id: {point_id}, tw: {list(customer.time_windows[i])})")
    print(f"Customer {customer.id}: {', '.join(ids_and_tws)}")
```

```python
if (model.solution.is_defined())
    print(model.solution)
```

--------------------------------

### Run RichVRP.py from command line

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Command-line invocation to solve an instance with the RichVRP demo. Specify the instance path, time limit, and solver name. CPLEX solver requires the academic version and, on Windows, its path via -p.

```bash
python RichVRP.py -i <instance path> -t <time limit> -s <solver_name>
```

--------------------------------

### Define VRPTW data

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Example/index.html

Defines the input data for the VRPTW example: cost per distance, time window bounds, number of points, coordinates of the depot and customers, and their demands.

```python
# data
cost_per_distance = 10
begin_time = 0
end_time = 5000
nb_point = 7

# map with names and coordinates
coordinates = {"Wisconsin, USA": (44.50, -89.50),  # depot
               "West Virginia, USA": (39.000000, -80.500000),
               "Vermont, USA": (44.000000, -72.699997),
               "Texas, the USA": (31.000000, -100.000000),
               "South Dakota, the US": (44.500000, -100.000000),
               "Rhode Island, the US": (41.742325, -71.742332),
               "Oregon, the US": (44.000000, -120.500000)
               }

# demands of points
demands = [0, 500, 300, 600, 658, 741, 436]

```

--------------------------------

### Add vehicle types for each depot

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/MDVRP.html

Define a separate vehicle type for each depot. The start and end point IDs correspond to the depot ID. The maximum number of vehicles cannot be less than the number of customers.

```python
# add vehicle types
for i in range(data.nb_depots):
    model.add_vehicle_type(id=i + 1,
                           start_point_id=i,
                           end_point_id=i,
                           capacity=data.vehicle_capacity,
                           max_number=data.nb_customers,
                           var_cost_dist=1)

```

--------------------------------

### Run demo by uncommenting solve_demo line

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRPTW.html

In the demo file CVRPTW.py, uncomment the last line to specify the instance name directly.

```python
solve_demo("R101.txt")

```

--------------------------------

### Run CVRPTW instance from Python file

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/CVRPTW.rst.txt

Run a specific instance by uncommenting this line in the demo file CVRPTW.py. Replace the filename with the desired instance.

```python
solve_demo("R101.txt")
```

--------------------------------

### Print solution if defined

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Example/index.html

Prints the solution if it is defined.

```python
if model.solution.is_defined():
    print(model.solution)

```

--------------------------------

### Add Depot and Customers

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRPTW.html

Register the depot and iterate through customer data to add them to the model with specific service times, time windows, and demands.

```python
# add depot
model.add_depot(id=0,
                service_time=data.depot_service_time,
                tw_begin=data.depot_tw_begin,
                tw_end=data.depot_tw_end)

# add all customers
for i in range(data.nb_customers):
    model.add_customer(id=i + 1,
                       service_time=data.cust_service_time[i],
                       tw_begin=data.cust_tw_begin[i],
                       tw_end=data.cust_tw_end[i],
                       demand=data.cust_demands[i])
```

--------------------------------

### Print the solution

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/MDVRP.html

Print the solution if it is defined. Alternatively, you can analyze the solution manually by retrieving each route, as shown in the CVRP demo.

```python
if (model.solution.is_defined())
    print(model.solution)

```

--------------------------------

### Parameters

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Solver%20API/index.html

Defines the Parameters class with its constructor, properties, and methods for configuring solver parameters.

```APIDOC
## Parameters

### Description
Define all parameters from model.

### Constructor
`Parameters(time_limit=300.0, upper_bound=1000000, heuristic_used=False, time_limit_heuristic=20.0, config_file='', solver_name='CLP', print_level=-1, action='solve', cplex_path='')`

### Parameters
- **time_limit** (float) - Optional - represents the limit time of resolution
- **upper_bound** (float) - Optional - represents the cost we want to reach
- **heuristic_used** (bool) - Optional - getter function of heuristic_used
- **time_limit_heuristic** (float) - Optional - getter function of time_limit_heuristic
- **config_file** (str) - Optional - indicates the path of the config file for more advanced settings
- **solver_name** (str) - Optional - indicates the solver used during the resolution, we can choose "CLP" or "CPLEX" solver
- **print_level** (int) - Optional - indicates the level of print from Bapcod during the resolution, we can choose (-2,-1,0)
- **action** (str) - Optional - indicates if we want to solve the problem ("solve") or enumerate all feasible routes ("enumAllFeasibleRoutes")
- **cplex_path** (str) - Optional - path of library cplex 22.1. You can specify a path if you want to use cplex and replace the bapcod-shared library by the library using cplex

### Methods
- **get_parameters(debug=False)** - Get all parameters which are different of default value

### Properties
- **action** (str) - indicates if we want to solve the problem ("solve") or enumerate all feasible routes ("enumAllFeasibleRoutes")
- **config_file** (str) - indicates the path of the config file for more advanced settings
- **cplex_path** (str) - path of library cplex 22.1. You can specify a path if you want to use cplex and replace the bapcod-shared library by the library using cplex
- **heuristic_used** (bool) - getter function of heuristic_used
- **print_level** (int) - indicates the level of print from Bapcod during the resolution, we can choose (-2,-1,0)
- **solver_name** (str) - indicates the solver used during the resolution, we can choose "CLP" or "CPLEX" solver
- **time_limit** (float) - represents the limit time of resolution
- **time_limit_heuristic** (float) - getter function of time_limit_heuristic
- **upper_bound** (float) - represents the cost we want to reach

### Notes
- `__repr__()` returns repr(self).
- `__weakref__` is a list of weak references to the object (if defined).
```

--------------------------------

### Build VRPSolverEasy model

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Example/index.html

Builds the VRPSolverEasy model: initializes the model, adds a vehicle type with capacity 1100 and max 6 vehicles, adds a depot, adds customers with demands and time windows, and adds links with Euclidean distances and travel times.

```python
# Initialisation
model = solver.Model()

# Add vehicle type
model.add_vehicle_type(
    id=1,
    start_point_id=0,
    end_point_id=0,
    name="VEH1",
    capacity=1100,
    max_number=6,
    var_cost_dist=cost_per_distance,
    tw_end=5000)

# Add depot
model.add_depot(id=0, name="D1", tw_begin=0, tw_end=5000)

coordinates_keys = list(coordinates.keys())
# Add Customers
for i in range(1, nb_point):
    model.add_customer(
        id=i,
        name=coordinates_keys[i],
        demand=demands[i],
        tw_begin=begin_time,
        tw_end=end_time)

# Add links
coordinates_values = list(coordinates.values())
for i in range(0, 7):
    for j in range(i + 1, 7):
        dist = compute_euclidean_distance(coordinates_values[i][0],
                                          coordinates_values[j][0],
                                          coordinates_values[i][1],
                                          coordinates_values[j][1])
        model.add_link(
            start_point_id=i,
            end_point_id=j,
            distance=dist,
            time=dist)

```

--------------------------------

### Parameters

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Solver%20API/index.html

The Parameters class holds all the configuration options for the solver. It is used to set time limits, solver choice, and other solving options.

```APIDOC
## Parameters

### Description
Define all parameters from model.

### Constructor

Parameters(time_limit=300, upper_bound=1000000, heuristic_used=False, time_limit_heuristic=20, config_file='', solver_name='CLP', print_level=-1, action='solve', cplex_path='')

### Parameters
- **time_limit** (int) - Optional - The time limit in seconds.
- **upper_bound** (int) - Optional - The upper bound on the objective value.
- **heuristic_used** (bool) - Optional - Whether to use a heuristic.
- **time_limit_heuristic** (int) - Optional - The time limit for the heuristic.
- **config_file** (str) - Optional - The path to a configuration file.
- **solver_name** (str) - Optional - The solver to use: 'CLP' or 'CPLEX'.
- **print_level** (int) - Optional - The print level: -2, -1, or 0.
- **action** (str) - Optional - The action to perform: 'solve' or 'enumAllFeasibleRoutes'.
- **cplex_path** (str) - Optional - The path to the CPLEX solver.
```

--------------------------------

### Set solver parameters (time_limit, solver_name)

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Configures the solver with a 30-second time limit and the 'CLP' solver. Use before solving to control the optimization process.

```python
# set parameters
model.set_parameters(time_limit=30,
                     solver_name="CLP")
```

--------------------------------

### RichVRP instance file format

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Format of the instance file read by the RichVRP demo. It specifies depots, vehicle types (big and small), and customers with coordinates, time windows, and optional fields.

```text
<M> # Number of depots
0 <xCoordDepot0> <yCoordDepot0> <beginTwDepot0> <endTwDepot0>
...
M-1 <xCoordDepotM-1> <yCoordDepotM-1> <beginTwDepotM-1> <endTwDepotM-1>
<bigVehicleCapacity> <bigVehicleFixedCost> <bigVehicleVariableCost> <bigVehicleMaxNumber>
<smallVehicleCapacity> <smallVehicleFixedCost> <smallVehicleVariableCost> <smallVehicleMaxNumber>
<N> # Number of customers
M <xCoordCustomerM> <yCoordCustomerM> <beginTwCustomerM> <endTwCustomerM>
...
M+N-1 <xCoordCustomerM+N-1> <yCoordCustomerM+N-1> <beginTwCustomerM+N-1> <endTwCustomerM+N-1>
```

--------------------------------

### Add customers (Python)

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Adds customers with multiple time windows, creating alternative point IDs for later time windows. Assigns penalties for optional customers and marks incompatible vehicle types for small-vehicle-only customers.

```python
    # ID for alternative points of a customer with multiple time windows
    next_id = max([customer.id for customer in data.customers]) + 1
    # IDs of a customer, including the alternative ones
    customer_ids = {customer.id : [customer.id] for customer in data.customers}
    # Add customers
    for customer in data.customers:
        # Add a point for each time window of a customer
        for i, tw in enumerate(customer.time_windows):
            point_id = customer.id
            if i > 0: # Is it an alternative point?
                point_id = next_id
                customer_ids[customer.id].append(next_id)
                next_id += 1 # Get the next alternative ID
            model.add_customer(id = point_id,
                                id_customer = customer.id,
                                demand = customer.demand,
                                service_time = customer.service_time,
                                tw_begin = tw[0],
                                tw_end = tw[1],
                                penalty = 1.0 if customer.optional else 0.0,
                                incompatible_vehicles = big_vehicle_ids if customer.only_small_veh else [])
```

--------------------------------

### Print solution automatically

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Prints the solution using the automatic printing function. The output shows routes with IDs, loads, and total cost.

```python
# print solution
print(model.solution)
```

--------------------------------

### Add links between depot and customers

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Computes Euclidean distances from the depot to each customer and adds links with those distances.

```python
# Compute the links between depot and other points
for i,cust_i in enumerate(data.cust_coordinates):
    dist = compute_euclidean_distance(cust_i[0],
                                      cust_i[1],
                                      data.depot_coordinates[0],
                                      data.depot_coordinates[1], 0)

    model.add_link(start_point_id=0,
                   end_point_id=i + 1,
                   distance=dist)
```

--------------------------------

### Interpretation of toy.txt

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Interpretation of the toy.txt instance, showing depots, vehicle types, and customers with their attributes as read by the demo.

```text
Depots:
Depot(id: 0, x: 0, y: 0, tw_begin: 0, tw_end: 1000)
Depot(id: 1, x: 100, y: 100, tw_begin: 0, tw_end: 500)

Big Vehicle:
Vehicle(capacity: 200, fixed_cost: 400, var_cost: 3.2, max_number: 1)

Small Vehicle:
Vehicle(capacity: 50, fixed_cost: 20, var_cost: 1.0, max_number: 4)

Customers:
Customer(id: 2, x: 5, y: 15, demand: 35, service_time: 50, optional: False, only_small_veh: True, time_windows: [(20, 100)])
Customer(id: 3, x: 5, y: 25, demand: 15, service_time: 50, optional: True, only_small_veh: True, time_windows: [(0, 100)])
Customer(id: 4, x: 15, y: 15, demand: 100, service_time: 50, optional: False, only_small_veh: False, time_windows: [(180, 250)])
Customer(id: 5, x: 75, y: 60, demand: 20, service_time: 50, optional: False, only_small_veh: True, time_windows: [(0, 100), (200, 300), (400, 500)])
Customer(id: 6, x: 50, y: 50, demand: 80, service_time: 50, optional: False, only_small_veh: False, time_windows: [(80, 130)])
Customer(id: 7, x: 35, y: 75, demand: 30, service_time: 50, optional: False, only_small_veh: False, time_windows: [(0, 50), (500, 600)])
```

--------------------------------

### Print Solution Results

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Example/index.rst.txt

Checks if a solution was found and prints the routing details.

```python
if model.solution.is_defined():
    print(model.solution)
```

--------------------------------

### Print solution manually (statistics and routes)

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/CVRP.html

Manually prints solver statistics and solution details, including best lower bound, solution time, number of nodes, solution value, root lower bound, root time, status, message, and each route's vehicle type, point IDs, and load consumption.

```python
if model.solution.is_defined :
    print(f"""Statistics :
    best lower bound : { model.statistics.best_lb }

    solution time : {model.statistics.solution_time}

    number of nodes : {model.statistics.nb_branch_and_bound_nodes}

    solution value : {model.solution.value}

    root lower bound : {model.statistics.root_lb}

    root root time : {model.statistics.root_time}.
    """)
    print(f"Status : {model.status}.\n")
    print(f"Message : {model.message}.\n")
    for route in model.solution.routes:
        print(f"Vehicle Type id : {route.vehicle_type_id}.")
        print(f"Ids : {route.point_ids}.")
        print(f"Load : {route.cap_consumption}.\n")
```

--------------------------------

### Add links (Python)

Source: https://vrpsolvereasy.readthedocs.io/en/latest/_sources/Demos/RichVRP.rst.txt

Computes Euclidean distances and adds links between depots and all customer points, then between all pairs of customer points, including alternative points. This assumes the `compute_euclidean_distance` function is defined elsewhere.

```python
    # Compute the links between depots and other points
    for depot in data.depots:
        for customer in data.customers:
            dist = compute_euclidean_distance(customer.x, customer.y, depot.x, depot.y)
            for point_id in customer_ids[customer.id]:
                model.add_link(start_point_id = depot.id,
                                end_point_id = point_id,
                                distance = dist,
                                time = dist)
                
    # Compute the links between customer points
    for i, c1 in enumerate(data.customers):
        for j, c2 in enumerate(data.customers):
            if j <= i:
                continue
            dist = compute_euclidean_distance(c1.x, c1.y, c2.x, c2.y)
            # Add a link for each pair of points from c1 to c2
            for point_id_c1 in customer_ids[c1.id]:
                for point_id_c2 in customer_ids[c2.id]:
                    model.add_link(start_point_id = point_id_c1,
                                    end_point_id = point_id_c2,
                                    distance = dist,
                                    time = dist)
```

--------------------------------

### Activate enumeration mode

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Important%20notes/index.html

Activates the solver enumeration mode to return all feasible routes for a small instance (up to 5-10 customers) to verify model correctness.

```python
model.parameters.action = "enumAllFeasibleRoutes"
```

--------------------------------

### Add links between depots and customers

Source: https://vrpsolvereasy.readthedocs.io/en/latest/Demos/MDVRP.html

Compute and add links between depots and customers, and between customers. Distances are Euclidean. Point IDs for customers are offset by nb_depots + 1.

```python
# Compute the links between depots and other points
for depot_id in range(data.nb_depots):
    for i, cust_i in enumerate(data.cust_coordinates):
        dist = compute_euclidean_distance(
            cust_i[0],
            cust_i[1],
            data.depot_coordinates[depot_id][0],
            data.depot_coordinates[depot_id][1])

        model.add_link(start_point_id=depot_id,
                       end_point_id=i + data.nb_depots + 1,
                       distance=dist
                       )

# Compute the links between points
for i,cust_i in enumerate(data.cust_coordinates):
    for j in range(i + 1, len(data.cust_coordinates)):
        dist = compute_euclidean_distance(cust_i[0],
                                          cust_i[1],
                                          data.cust_coordinates[j][0],
                                          data.cust_coordinates[j][1])

        model.add_link(start_point_id=i + data.nb_depots + 1,
                       end_point_id=j + data.nb_depots + 1,
                       distance=dist
                       )

```
Tokens:
Raw