The open-vrp Reference Manual

4.1.1 open-vrp/open-vrp.asd

Source

open-vrp.asd.

Parent Component

open-vrp (system).

ASDF Systems

open-vrp.

---

4.1.2 open-vrp-lib/open-vrp-lib.asd

Source

open-vrp-lib.asd.

Parent Component

open-vrp-lib (system).

ASDF Systems

open-vrp-lib.

---

4.1.3 open-vrp/algo/algo-conditions.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

tabu-list (reader method).

Internals

• all-moves-tabu (condition).
• moves (reader method).
• moves (reader method).
• no-feasible-move (condition).
• no-initial-feasible-solution (condition).
• select-best-tabu (function).

---

4.1.4 open-vrp/algo/tools.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• feasible-movep (generic function).
• get-closest-feasible-vehicle (method).
• get-closest-feasible-vehicle (method).
• get-closest-feasible-vehicle (method).
• get-closest-node (function).
• get-closest-vehicle (function).
• insertion-move (structure).
• make-insertion-move (function).
• move (structure).
• move-fitness (reader).
• (setf move-fitness) (writer).
• move-index (reader).
• (setf move-index) (writer).
• move-node-id (reader).
• (setf move-node-id) (writer).
• move-vehicle-id (reader).
• (setf move-vehicle-id) (writer).

Internals

• capacities-left (function).
• copy-insertion-move (function).
• copy-move (function).
• dists-to-vehicles (function).
• get-min-index-with-tabu (function).
• insertion-move-p (function).
• make-move (function).
• move-p (function).
• num-nodes (function).
• num-veh (function).
• route-from (function).
• route-to (function).
• times-of-arriving (function).

---

4.1.5 open-vrp/algo/iterator.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• assess-move (generic function).
• assess-moves (function).
• fitness-before-after (function).
• generate-moves (generic function).
• initialize (generic function).
• perform-move (generic function).
• select-move (generic function).
• sort-moves (function).

---

4.1.6 open-vrp/algo/best-insertion.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• assess-move (method).
• get-best-insertion-move (generic function).
• get-best-insertion-move-in-vehicle (function).
• perform-move (method).
• perform-move (method).

Internals

generate-insertion-moves (function).

---

4.1.7 open-vrp/algo/greedy-NN.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• greedy-nn (class).
• run-algo (method).

---

4.1.8 open-vrp/algo/greedy-append.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• greedy-append (class).
• run-algo (method).

---

4.1.9 open-vrp/algo/greedy-best-insertion.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• greedy-best-insertion (class).
• run-algo (method).

---

4.1.10 open-vrp/algo/TS-classdef.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• make-ts-best-insertion-move (function).
• tabu-search (class).
• ts-aspirationp (reader method).
• (setf ts-aspirationp) (writer method).
• ts-best-insertion-move (structure).
• ts-candidate-list (reader method).
• (setf ts-candidate-list) (writer method).
• ts-elite-listp (reader method).
• (setf ts-elite-listp) (writer method).
• ts-init-heur (reader method).
• (setf ts-init-heur) (writer method).
• ts-move-type (reader method).
• (setf ts-move-type) (writer method).
• ts-parameter-f (reader method).
• (setf ts-parameter-f) (writer method).
• ts-stopping-condition (reader method).
• (setf ts-stopping-condition) (writer method).
• ts-tabu-list (reader method).
• (setf ts-tabu-list) (writer method).
• ts-tenure (reader method).
• (setf ts-tenure) (writer method).

Internals

• copy-ts-best-insertion-move (function).
• ts-best-insertion-move-fitness (function).
• (setf ts-best-insertion-move-fitness) (function).
• ts-best-insertion-move-index (function).
• (setf ts-best-insertion-move-index) (function).
• ts-best-insertion-move-node-id (function).
• (setf ts-best-insertion-move-node-id) (function).
• ts-best-insertion-move-p (function).
• ts-best-insertion-move-vehicle-id (function).
• (setf ts-best-insertion-move-vehicle-id) (function).

---

4.1.11 open-vrp/algo/TS-utils.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• add-move-to-tabu (function).
• add-to-tabu (function).
• create-candidate-list (function).
• is-tabu-movep (function).
• is-tabup (function).
• toggle-aspiration (function).
• toggle-elite-list (function).

Internals

• clear-tabu-list (function).
• improving-movep (function).
• remove-affected-moves (method).
• stopping-conditionp (function).
• ts-pars-n (function).
• ts-pars-nv (function).

---

4.1.12 open-vrp/algo/TS.lisp

Source

open-vrp.asd.

Parent Component

algo (module).

Public Interface

• assess-move (method).
• generate-moves (method).
• initialize (method).
• iterate (method).
• iterate (method).
• perform-move (method).
• run-algo (method).
• select-move (method).

Internals

• for-node-id (macro).
• for-veh-id (macro).
• useless-move (function).

---

4.1.13 open-vrp/test-cases/test-cases.lisp

Source

open-vrp.asd.

Parent Component

test-cases (module).

Public Interface

• *node-coords* (special variable).
• christofides-1 (special variable).
• christofides-2 (special variable).
• solomon100 (special variable).
• solomon25 (special variable).
• test-tsp (special variable).
• test-vrp (special variable).

---

4.1.14 open-vrp/test-cases/test-suite.lisp

Source

open-vrp.asd.

Parent Component

test-cases (module).

Internals

• asym-net (special variable).
• asym-tsp (special variable).
• asym-vrp (special variable).
• late-v-duration (function).
• late-v-speed (function).
• on-all-testcases (macro).
• on-time-and-in-cap-v (function).
• on-time-but-overfull-v (function).
• on-time-v (function).
• overfull-v (function).
• space-v (function).

---

4.1.15 open-vrp-lib/packages.lisp

Source

open-vrp-lib.asd.

Parent Component

open-vrp-lib (system).

Packages

• open-vrp.algo.
• open-vrp.test.
• open-vrp.
• open-vrp.classes.
• open-vrp.util.

---

