Update the documentation so that the examples are runnable by copy-pasting

Author: jbytecode

CHANGELOG.md

@@ -1,7 +1,7 @@
 ### 0.2.10 (Upcoming Release)
 
 - Update docs example in travelingsalesman.
-
+- Update the documentation so that the examples are runnable by copy-pasting.
 
 ### 0.2.9 
 

src/assignment.jl

@@ -119,26 +119,15 @@ Solves an assignment problem given by an object of in type `AssignmentProblem`.
 # Example 
 
 ```julia
-julia> mat = [
-                   4 8 1;
-                   3 1 9;
-                   1 6 7;
-               ];
+mat = [
+        4 8 1;
+        3 1 9;
+        1 6 7;
+    ];
 
-julia> problem = AssignmentProblem(mat);
+problem = AssignmentProblem(mat);
 
-julia> result = solve(problem);
-
-julia> result.solution
-
-3×3 Matrix{Float64}:
- 0.0  0.0  1.0
- 0.0  1.0  0.0
- 1.0  0.0  0.0
-
-julia> result.cost
-
-3.0
+result = solve(problem);
 ```
 """
 function solve(a::AssignmentProblem)::AssignmentResult

src/cpm.jl

@@ -27,11 +27,11 @@ The object that represents an activity in CPM (Critical Path Method).
 # Example
 
 ```julia
-julia> A = CpmActivity("A", 2, []);
+A = CpmActivity("A", 2, []);
 
-julia> B = CpmActivity("B", 3, []);
+B = CpmActivity("B", 3, []);
 
-julia> C = CpmActivity("C", 2, [A, B]);
+C = CpmActivity("C", 2, [A, B]);
 
 ```
 """
