Jackson a

Clique/gen/generate.py

@@ -0,0 +1,68 @@
+# File: generate.py
+# Author: Jackson Madsen
+
+# Description: Graph generator for clique problem solver
+# Use: python3 genereate.py -n num -k num > filename.lp
+#      python3 generate.py -n num > filename.lp
+#      python3 generate.py -k num > filename.lp
+#      python3 generate.py > filename.lp
+
+import argparse
+from random import randint
+
+# Process arguments
+parser = argparse.ArgumentParser()
+
+parser.add_argument('-n', default = 10, type = int, 
+			help = "Upper limit on number of nodes, non-inclusive. (Default = 10)")
+parser.add_argument('-k', default = 3, type = int,
+			help = "The clique size that is guaranteed to be found in the graph (Default = 3)")
+args = parser.parse_args()
+
+numNodes = args.n
+cliqueSize = args.k
+
+# Generate all possible nodes
+print("node(", sep = "", end = "")
+for x in range(1, numNodes):
+  print(x, " ; ", sep = "", end = "")
+print(numNodes, ").", sep ="")
+
+# Collect arbitrary nodes that will form the clique
+connected = set()
+while len(connected) < cliqueSize:
+  index = randint(1, numNodes)
+  connected.add(index)
+
+connected = list(connected)
+
+# Generate edges, with some random additional edges thrown in as well
+for i in connected:
+  seen = set(connected)
+  edgeStr = f"edge({i}, ("
+  for j in connected:
+    if i != j:
+      edgeStr += f"{j} ; "
+  for _ in range(randint(0, numNodes)):
+    randNode = randint(1, numNodes)
+    if randNode not in seen:
+      seen.add(randNode)
+      edgeStr += f"{randNode} ; "
+
+  print(edgeStr[:len(edgeStr)-3] + ")).")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

Clique/gen/instance1.lp