4.1.16 open-vrp-lib/lib/class-definitions.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• algo (class).
• algo-animatep (reader method).
• (setf algo-animatep) (writer method).
• algo-best-fitness (reader method).
• (setf algo-best-fitness) (writer method).
• algo-best-iteration (reader method).
• (setf algo-best-iteration) (writer method).
• algo-best-sol (reader method).
• (setf algo-best-sol) (writer method).
• algo-current-sol (reader method).
• (setf algo-current-sol) (writer method).
• algo-desc (reader method).
• algo-iterations (reader method).
• (setf algo-iterations) (writer method).
• algo-name (reader method).
• cvrp (class).
• cvrptw (class).
• drawer (structure).
• drawer-filename (reader).
• (setf drawer-filename) (writer).
• drawer-legend-x (reader).
• (setf drawer-legend-x) (writer).
• drawer-legend-y (reader).
• (setf drawer-legend-y) (writer).
• drawer-legendp (reader).
• (setf drawer-legendp) (writer).
• drawer-max-coord (reader).
• (setf drawer-max-coord) (writer).
• drawer-max-pix (reader).
• (setf drawer-max-pix) (writer).
• drawer-min-coord (reader).
• (setf drawer-min-coord) (writer).
• drawer-plotp (reader).
• (setf drawer-plotp) (writer).
• drawer-x-pos (reader).
• (setf drawer-x-pos) (writer).
• drawer-y-pos (reader).
• (setf drawer-y-pos) (writer).
• make-drawer (function).
• make-node (function).
• make-vehicle (function).
• node (structure).
• node-demand (reader).
• node-duration (reader).
• node-end (reader).
• node-id (reader).
• node-start (reader).
• node-xcor (reader).
• node-ycor (reader).
• problem (class).
• problem-desc (reader method).
• problem-dist-array (reader method).
• (setf problem-dist-array) (writer method).
• problem-drawer (reader method).
• (setf problem-drawer) (writer method).
• problem-fleet (reader method).
• problem-log-file (reader method).
• (setf problem-log-file) (writer method).
• problem-log-mode (reader method).
• (setf problem-log-mode) (writer method).
• problem-name (reader method).
• problem-network (reader method).
• problem-to-depot (reader method).
• (setf problem-to-depot) (writer method).
• vehicle (structure).
• vehicle-capacity (reader).
• vehicle-id (reader).
• vehicle-route (reader).
• (setf vehicle-route) (writer).
• vehicle-speed (reader).
• vrptw (class).

Internals

• copy-drawer (function).
• copy-node (function).
• copy-vehicle (function).
• drawer-p (function).
• node-p (function).
• vehicle-p (function).

---

4.1.17 open-vrp-lib/lib/simple-utils.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• aif (macro).
• awhile (macro).
• copy-object (function).
• mac (macro).
• map0-n (function).
• map1-n (function).
• max-car (function).
• max-cdr (function).
• single (function).
• sum (function).
• while (macro).

Internals

vrp-object (function).

---

4.1.18 open-vrp-lib/lib/list.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• enumerate-interval (function).
• get-max (function).
• get-max-index (function).
• get-min (function).
• get-min-index (function).
• insert-at-end (function).
• insert-before (function).
• random-list-permutation (function).
• remove-index (function).
• sort-ignore-nil (function).
• with-tabu-indices (macro).

Internals

• get-from-list (function).
• get-index-of (function).
• mark-nill (function).

---

4.1.19 open-vrp-lib/lib/network.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• distance (function).
• generate-dist-array (function).
• get-array-row (function).
• new-node (macro).
• node (method).
• node-distance (function).

Internals

• 2d-array-to-list (function).
• 2d-list-to-array (function).
• distance-coord-pair (function).
• distance-coords (function).

---

4.1.20 open-vrp-lib/lib/fleet.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• new-vehicle (macro).
• node-on-routep (function).
• route-indices (generic function).
• total-dist (generic function).
• vehicle (method).
• vehicle-with-node-id (function).

---

4.1.21 open-vrp-lib/lib/fitness.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

fitness (generic function).

---

4.1.22 open-vrp-lib/lib/output.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• log-to-replp (generic function).
• print-final-results (function).
• print-multi-run-stats (function).
• print-routes (generic function).
• print-timestamp (function).
• print-vrp-object (function).
• with-log-or-print (macro).

Internals

• append-run-result (function).
• get-multi-run-stats (function).
• insert-time-stamp-in-path (function).
• print-batch-run-table-header (function).
• print-header (function).
• universal-time-to-string (function).

---

4.1.23 open-vrp-lib/lib/route.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• append-node (function).
• empty-routep (function).
• get-busy-vehicles (function).
• insert-node (function).
• last-node (generic function).
• one-destinationp (function).
• remove-node-at (function).
• remove-node-id (generic function).

Internals

change-route (macro).

---

4.1.24 open-vrp-lib/lib/draw-solution.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• plot-nodes (generic function).
• plot-solution (generic function).

Internals

• *b* (special variable).
• *g* (special variable).
• *r* (special variable).
• arrow-to (function).
• coord->pix (function).
• draw-legend-item (function).
• draw-nodes (function).
• get-color (function).
• store-pix (function).
• use-node (macro).

---

4.1.25 open-vrp-lib/lib/solver.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• *multi-run-start-time* (special variable).
• *start-time* (special variable).
• get-best-solution-from-multi-run (function).
• init-algo (function).
• iterate (generic function).
• iterate-more (generic function).
• multi-run (macro).
• multi-run-algo (macro).
• run-algo (generic function).
• solve-prob (generic function).

Internals

• *finish-time* (special variable).
• *multi-run-finish-time* (special variable).

---

4.1.26 open-vrp-lib/lib/constraints.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• constraints-check (macro).
• constraintsp (generic function).
• in-capacityp (generic function).
• in-timep (method).
• time-after-serving-node (function).
• travel-time (function).
• veh-in-timep (function).

---

4.1.27 open-vrp-lib/lib/conditions.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• file (reader method).
• list-of-nils (condition).
• same-origin-destination (condition).

Internals

• empty-network (condition).
• file-not-recognized (condition).
• from (reader method).
• func (reader method).
• index (reader method).
• index-out-of-bounds (condition).
• infeasible-solution (condition).
• key (reader method).
• lists (reader method).
• ls (reader method).
• ls (reader method).
• missing-drawer-object (condition).
• no-capacities-vehicle (condition).
• no-speed-vehicle (condition).
• not-equal-length (condition).
• pred (reader method).
• prob (reader method).
• sol (reader method).
• to (reader method).
• unaccepted-predicate (condition).
• veh (reader method).
• veh (reader method).

---

4.1.28 open-vrp-lib/lib/init-macros.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• create-nodes (macro).
• create-vehicles (macro).
• define-problem (macro).

Internals

• get-max-coord (function).
• get-min-coord (function).
• same-lengthp (function).

---

4.1.29 open-vrp-lib/lib/read-solomon.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