@@ -96,9 +96,9 @@ The object that represents an activity in PERT (Program Evaluation and Review Te
 
 # Example
 ```julia
-julia> A = PertActivity("A", 1, 2, 3);
-julia> B = PertActivity("B", 3, 3, 4);
-julia> C = PertActivity("C", 5, 6, 7, [A, B]);
+A = PertActivity("A", 1, 2, 3);
+B = PertActivity("B", 3, 3, 4);
+C = PertActivity("C", 5, 6, 7, [A, B]);
 ```
 """
 struct PertActivity
@@ -218,32 +218,23 @@ Calculates CPM (Critical Path Method) and reports the critical path for a given
 # Example 
 
 ```julia 
-julia> A = CpmActivity("A", 2);
-julia> B = CpmActivity("B", 3);
-julia> C = CpmActivity("C", 2, [A]);
-julia> D = CpmActivity("D", 3, [B]);
-julia> E = CpmActivity("E", 2, [B]);
-julia> F = CpmActivity("F", 3, [C, D]);
-julia> G = CpmActivity("G", 7, [E]);
-julia> H = CpmActivity("H", 5, [E]);
-julia> I = CpmActivity("I", 6, [G, F]);
-julia> J = CpmActivity("J", 2, [C, D]);
-
-julia> activities = [A, B, C, D, E, F, G, H, I, J];
-
-julia> problem = CpmProblem(activities);
-
-julia> result = solve(problem);
-
-julia> result.pathstr
-4-element Vector{String}:
- "B"
- "E"
- "G"
- "I"
-
- julia> result.path == [B, E, G, I]
-true
+A = CpmActivity("A", 2);
+B = CpmActivity("B", 3);
+C = CpmActivity("C", 2, [A]);
+D = CpmActivity("D", 3, [B]);
+E = CpmActivity("E", 2, [B]);
+F = CpmActivity("F", 3, [C, D]);
+G = CpmActivity("G", 7, [E]);
+H = CpmActivity("H", 5, [E]);
+I = CpmActivity("I", 6, [G, F]);
+J = CpmActivity("J", 2, [C, D]);
+
+activities = [A, B, C, D, E, F, G, H, I, J];
+
+problem = CpmProblem(activities);
+
+result = solve(problem);
+
 ``` 
 """
 function solve(problem::CpmProblem)::CpmResult
@@ -315,31 +306,20 @@ end
 # Example
 
 ```julia
-julia> A = PertActivity("A", 1, 2, 3)
-PertActivity("A", 1.0, 2.0, 3.0, PertActivity[])
-
-julia> B = PertActivity("B", 3, 3, 3)
-PertActivity("B", 3.0, 3.0, 3.0, PertActivity[])
+A = PertActivity("A", 1, 2, 3)
 
-julia> C = PertActivity("C", 5, 5, 5, [A, B])
-PertActivity("C", 5.0, 5.0, 5.0, PertActivity[PertActivity("A", 1.0, 2.0, 3.0, PertActivity[]), PertActivity("B", 3.0, 3.0, 3.0, PertActivity[])])
+B = PertActivity("B", 3, 3, 3)
 
-julia> activities = [A, B, C]
-3-element Vector{PertActivity}:
- PertActivity("A", 1.0, 2.0, 3.0, PertActivity[])
- PertActivity("B", 3.0, 3.0, 3.0, PertActivity[])
- PertActivity("C", 5.0, 5.0, 5.0, PertActivity[PertActivity("A", 1.0, 2.0, 3.0, PertActivity[]), PertActivity("B", 3.0, 3.0, 3.0, PertActivity[])])
+C = PertActivity("C", 5, 5, 5, [A, B])
 
-julia> problem = PertProblem(activities);
+activities = [A, B, C]
 
-julia> result = pert(activities)
-PertResult(PertActivity[PertActivity("B", 3.0, 3.0, 3.0, PertActivity[]), PertActivity("C", 5.0, 5.0, 5.0, PertActivity[PertActivity("A", 1.0, 2.0, 3.0, PertActivity[]), PertActivity("B", 3.0, 3.0, 3.0, PertActivity[])])], 8.0, 0.0)
+problem = PertProblem(activities);
 
-julia> result.mean
-8.0
+result = pert(activities)
 
-julia> result.stddev
-0.0
+println(result.mean)
+println(result.stddev)
 ```
 """
 function solve(problem::PertProblem)::PertResult

src/johnsons.jl

@@ -250,15 +250,15 @@ Given a problem containing a matrix of times and a permutation of the jobs, retu
 
 ```julia
 
-julia> times = Float64[
+times = Float64[
     3 3 5;
     8 4 8;
     7 2 10;
     5 1 7;
     2 5 6    
 ]
 
-julia> result = makespan(JohnsonProblem(times), [1, 4, 5, 3, 2])
+result = makespan(JohnsonProblem(times), [1, 4, 5, 3, 2])
 ```
 """
 function makespan(problem::JohnsonProblem, permutation::Vector{Int})::Float64

src/knapsack.jl

@@ -71,10 +71,10 @@ Solves the knapsack problem.
 
 # Example
 ```julia
-julia> values = [10, 20, 30, 40, 50];
-julia> weights = [1, 2, 3, 4, 5];
-julia> capacity = 10;
-julia> solve(KnapsackProblem(values, weights, capacity));
+values = [10, 20, 30, 40, 50];
+weights = [1, 2, 3, 4, 5];
+capacity = 10;
+solve(KnapsackProblem(values, weights, capacity));
 ```
 """
 function solve(problem::KnapsackProblem)::KnapsackResult

src/maximumflow.jl

@@ -72,34 +72,25 @@ Solves a maximum flow problem given by an object of in type `MaximumFlowProblem`
 # Example
 
 ```julia
-julia> conns = [
-                   Connection(1, 2, 3),
-                   Connection(1, 3, 2),
-                   Connection(1, 4, 4),
-                   Connection(2, 5, 3),
-                   Connection(3, 5, 1),
-                   Connection(3, 6, 1),
-                   Connection(4, 6, 2),
-                   Connection(5, 7, 6),
-                   Connection(6, 7, 5),
-               ];
-julia> problem = MaximumFlowProblem(conns)
-julia> result = solve(problem);
-
-julia> result.path
-9-element Vector{Connection}:
- Connection(1, 2, 3.0)
- Connection(1, 3, 2.0)
- Connection(1, 4, 2.0)
- Connection(2, 5, 3.0)
- Connection(3, 5, 1.0)
- Connection(3, 6, 1.0)
- Connection(4, 6, 2.0)
- Connection(5, 7, 4.0)
- Connection(6, 7, 3.0)
-
-julia> result.flow
-7.0
+conns = [
+    Connection(1, 2, 3),
+    Connection(1, 3, 2),
+    Connection(1, 4, 4),
+    Connection(2, 5, 3),
+    Connection(3, 5, 1),
+    Connection(3, 6, 1),
+    Connection(4, 6, 2),
+    Connection(5, 7, 6),
+    Connection(6, 7, 5),
+];
+
+problem = MaximumFlowProblem(conns)
+
+result = solve(problem);
+
+println(result.path)
+
+println(result.flow)
 ```
 
 !!! info "Determining start and finish nodes"

src/mst.jl

@@ -142,30 +142,20 @@ Obtains the minimum spanning tree.
 # Examples 
 
 ```julia 
-julia> conns = Connection[
-                       Connection(1, 2, 10),
-                       Connection(2, 3, 10),
-                       Connection(3, 4, 10),
-                       Connection(1, 4, 10)
-                   ]
-
-4-element Vector{Connection}:
- Connection(1, 2, 10)
- Connection(2, 3, 10)
- Connection(3, 4, 10)
- Connection(1, 4, 10)
-
- julia> result = solve(MstProblem(conns))
- MstResult(Connection[Connection(3, 4, 10), Connection(1, 4, 10), Connection(2, 3, 10)], 30.0)
- 
- julia> result.distance
- 30.0
- 
- julia> result.connections
- 3-element Vector{Connection}:
-  Connection(3, 4, 10)
-  Connection(1, 4, 10)
-  Connection(2, 3, 10)
+conns = Connection[
+    Connection(1, 2, 10),
+    Connection(2, 3, 10),
+    Connection(3, 4, 10),
+    Connection(1, 4, 10)
+]
+
+result = solve(MstProblem(conns))
+
+MstResult(Connection[Connection(3, 4, 10), Connection(1, 4, 10), Connection(2, 3, 10)], 30.0)
+
+println(result.distance)
+
+println(result.connections)
 ```
 """
 function solve(problem::MstProblem)::MstResult

src/pmedian.jl

@@ -58,26 +58,25 @@ The function calculates Euclidean distances between all possible rows of the mat
 # Example 
 
 ```julia
-julia> data1 = rand(10, 2);
+data1 = rand(10, 2)
 
-julia> data2 = rand(10, 2) .+ 50;
+data2 = rand(10, 2) .+ 50
 
-julia> data3 = rand(10, 2) .+ 100;
+data3 = rand(10, 2) .+ 100
 
-julia> data = vcat(data1, data2, data3);
+data = vcat(data1, data2, data3)
 
-julia> result = pmedian(data, 3);
+result = pmedian(data, 3);
 
-julia> result.centers
-3-element Vector{Int64}:
-  1
- 16
- 21
+println(result.centers)
+# 3-element Vector{Int64}:
+#  1
+# 16
+# 21
 
- julia> result.objective
- 11.531012240599605
+println(result.objective)
+# 11.531012240599605
 ``` 
-
 """
 function pmedian(data::Matrix, ncenters::Int)::PMedianResult
 

src/shortestpath.jl

@@ -68,28 +68,28 @@ Solves a shortest path problem given by an object of in type `ShortestPathProble
 # Example
 
 ```julia 
-julia> conns = [
-                   Connection(1, 2, 3),
-                   Connection(1, 3, 2),
-                   Connection(1, 4, 4),
-                   Connection(2, 5, 3),
-                   Connection(3, 5, 1),
-                   Connection(3, 6, 1),
-                   Connection(4, 6, 2),
-                   Connection(5, 7, 6),
-                   Connection(6, 7, 5),
-               ];
-
-julia> solve(ShortestPathProblem(conns));
-
-julia> result.path
-3-element Vector{Connection}:
- Connection(1, 3, 2)
- Connection(3, 6, 1)
- Connection(6, 7, 5)
-
-julia> result.cost
-8.0
+conns = [
+    Connection(1, 2, 3),
+    Connection(1, 3, 2),
+    Connection(1, 4, 4),
+    Connection(2, 5, 3),
+    Connection(3, 5, 1),
+    Connection(3, 6, 1),
+    Connection(4, 6, 2),
+    Connection(5, 7, 6),
+    Connection(6, 7, 5),
+]
+
+result = solve(ShortestPathProblem(conns))
+
+println(result.path)
+# 3-element Vector{Connection}:
+#  Connection(1, 3, 2)
+#  Connection(3, 6, 1)
+#  Connection(6, 7, 5)
+
+println(result.cost)
+# 8.0
 ```
 
 !!! info "Determining start and finish nodes"