@@ -0,0 +1,16 @@
+node(1 ; 2 ; 3 ; 4 ; 5 ; 6 ; 7 ; 8 ; 9 ; 10 ; 11 ; 12 ; 13 ; 14 ; 15 ; 16 ; 17 ; 18 ; 19 ; 20 ; 21 ; 22 ; 23 ; 24 ; 25 ; 26 ; 27 ; 28 ; 29 ; 30 ; 31 ; 32 ; 33 ; 34 ; 35 ; 36 ; 37 ; 38 ; 39 ; 40 ; 41 ; 42 ; 43 ; 44 ; 45 ; 46 ; 47 ; 48 ; 49 ; 50 ; 51 ; 52 ; 53 ; 54 ; 55 ; 56 ; 57 ; 58 ; 59 ; 60 ; 61 ; 62 ; 63 ; 64 ; 65 ; 66 ; 67 ; 68 ; 69 ; 70 ; 71 ; 72 ; 73 ; 74 ; 75 ; 76 ; 77 ; 78 ; 79 ; 80 ; 81 ; 82 ; 83 ; 84 ; 85 ; 86 ; 87 ; 88 ; 89 ; 90 ; 91 ; 92 ; 93 ; 94 ; 95 ; 96 ; 97 ; 98 ; 99 ; 100).
+edge(2, (67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 22 ; 73 ; 43 ; 58 ; 19 ; 57 ; 7 ; 87 ; 81 ; 77 ; 41 ; 71 ; 72 ; 33 ; 44 ; 36 ; 34 ; 50 ; 53 ; 95 ; 6 ; 59 ; 35 ; 24 ; 32 ; 85 ; 9 ; 28 ; 18 ; 91 ; 76 ; 86 ; 15 ; 100 ; 54 ; 83 ; 31)).
+edge(67, (2 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 4 ; 94 ; 19 ; 71 ; 93 ; 69 ; 15 ; 43 ; 50 ; 63 ; 89 ; 97 ; 82 ; 17 ; 47 ; 44 ; 14 ; 52 ; 70 ; 40 ; 58 ; 99 ; 35 ; 64 ; 91 ; 18 ; 9 ; 90 ; 98 ; 41 ; 10 ; 39 ; 33)).
+edge(3, (2 ; 67 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 61)).
+edge(5, (2 ; 67 ; 3 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 48 ; 54 ; 7 ; 20 ; 99 ; 55 ; 63 ; 34 ; 81)).
+edge(38, (2 ; 67 ; 3 ; 5 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 6 ; 60 ; 35 ; 43 ; 24 ; 81 ; 47 ; 97 ; 89 ; 28 ; 95 ; 30 ; 79 ; 36 ; 100 ; 41 ; 71 ; 52 ; 66 ; 1 ; 83 ; 48 ; 8 ; 64 ; 90 ; 21 ; 96 ; 78 ; 70 ; 33 ; 69 ; 37 ; 87 ; 7 ; 23 ; 29 ; 72 ; 59 ; 94 ; 39 ; 51)).
+edge(42, (2 ; 67 ; 3 ; 5 ; 38 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 1 ; 100 ; 10 ; 87 ; 25 ; 60 ; 62 ; 97 ; 94 ; 48 ; 39)).
+edge(11, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 70 ; 14 ; 47 ; 59 ; 89 ; 91 ; 78 ; 82 ; 40 ; 71 ; 76 ; 90 ; 63 ; 30 ; 58 ; 95 ; 88 ; 81 ; 18 ; 48 ; 17 ; 62 ; 8 ; 22 ; 65 ; 87 ; 43 ; 13 ; 93 ; 97 ; 54 ; 84 ; 32 ; 50 ; 85 ; 80 ; 33 ; 15 ; 55 ; 29 ; 4 ; 46 ; 28 ; 35 ; 96 ; 53 ; 74 ; 98 ; 66 ; 19 ; 64 ; 99)).
+edge(75, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 52 ; 34 ; 98 ; 55 ; 44 ; 58 ; 88 ; 19 ; 65 ; 47 ; 68 ; 37 ; 29 ; 9 ; 31 ; 66 ; 72 ; 84 ; 23 ; 74 ; 50 ; 4 ; 100 ; 14 ; 81 ; 40 ; 20 ; 48 ; 43 ; 22 ; 70 ; 97 ; 85 ; 39 ; 57 ; 92 ; 77 ; 8 ; 30 ; 71 ; 15 ; 24 ; 36 ; 53 ; 28 ; 60 ; 1 ; 63 ; 80 ; 33 ; 35 ; 18 ; 10 ; 86 ; 94)).
+edge(45, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 12 ; 16 ; 49 ; 56 ; 26 ; 27 ; 53 ; 96 ; 21 ; 61 ; 63 ; 32 ; 72 ; 24 ; 65 ; 99 ; 57 ; 73 ; 14 ; 44 ; 40 ; 47 ; 52 ; 83 ; 23 ; 74 ; 4 ; 68 ; 25 ; 76 ; 84 ; 13 ; 93 ; 33 ; 10)).
+edge(12, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 16 ; 49 ; 56 ; 26 ; 27 ; 73 ; 23 ; 92 ; 71 ; 98 ; 34 ; 74 ; 96 ; 31 ; 84 ; 7 ; 65 ; 53 ; 44 ; 21 ; 41 ; 46 ; 82 ; 59 ; 4 ; 30 ; 97 ; 58 ; 36 ; 90 ; 19 ; 9 ; 88 ; 86 ; 13 ; 66 ; 68 ; 55 ; 57 ; 99 ; 47 ; 64 ; 18 ; 33 ; 22 ; 62 ; 72 ; 25 ; 79 ; 20)).
+edge(16, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 49 ; 56 ; 26 ; 27 ; 68 ; 86 ; 58 ; 74 ; 43 ; 84 ; 28 ; 93 ; 10 ; 51 ; 61 ; 72 ; 94 ; 87 ; 89 ; 52 ; 32 ; 77 ; 53 ; 37 ; 25 ; 97 ; 71 ; 46 ; 23 ; 63 ; 29 ; 62 ; 100 ; 33 ; 21 ; 1 ; 76 ; 47 ; 44 ; 8 ; 80 ; 66 ; 73 ; 35 ; 64 ; 59 ; 36 ; 82)).
+edge(49, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 56 ; 26 ; 27 ; 22 ; 34 ; 97 ; 31 ; 70 ; 88 ; 82 ; 86 ; 94 ; 17 ; 98 ; 36 ; 28 ; 84 ; 62 ; 96 ; 55 ; 76 ; 74 ; 57 ; 9 ; 24 ; 39 ; 41 ; 6 ; 99 ; 30 ; 90 ; 10 ; 58 ; 60 ; 64 ; 91 ; 100 ; 35 ; 47 ; 79 ; 65 ; 15 ; 21 ; 43 ; 33 ; 23 ; 44 ; 46 ; 83 ; 8 ; 73)).
+edge(56, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 26 ; 27 ; 1 ; 89 ; 20 ; 58 ; 37 ; 40 ; 50 ; 33 ; 86 ; 43 ; 61 ; 52 ; 24 ; 68 ; 77 ; 59 ; 96 ; 98 ; 99)).
+edge(26, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 27 ; 52 ; 1 ; 71 ; 9 ; 72 ; 19 ; 51 ; 66 ; 73 ; 36 ; 20 ; 65 ; 98 ; 90 ; 59 ; 29 ; 33 ; 41 ; 63 ; 76 ; 93 ; 24 ; 87 ; 77 ; 84 ; 8 ; 17 ; 91 ; 92 ; 55 ; 50)).
+edge(27, (2 ; 67 ; 3 ; 5 ; 38 ; 42 ; 11 ; 75 ; 45 ; 12 ; 16 ; 49 ; 56 ; 26 ; 72 ; 70 ; 96 ; 8 ; 20 ; 19 ; 37)).

Perfect-Numbers/gen/README.md

@@ -0,0 +1,8 @@
+# Problem: Perfect-Numbers
+
+## Generator Description
+This problem does not contain an instance generator
+due to the nature of the problem. We are finding all
+the perfect numbers from 2 to an upper limit n. Since 
+the user provides this upper limit of n, no instance
+generator is necessary.

Prime-Sieve/gen/README.md

@@ -0,0 +1,9 @@
+# Problem: Prime-Sieve
+
+## Generator Description
+This problem does not contain an instance generator
+due to the nature of the problem. We are filtering 
+through all the possible numbers from 2 through n,
+filtering for primes or composites. Since the user
+provides this upper limit of n, no instance
+generator is necessary.