load-solomon-vrp-file (function).

Internals

couple-lists (function).

---

4.1.30 open-vrp-lib/lib/read-cvrp.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

load-tsplib-vrp-file (function).

Internals

• %read-string (function).
• read-string-while-member (function).
• read-string-while-not-member (function).

---

4.1.31 open-vrp-lib/lib/config-functions.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

• set-dist-array (function).
• set-log-file (function).
• set-log-mode (function).
• set-plot-file (function).
• toggle (macro).
• toggle-animate (function).
• toggle-legend (generic function).
• toggle-plot (generic function).

---

4.1.32 open-vrp-lib/lib/read-test-case.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

load-test-case-file (function).

---

4.1.33 open-vrp-lib/lib/batch-run.lisp

Source

open-vrp-lib.asd.

Parent Component

lib (module).

Public Interface

batch-run (macro).

---

6.1.1 Special variables

Special Variable: *multi-run-start-time* ¶

Package

open-vrp.util.

Source

solver.lisp.

Special Variable: *node-coords* ¶

Package

open-vrp.test.

Source

test-cases.lisp.

Special Variable: *start-time* ¶

Package

open-vrp.util.

Source

solver.lisp.

Special Variable: christofides-1 ¶

Package

open-vrp.test.

Source

test-cases.lisp.

Special Variable: christofides-2 ¶

Package

open-vrp.test.

Source

test-cases.lisp.

Special Variable: solomon100 ¶

Package

open-vrp.test.

Source

test-cases.lisp.

Special Variable: solomon25 ¶

Package

open-vrp.test.

Source

test-cases.lisp.

Special Variable: test-tsp ¶

Package

open-vrp.test.

Source

test-cases.lisp.

Special Variable: test-vrp ¶

Package

open-vrp.test.

Source

test-cases.lisp.

---

6.1.2 Macros

Macro: aif (test-form then-form &optional else-form) ¶

Package

open-vrp.util.

Source

simple-utils.lisp.

Macro: awhile (expr &body body) ¶

Package

open-vrp.util.

Source

simple-utils.lisp.

Macro: batch-run ((x dir-path &key plotp log-mode) output-file num-times &body algo-call) ¶

Given a directory, will call algo-call on each file that is loaded using the loader-fn and bound to x. Output-file is a mandatory filepath to which the results will be written. Algo-call must return an <Algo> object (e.g. multi-run-algo or solve-prob). Num-times is the number of times the algo-call will run on each test-case, which will be used for stats. Will return a list of list of algo objects holding the solutions.

Example: (batch-run (test-case "test-cases/Solomon-25/")
"run-logs/Solomon-25-batch.txt" 20
(solve-prob test-case (make-instance ’tabu-search :iterations 300))).

Package

open-vrp.util.

Source

batch-run.lisp.

Macro: constraints-check (arglist init-forms next-forms testform &optional endtest) ¶

Package

open-vrp.util.

Source

constraints.lisp.

Macro: create-nodes (&key node-coords demands time-windows durations dist-matrix) ¶

Will return a vector of nodes that are numbered starting from 0 (which should be the base node, by convention over configuration). All attribute parameters are optional but must be of the same length. Note that dist-matrix parameter is not used, but only to create nodes when no other parameter is passed (called from define-problem).

Package

open-vrp.util.

Source

init-macros.lisp.

Macro: create-vehicles (fleet-size base-node to-depot &key capacities speeds) ¶

Returns a list of vehicles, starting with ID 0. The starting location of their routes are all initialized at base-node. When to-depot is set to T, initialize their routes with 2 base nodes (departure and destination). For capacities and speeds, only accepts a list that is of equal lenght to fleet-size.

Package

open-vrp.util.

Source

init-macros.lisp.

Macro: define-problem (name fleet-size &key node-coords-list demands capacities time-windows-list durations speeds to-depot plot-filename log-filename dist-matrix log-mode plotp) ¶

Creates the appropriate <Problem> object from the inputs. Extra key attributes only accept lists that are of equal length to node-coords-list or fleet-size (depending on what attributes it sets). For demands, durations, capacities and speeds, will also accept a single value, which will set all attributes to this value.

A(n asymmetric) dist-matrix may be passed, instead of node-coords, in which case plotting will be disabled. dist-matrix must be a list of lists or 2-dimensional array.

With only the demands-list and capacities, creates a CVRP problem. With time-windows, creates a VRPTW problem. When durations and speeds are not provided, defaults to 0 and 1. When plot-filename is not given, it will plot in "plots/name.png". When log-filename is not given, it will log by default in "run-logs/name.txt".

Package

open-vrp.util.

Source

init-macros.lisp.

Macro: mac (expr) ¶

Package

open-vrp.util.

Source

simple-utils.lisp.

Macro: multi-run (times &body algo-call) ¶

Run algo x times and collect all resulting solution objects in a list.

Package

open-vrp.util.

Source

solver.lisp.

Macro: multi-run-algo (times &body algo-call) ¶

Run algo x times, print multi-run-stats and return the best result.

Package

open-vrp.util.

Source

solver.lisp.

Macro: new-node (id xcor ycor &key demand start end duration) ¶

Package

open-vrp.util.

Source

network.lisp.

Macro: new-vehicle (id base-node to-depot &key capacity speed) ¶

Package

open-vrp.util.

Source

fleet.lisp.

Macro: toggle (place) ¶

Package

open-vrp.util.

Source

config-functions.lisp.

Macro: while (test &body body) ¶

Package

open-vrp.util.

Source

simple-utils.lisp.

Macro: with-log-or-print ((stream prob time &optional appendp) &body body) ¶

A wrapper on top of with-open-file, where we use the filepath stored in the :log-file slot of a problem object. When :log-mode is 0, return nil. If 1, use the file stream; if 2, use the T stream. Optional parameter appendp can be set to NIL in order to :supersede if file exists. By default appends. Returns T if logging is succesful. Requires universal-time, to append to log-file.

Package

open-vrp.util.

Source

output.lisp.

Macro: with-tabu-indices (tabu-indices fn arg-list) ¶

Package

open-vrp.util.

Source

list.lisp.

---

6.1.3 Ordinary functions

Function: add-move-to-tabu (ts mv) ¶

Adds <Move> to tabu-list of <tabu-search>. Calls function held in <ts>’s :tabu-parameter-f slot.

Package

open-vrp.algo.

Source

ts-utils.lisp.

Function: add-to-tabu (ts pars) ¶

Add pars to the tabu-list of <tabu-search>. Expects pars to be a list when more than one parameter is recorded. When tabu-list gets larger than the tenure, will prune away the oldest pars on the list. Destructive.

Package

open-vrp.algo.

Source

ts-utils.lisp.

Function: append-node (veh node) ¶

Appends <Node> to the end of the route of <vehicle>. Wrapper of insert-node. If the route includes returning to-depot, then append before the last return to depot.

Package

open-vrp.util.

Source

route.lisp.

Function: assess-moves (solution moves) ¶

Given a list of <Move> objects, assess them all on the solution (uses assess-move), and setf the move’s :fitness slots. Returns the list of moves.

Package

open-vrp.algo.

Source

iterator.lisp.

Function: copy-object (object) ¶

A deep-cloner for CLOS.

Package

open-vrp.util.

Source

simple-utils.lisp.

Function: create-candidate-list (ts sorted-moves) ¶

Given a list of sorted moves, return the list with non-tabu improving moves. Will always at least return one (non-tabu) move.

Package

open-vrp.algo.

Source

ts-utils.lisp.

Function: distance (i j dist-array) ¶

Read from the distance-table with two indices.

Package

open-vrp.util.

Source

network.lisp.

Reader: drawer-filename (instance) ¶

Writer: (setf drawer-filename) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

filename.

Reader: drawer-legend-x (instance) ¶

Writer: (setf drawer-legend-x) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

legend-x.

Reader: drawer-legend-y (instance) ¶

Writer: (setf drawer-legend-y) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

legend-y.

Reader: drawer-legendp (instance) ¶

Writer: (setf drawer-legendp) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

legendp.

Reader: drawer-max-coord (instance) ¶

Writer: (setf drawer-max-coord) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

max-coord.

Reader: drawer-max-pix (instance) ¶

Writer: (setf drawer-max-pix) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

max-pix.

Reader: drawer-min-coord (instance) ¶

Writer: (setf drawer-min-coord) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

min-coord.

Reader: drawer-plotp (instance) ¶

Writer: (setf drawer-plotp) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

plotp.

Reader: drawer-x-pos (instance) ¶

Writer: (setf drawer-x-pos) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

x-pos.

Reader: drawer-y-pos (instance) ¶

Writer: (setf drawer-y-pos) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

y-pos.

Function: empty-routep (route) ¶

Given a route, return T if the route only has base-nodes.

Package

open-vrp.util.

Source

route.lisp.

Function: enumerate-interval (n) ¶

Returns a list from 1 to n.

Package

open-vrp.util.

Source

list.lisp.

Function: fitness-before-after (sol operation) ¶

Given <Problem> object and an #’operation function that takes the <problem> as input, return the difference of fitness between after and before.

Package

open-vrp.algo.

Source

iterator.lisp.

Function: generate-dist-array (coord-list) ¶

Given a list of coord pairs, generate an array of distances.

Package

open-vrp.util.

Source

network.lisp.

Function: get-array-row (array row-index) ¶

Given a 2-dimenstional array and a row-index, return the row as a list

Package

open-vrp.util.

Source

network.lisp.

Function: get-best-insertion-move-in-vehicle (sol vehicle-id node-id) ¶

Given the <solution> object, vehicle-id and node-id (integers), return the best <insertion-move> (i.e. with the lowest fitness) for inserting node-id in vehicle-id. When no move is feasible, throws error.

Package

open-vrp.algo.

Source

best-insertion.lisp.

Function: get-best-solution-from-multi-run (solutions) ¶

Given a list of solutions (from multi-run), return the best solution.

Package

open-vrp.util.

Source

solver.lisp.

Function: get-busy-vehicles (problem) ¶

Returns a list of <Vehicles> that are not empty, given a <Problem> object.

Package

open-vrp.util.

Source

route.lisp.

Function: get-closest-node (prob veh-id &optional tabu) ¶

Returns the closest node from the last location of vehicle. Requires <problem> and vehicle-ID. A tabu list of node-IDs is optional to exclude consideration of some nodes.

Package

open-vrp.algo.

Source

tools.lisp.

Function: get-closest-vehicle (n prob) ¶

Returns the closest <vehicle> to <node>. Used by insertion heuristic. When multiple <vehicle> are on equal distance, choose first one (i.e. lowest ID).

Package

open-vrp.algo.

Source

tools.lisp.

Function: get-max (list &key key) ¶

Gets the maximum value from a list, while ignoring the NIL values.

Package

open-vrp.util.

Source

list.lisp.

Function: get-max-index (list &key key) ¶

Returns index of the largest value on list, while ignoring NIL. Returns index and its value (closest node and value).

Package

open-vrp.util.

Source

list.lisp.

Function: get-min (list &key key) ¶

Gets the minimum value from a list, while ignoring the NIL values.

Package

open-vrp.util.

Source

list.lisp.

Function: get-min-index (list &key key) ¶

Returns index of the smallest value on list, while ignoring NIL. Returns index and its value (closest node and value).

Package

open-vrp.util.

Source

list.lisp.

Function: init-algo (sol algo) ¶

Given a solution, sets the :current-sol, :best-fitness and :best-sol slots of the <algo> object. Returns <algo>.

Package

open-vrp.util.

Source

solver.lisp.

Function: insert-at-end (object list) ¶

Appends the object at the end of the list

Package

open-vrp.util.

Source

list.lisp.

Function: insert-before (object index list) ¶

Insert object before index of list. 0 implies inserting in front, length of list implies appending at the end. Throws index out of bounds when index is larger.

Package

open-vrp.util.

Source

list.lisp.

Function: insert-node (veh node index) ¶

Adds the <Node> object before the index of the route of <vehicle>. An index of 0 implies inserting in front, length of list implies at the end.

Package

open-vrp.util.

Source

route.lisp.

Function: is-tabu-movep (ts mv) ¶

Given a <Move>, checks if the parameters returned by calling :tabu-parameter-f are recorded on the list.

Package

open-vrp.algo.

Source

ts-utils.lisp.

Function: is-tabup (ts pars) ¶

Given pars, checks if on tabu list of <tabu-search>

Package

open-vrp.algo.

Source

ts-utils.lisp.

Function: load-solomon-vrp-file (file) ¶

Load testcase from file, which should be Solomon style.

Package

open-vrp.util.

Source

read-solomon.lisp.

Function: load-test-case-file (filepath) ¶

Given a file, will recognize the format based on some cues and dispatch to appropriate reader function to parse the file. File with .vrp extension will be read as TSPLIB.

Package

open-vrp.util.

Source

read-test-case.lisp.

Function: load-tsplib-vrp-file (file) ¶

Load a subset of the VRP in the TSPLIB. Do not support time windows. ###################
NAME: xxxx
...
DIMENSION: xxx
...
EDGE_WEIGHT_FORMAT: FUNCTION
...
EDGE_WEIGHT_TYPE: EXACT_2D
CAPACITY: xxx
...
NODE_COORD_SECTION
....
DEPOT_SECTION
1
-1
EOF
####################
EDGE_WEIGHT_FORMAT and EDGE_WEIGHT_TYPE are optional

Package

open-vrp.util.

Source

read-cvrp.lisp.

Function: make-drawer (&key min-coord max-coord x-pos y-pos max-pix legendp legend-x legend-y filename plotp) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Function: make-insertion-move (&key fitness node-id vehicle-id index) ¶

Package

open-vrp.algo.

Source

tools.lisp.

Function: make-node (&key id xcor ycor demand start end duration) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Function: make-ts-best-insertion-move (&key fitness node-id vehicle-id index) ¶

Package

open-vrp.algo.

Source

ts-classdef.lisp.

Function: make-vehicle (&key id route capacity speed) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Function: map0-n (fn n) ¶

maps from 0 to n

Package

open-vrp.util.

Source

simple-utils.lisp.

Function: map1-n (fn n) ¶

maps from 1 to n

Package

open-vrp.util.

Source

simple-utils.lisp.

Function: max-car (list) ¶

Provided a list, return the maximum value considering the cars

Package

open-vrp.util.

Source

simple-utils.lisp.

Function: max-cdr (list) ¶

Provided a list, return the maximum value considering the cdrs

Package

open-vrp.util.

Source

simple-utils.lisp.

Reader: move-fitness (instance) ¶

Writer: (setf move-fitness) (instance) ¶

Package

open-vrp.algo.

Source

tools.lisp.

Target Slot

fitness.

Reader: move-index (instance) ¶

Writer: (setf move-index) (instance) ¶

Package

open-vrp.algo.

Source

tools.lisp.

Target Slot

index.

Reader: move-node-id (instance) ¶

Writer: (setf move-node-id) (instance) ¶

Package

open-vrp.algo.

Source

tools.lisp.

Target Slot

node-id.

Reader: move-vehicle-id (instance) ¶

Writer: (setf move-vehicle-id) (instance) ¶

Package

open-vrp.algo.

Source

tools.lisp.

Target Slot

vehicle-id.

Reader: node-demand (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

demand.

Function: node-distance (n1 n2) ¶

Given two node objects, calculate and return their distance (Cartesian).

Package

open-vrp.util.

Source

network.lisp.

Reader: node-duration (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

duration.

Reader: node-end (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

end.

Reader: node-id (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

id.

Function: node-on-routep (node-id vehicle) ¶

Returns NIL of <vehicle> does not have the node on its route.

Package

open-vrp.util.

Source

fleet.lisp.

Reader: node-start (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

start.

Reader: node-xcor (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

xcor.

Reader: node-ycor (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

ycor.

Function: one-destinationp (route) ¶

Return T if there is only one destination on route, excluding base nodes.

Package

open-vrp.util.

Source

route.lisp.

Function: print-final-results (prob algo &optional stream) ¶

Prints final results of run, helper function to :after methods of run-algo and solve-prob.

Package

open-vrp.util.

Source

output.lisp.

Function: print-multi-run-stats (algo-objects &optional str) ¶

Given a list of algo-objects returned by multi-run, print run-stats.

Package

open-vrp.util.

Source

output.lisp.

Function: print-timestamp (&optional stream) ¶

Prints timestamp to stream, source from cl-cookbook.

Package

open-vrp.util.

Source

output.lisp.

Function: print-vrp-object (object &optional stream) ¶

Given object, will print it’s object’s slots and values

Package

open-vrp.util.

Source

output.lisp.

Function: random-list-permutation (length) ¶

Randomly creates a permutation from 1 to length.

Package

open-vrp.util.

Source

list.lisp.

Function: remove-index (index list) ¶

Given a list, remove the object on index. Does not accept index out of bounds. Returns the new list AND the object that was removed.

Package

open-vrp.util.

Source

list.lisp.

Function: remove-node-at (veh index) ¶

Removes the <node> from the route of <vehicle> at index

Package

open-vrp.util.

Source

route.lisp.

Function: set-dist-array (problem dist-array) ¶

Given a <problem> and a 2-dimensional list or array in dist-array, set it in <problem>

Package

open-vrp.util.

Source

config-functions.lisp.

Function: set-log-file (prob path) ¶

Sets the output location of the log-file.

Package

open-vrp.util.

Source

config-functions.lisp.

Function: set-log-mode (prob x) ¶

Sets log-mode: 0 for no log, 1 for log to log-file, 2 for REPL log.

Package

open-vrp.util.

Source

config-functions.lisp.

Function: set-plot-file (prob path) ¶

Sets the plot output file location.

Package

open-vrp.util.

Source

config-functions.lisp.

Function: single (lst) ¶

Package

open-vrp.util.

Source

simple-utils.lisp.

Function: sort-ignore-nil (list predicate &key key) ¶

Sorts the sequence with #’< or #’> while passing all NIL values towards the end of result.

Package

open-vrp.util.

Source

list.lisp.

Function: sort-moves (moves) ¶

Given a list of <Move>s, sort them according to fitness (ascending). Undestructive.

Package

open-vrp.algo.

Source

iterator.lisp.

Function: sum (list) ¶

A quick list summer, 4 times as fast as (reduce #’+ list)

Package

open-vrp.util.

Source

simple-utils.lisp.

Function: time-after-serving-node (node arrival-time) ¶

Given a node to serve and the current time, return the new time (if on-time to begin with). When arrival-time is too early, wait till earliest start time.

Package

open-vrp.util.

Source

constraints.lisp.

Function: toggle-animate (algo) ¶

Toggles animation, which means plotting every iteration in run-frames/ folder

Package

open-vrp.util.

Source

config-functions.lisp.

Function: toggle-aspiration (ts) ¶

Package

open-vrp.algo.

Source

ts-utils.lisp.

Function: toggle-elite-list (ts) ¶

Package

open-vrp.algo.

Source

ts-utils.lisp.

Function: travel-time (n1 n2 &key dist-array speed) ¶

Given two <nodes> and optional speed, return the travel-time. When dist-array is not provided, calculate distance directly using coords.

Package

open-vrp.util.

Source

constraints.lisp.

Function: veh-in-timep (v &optional dist-array) ¶

Tests weather the route on <Vehicle> is complying with the time-window constraints. Returns T and the time of finishing its last task.

Package

open-vrp.util.

Source

constraints.lisp.

Reader: vehicle-capacity (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

capacity.

Reader: vehicle-id (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

id.

Reader: vehicle-route (instance) ¶

Writer: (setf vehicle-route) (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

route.

Reader: vehicle-speed (instance) ¶

Package

open-vrp.classes.

Source

class-definitions.lisp.

Target Slot

speed.

Function: vehicle-with-node-id (prob node-id) ¶

Given a node-ID, return the vehicle-ID that has the node in its route. The function for the input of the base-node 0 is undefined. Returns NIL if node-ID cannot be found.

Package

open-vrp.util.

Source

fleet.lisp.

---

6.1.4 Generic functions

Generic Reader: algo-animatep (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: algo-animatep ((algo algo)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

animatep.

Generic Writer: (setf algo-animatep) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf algo-animatep) ((algo algo)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

animatep.

Generic Reader: algo-best-fitness (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: algo-best-fitness ((algo algo)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

best-fitness.

Generic Writer: (setf algo-best-fitness) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf algo-best-fitness) ((algo algo)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

best-fitness.

Generic Reader: algo-best-iteration (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: algo-best-iteration ((algo algo)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

best-iteration.

Generic Writer: (setf algo-best-iteration) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf algo-best-iteration) ((algo algo)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

best-iteration.

Generic Reader: algo-best-sol (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: algo-best-sol ((algo algo)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

best-sol.

Generic Writer: (setf algo-best-sol) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf algo-best-sol) ((algo algo)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

best-sol.

Generic Reader: algo-current-sol (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: algo-current-sol ((algo algo)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

current-sol.

Generic Writer: (setf algo-current-sol) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf algo-current-sol) ((algo algo)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

current-sol.

Generic Reader: algo-desc (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: algo-desc ((algo algo)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

desc.

Generic Reader: algo-iterations (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: algo-iterations ((algo algo)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

iterations.

Generic Writer: (setf algo-iterations) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf algo-iterations) ((algo algo)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

iterations.

Generic Reader: algo-name (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: algo-name ((algo algo)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

name.

Generic Function: assess-move (sol move) ¶

The <Move> is assessed by calculating the fitness of solution before, and after. The fitness is the difference and is stored in the :fitness slot of the <Move> object.

Package

open-vrp.algo.

Source

iterator.lisp.

Methods

Method: assess-move ((sol problem) (mv ts-best-insertion-move)) ¶

Source

ts.lisp.

Method: assess-move ((sol problem) (m insertion-move)) ¶

Source

best-insertion.lisp.

Method: assess-move :around ((sol problem) (m move)) ¶

Method: assess-move ((sol problem) (m move)) ¶

Assesses the effect on fitness when <move> is performed on <problem> (on a clone - undestructive).

Method: assess-move (sol move) ¶

Generic Function: constraintsp (prob) ¶

Tests weather the solution in the <problem> is complying with the constraints. If the problem is a CVRP, check for capacity. If it is a VRPTW, check for time-windows. For CVRPTW, that inherits from both classes, check both constraints.

Package

open-vrp.util.

Source

constraints.lisp.

Method Combination

and.

Options

:most-specific-first

Methods

Method: constraintsp and ((sol vrptw)) ¶

Method: constraintsp and ((sol cvrp)) ¶

Method: constraintsp and ((prob problem)) ¶

Generic Function: feasible-movep (sol move) ¶

Given a current solution, assess feasibility of the <Move>. For CVRP, just check if it fits in the total vehicle capacity. For VRPTW, check for TW feasibility of the whole route. For CVRPTW, checks both by means of multiple-inheritance and method-combination.

Package

open-vrp.algo.

Source

tools.lisp.

Method Combination

and.

Options

:most-specific-first

Methods

Method: feasible-movep and ((sol vrptw) (m insertion-move)) ¶

Method: feasible-movep and ((sol cvrp) (m insertion-move)) ¶

Method: feasible-movep and ((sol problem) (m move)) ¶

Generic Function: fitness (problem) ¶

The generic fitness function. To be defined for each class of <problem> specifically. This function allows for custom fitness-functions for your own defined <problem> classess. The default fitness function is total distance.

Package

open-vrp.util.

Source

fitness.lisp.

Methods

Method: fitness ((prob problem)) ¶

Method: fitness (problem) ¶

Generic Function: generate-moves (algo) ¶

Given the algo object, that contains the current solution, generate potential <moves> for next iteration as defined by the algo. e.g. insertion moves for TS and chromosome pool for GA.

Package

open-vrp.algo.

Source

iterator.lisp.

Methods

Method: generate-moves ((ts tabu-search)) ¶

Generates a list of <move> instances (depending on what was defined in the ts slot) for all nodes and vehicles.

Source

ts.lisp.

Method: generate-moves (algo) ¶

Generic Function: get-best-insertion-move (prob node) ¶

Given a node and a solution (that does not have this node yet), return the best <insertion-move>.

Package

open-vrp.algo.

Source

best-insertion.lisp.

Methods

Method: get-best-insertion-move ((sol problem) (n node)) ¶

Method: get-best-insertion-move (prob node) ¶

Generic Function: get-closest-feasible-vehicle (n prob) ¶

Package

open-vrp.algo.

Methods

Method: get-closest-feasible-vehicle ((n node) (prob vrptw)) ¶

Returns the vehicle closest to the node that has enough time at the end of its route. Used for appending nodes. Use get-optimal-insertion instead for inserting feasibly into routes.

Source

tools.lisp.

Method: get-closest-feasible-vehicle ((n node) (prob cvrp)) ¶

Returns the vehicle closest to the node and has enough capacity.

Source

tools.lisp.

Method: get-closest-feasible-vehicle ((n node) (prob problem)) ¶

Source

tools.lisp.

Generic Function: in-capacityp (veh/cvrp) ¶

Tests weather the route on <vehicle> is complying with the capacity constraint. Returns T and the remaining capacity if it does. When <CVRP> is provided, test all vehicles.

Package

open-vrp.util.

Source

constraints.lisp.

Methods

Method: in-capacityp ((pr cvrp)) ¶

Method: in-capacityp ((v vehicle)) ¶

Method: in-capacityp (obj) ¶

Generic Function: in-timep (pr) ¶

Package

open-vrp.util.

Methods

Method: in-timep ((pr vrptw)) ¶

Source

constraints.lisp.

Generic Function: initialize (problem algo) ¶

Initializes the initial solution for the algo object.

Package

open-vrp.algo.

Source

iterator.lisp.

Methods

Method: initialize ((prob problem) (ts tabu-search)) ¶

Creates inital solution and sets it to :algo-current-sol. Returns the <tabu-search> object. For Tabu Search, the default heuristic for generating an initial solution is ’greedy-best-insertion, which is read from the slot :init-heur.

Source

ts.lisp.

Method: initialize (problem algo) ¶

Generic Function: iterate (algo) ¶

Runs the algo one iteration. Implementation of this method should use the algo’s slot current-sol as current solution and destructively adjust it to a new solution. When algo’s slot iterations is 0, then print the best solution found by this algo object. Returns the <algo> object. After each iterate, will automatically check if a new best solution has been found and adjust the :best-sol and :best-fitness slots for you. When :animatep is set to T, will plot current solution in run-frames/

Package

open-vrp.util.

Source

solver.lisp.

Methods

Method: iterate :around ((ts tabu-search)) ¶

Source

ts.lisp.

Method: iterate ((ts tabu-search)) ¶

Source

ts.lisp.

Method: iterate :after ((a algo)) ¶

Method: iterate :around ((a algo)) ¶

Method: iterate (algo) ¶

Generic Function: iterate-more (algo int) ¶

When an algo finished (i.e. iterations = 0) using iterate-more allows you to keep running it x more iterations. Also resets :best-iteration, which the stopping condition uses. Calls run-algo on the :current-sol of and with <algo>.

Package

open-vrp.util.

Source

solver.lisp.

Methods

Method: iterate-more :after ((a algo) int) ¶

Method: iterate-more ((a algo) int) ¶

Method: iterate-more (algo int) ¶

Generic Function: last-node (vehicle) ¶

Returns the last <node> in its route. Depicts the current location (before returning to base).

Package

open-vrp.util.

Source

route.lisp.

Methods

Method: last-node ((v vehicle)) ¶

Method: last-node (route) ¶

Generic Function: log-to-replp (prob/algo) ¶

Returns T if :log-mode is set to 2, which is REPL.

Package

open-vrp.util.

Source

output.lisp.

Methods

Method: log-to-replp ((a algo)) ¶

Method: log-to-replp ((p problem)) ¶

Generic Function: node (prob id) ¶

Package

open-vrp.classes.

Methods

Method: node ((prob problem) id) ¶

Source

network.lisp.

Generic Function: perform-move (sol move) ¶

Performs the move defined in <move> on the solution. Returns the new solution (which is a class of <Problem>)

Package

open-vrp.algo.

Source

iterator.lisp.

Methods

Method: perform-move ((sol problem) (mv ts-best-insertion-move)) ¶

Takes <Node> with node-ID and uses get-best-insertion to insert in vehicle-ID. DESTRUCTIVE.

Source

ts.lisp.

Method: perform-move :after ((prob problem) (mv insertion-move)) ¶

Source

best-insertion.lisp.

Method: perform-move ((sol problem) (m insertion-move)) ¶

Performs the <move> on <problem>.

Source

best-insertion.lisp.

Method: perform-move (sol move) ¶

Generic Function: plot-nodes (problem) ¶

Draws only the nodes in output file.

Package

open-vrp.util.

Source

draw-solution.lisp.

Methods

Method: plot-nodes ((prob problem)) ¶

Method: plot-nodes (problem) ¶

Generic Function: plot-solution (problem/algo &optional output-file) ¶

Given a solution object (<problem>/<algo>), draw the solution in output file given in the drawer object’s :filename slot (which is held in problem-drawer slot). When <algo> object as input, draw the best found solution by that algo object.

Package

open-vrp.util.

Source

draw-solution.lisp.

Methods

Method: plot-solution ((a algo) &optional output-file) ¶

Method: plot-solution ((sol problem) &optional output-file) ¶

Generic Function: print-routes (prob/algo &optional stream) ¶

Prints solution given a <problem>/<algo> object. Also prints the total distance when the input is a <problem>/<algo> object.

Package

open-vrp.util.

Source

output.lisp.

Methods

Method: print-routes ((a algo) &optional stream) ¶

Method: print-routes ((prob problem) &optional stream) ¶

Generic Reader: problem-desc (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-desc ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

desc.

Generic Reader: problem-dist-array (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-dist-array ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

dist-array.

Generic Writer: (setf problem-dist-array) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf problem-dist-array) ((problem problem)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

dist-array.

Generic Reader: problem-drawer (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-drawer ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

drawer.

Generic Writer: (setf problem-drawer) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf problem-drawer) ((problem problem)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

drawer.

Generic Reader: problem-fleet (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-fleet ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

fleet.

Generic Reader: problem-log-file (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-log-file ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

log-file.

Generic Writer: (setf problem-log-file) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf problem-log-file) ((problem problem)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

log-file.

Generic Reader: problem-log-mode (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-log-mode ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

log-mode.

Generic Writer: (setf problem-log-mode) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf problem-log-mode) ((problem problem)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

log-mode.

Generic Reader: problem-name (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-name ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

name.

Generic Reader: problem-network (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-network ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

network.

Generic Reader: problem-to-depot (object) ¶

Package

open-vrp.classes.

Methods

Reader Method: problem-to-depot ((problem problem)) ¶

automatically generated reader method

Source

class-definitions.lisp.

Target Slot

to-depot.

Generic Writer: (setf problem-to-depot) (object) ¶

Package

open-vrp.classes.

Methods

Writer Method: (setf problem-to-depot) ((problem problem)) ¶

automatically generated writer method

Source

class-definitions.lisp.

Target Slot

to-depot.

Generic Function: remove-node-id (veh/prob node-id) ¶

Removes the <node> with node-ID from the route of <vehicle>. Returns NIL if failed to find node-ID.

Package

open-vrp.util.

Source

route.lisp.

Methods

Method: remove-node-id ((prob problem) node-id) ¶

Method: remove-node-id ((v vehicle) node-id) ¶

Method: remove-node-id (vehicle node-id) ¶

Generic Function: route-indices (obj) ¶

When input is a <vehicle>, returns its route as a list of node IDs. When input is <fleet>/<problem>, list all routes.

Package

open-vrp.util.

Source

fleet.lisp.

Methods

Method: route-indices ((p problem)) ¶

Method: route-indices ((v vehicle)) ¶

Method: route-indices (vehicle) ¶

Generic Function: run-algo (problem algo) ¶

Runs the algo on the problem. Destructive - will have side-effects on the <problem> and <algo> objects. Use solve-prob to prevent <problem> object being touched. Will return the <Algo> object, which will contain the solution (in the form of a copy of the <problem> object) in the :best-sol slot. When defining your own algorithms, make sure to implement a run-algo method for your algo, which sets the <algo> slots appropriately, and returns the <algo> object. For algorithms that just build a solution (like greedy-best-insertion or greedy-append), you can use init-algo to set :current-sol, :best-sol, :best-fitness simultaneously. For search algorithms – such as local search, population based algorithms – may make use of the iterate method to automatically set the slots after each iteration.

Package

open-vrp.util.

Source

solver.lisp.

Methods

Method: run-algo ((prob problem) (ts tabu-search)) ¶

Initialize (if necessary), iterate till finished. Returns <Algo> object.

Source

ts.lisp.

Method: run-algo ((p problem) (a greedy-best-insertion)) ¶

Randomly insert <Nodes> one by one to best <vehicle> in best location. Returns <Algo> object when done.

Source

greedy-best-insertion.lisp.

Method: run-algo ((p problem) (a greedy-append)) ¶

Randomly append <Nodes> one by one to the closest <Vehicle>. Returns <Algo> object when done. Also prints the fitness and solution.

Source

greedy-append.lisp.

Method: run-algo ((p problem) (a greedy-nn)) ¶

While there exists unchosen nodes, keep appending it. Returns the <Algo> object when done. Also prints the fitness and solution (run-algo :after method).

Source

greedy-nn.lisp.

Method: run-algo :after ((p problem) (a algo)) ¶

Method: run-algo :around ((p problem) (a algo)) ¶

Method: run-algo (problem algo) ¶

Generic Function: select-move (algo moves) ¶

Given an <Algo> object and the list of <Moves>, select a move. By default, sort the moves and select the best one, but e.g. for tabu-search, check first of the <Move> is tabu.

Package

open-vrp.algo.

Source

iterator.lisp.

Methods

Method: select-move ((ts tabu-search) all-moves) ¶

This function selects best non-tabu move from a list of assessed moves. When aspiration criteria is set to T, then if by performing the move we get a new best solution, circumvent the tabu-list.

Source

ts.lisp.

Method: select-move ((a algo) moves) ¶

Method: select-move (algo moves) ¶

Generic Function: solve-prob (problem algo) ¶

Solves the problem with the algo. Uses run-algo, but leaves the <problem> object untouched (<Algo> will suffer side-effects). Works with a clone (copy-object in lib/simple-utils.lisp). NON-destructive wrapper to the run-algo method.

Package

open-vrp.util.

Source

solver.lisp.

Methods

Method: solve-prob :after ((p problem) (a algo)) ¶

Method: solve-prob :before ((p problem) (a algo)) ¶

Method: solve-prob ((problem problem) (algo algo)) ¶

Method: solve-prob (problem algo) ¶

Generic Reader: tabu-list (condition) ¶

Package

open-vrp.algo.

Methods

Reader Method: tabu-list ((condition all-moves-tabu)) ¶

Source

algo-conditions.lisp.

Target Slot

tabu-list.

Generic Function: toggle-legend (problem/algo) ¶

Toggles legend drawing. When <Algo> is provided, toggles :best-sol

Package

open-vrp.util.

Source

config-functions.lisp.

Methods

Method: toggle-legend ((a algo)) ¶

Method: toggle-legend ((pr problem)) ¶

Generic Function: toggle-plot (problem/algo) ¶

Toggles plotting on/off of best solution. Config boolean is held by <Drawer> object’s plotp slot.

Package

open-vrp.util.

Source

config-functions.lisp.

Methods

Method: toggle-plot ((a algo)) ¶

Method: toggle-plot ((pr problem)) ¶

Generic Function: total-dist (veh/prob dist-array) ¶

Returns total distance of the route(s) given a vehicle or a fleet.

Package

open-vrp.util.

Source

fleet.lisp.

Methods

Method: total-dist ((p problem) dist-array) ¶

Method: total-dist ((v vehicle) dist-array) ¶

Method: total-dist (veh/prob dist-array) ¶

Generic Reader: ts-aspirationp (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-aspirationp ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

aspirationp.

Generic Writer: (setf ts-aspirationp) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-aspirationp) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

aspirationp.

Generic Reader: ts-candidate-list (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-candidate-list ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

candidate-list.

Generic Writer: (setf ts-candidate-list) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-candidate-list) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

candidate-list.

Generic Reader: ts-elite-listp (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-elite-listp ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

elite-listp.

Generic Writer: (setf ts-elite-listp) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-elite-listp) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

elite-listp.

Generic Reader: ts-init-heur (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-init-heur ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

init-heur.

Generic Writer: (setf ts-init-heur) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-init-heur) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

init-heur.

Generic Reader: ts-move-type (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-move-type ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

move-type.

Generic Writer: (setf ts-move-type) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-move-type) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

move-type.

Generic Reader: ts-parameter-f (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-parameter-f ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

tabu-parameter-f.

Generic Writer: (setf ts-parameter-f) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-parameter-f) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

tabu-parameter-f.

Generic Reader: ts-stopping-condition (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-stopping-condition ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

stopping-condition.

Generic Writer: (setf ts-stopping-condition) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-stopping-condition) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

stopping-condition.

Generic Reader: ts-tabu-list (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-tabu-list ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

tabu-list.

Generic Writer: (setf ts-tabu-list) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-tabu-list) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

tabu-list.

Generic Reader: ts-tenure (object) ¶

Package

open-vrp.algo.

Methods

Reader Method: ts-tenure ((tabu-search tabu-search)) ¶

automatically generated reader method

Source

ts-classdef.lisp.

Target Slot

tabu-tenure.

Generic Writer: (setf ts-tenure) (object) ¶

Package

open-vrp.algo.

Methods

Writer Method: (setf ts-tenure) ((tabu-search tabu-search)) ¶

automatically generated writer method

Source

ts-classdef.lisp.

Target Slot

tabu-tenure.

Generic Function: vehicle (p id) ¶

Package

open-vrp.classes.

Methods

Method: vehicle ((p problem) id) ¶

Source

fleet.lisp.

---