Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP

Comparing changes

Choose two branches to see what's changed or to start a new pull request. If you need to, you can also compare across forks.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also compare across forks.
base: 29b0237490
...
compare: a4c309bd1f
  • 12 commits
  • 6 files changed
  • 0 commit comments
  • 2 contributors
View
2  README.chickenwiki
@@ -8,7 +8,7 @@ Do not edit this page, it is maintained in the this package's [https://github.co
This is work in progress. A library of graph algorithms. Currently
only supports directed graphs.
-It's currently undocumented but will one day have documentation.
+Documentation is in the form of examples, see examples/graph-overview.scm.
=== License ===
View
2  README.mediawiki
@@ -3,7 +3,7 @@
This is work in progress. A library of graph algorithms. Currently
only supports directed graphs.
-It's currently undocumented but will one day have documentation.
+Documentation is in the form of examples, see examples/graph-overview.scm.
=== License ===
View
192 examples/graph-overview.scm
@@ -0,0 +1,192 @@
+(use graph)
+
+(define (mst-example)
+ ;; total cost should be 39
+ (mst
+ (digraph->graph
+ (alist->digraph
+ '((a d 5) (a b 7)
+ (b c 8) (b e 7) (b d 9)
+ (c e 5)
+ (d e 15) (d f 6)
+ (e g 9) (e f 8)
+ (g f 11))))
+ edge-label))
+
+(define (topological-sort-example)
+ (graph-topological-sort
+ (alist->digraph
+ '((7 11 #f) (7 8 #f) (5 11 #f) (3 8 #f) (3 10 #f)
+ (11 2 #f) (11 9 #f) (11 10 #f) (8 9 #f)))))
+
+(define (tsp-examples)
+ (let ((a (tsp ; 14
+ (digraph->graph
+ (alist->digraph
+ '((a b 2) (a e 2) (a d 1) (a f 2)
+ (b c 4) (b d 5) (b e 1)
+ (c e 2) (c f 3) (d e 4) (e f 2))))
+ edge-label))
+ (b (tsp ; 54
+ (digraph->graph
+ (alist->digraph
+ '((a b 10) (a c 15) (a s 10) (a e 14) (a m 11)
+ (b m 15) (b s 9) (b e 13) (b c 8)
+ (c s 10) (c m 16) (c e 11)
+ (e s 6) (e m 9)
+ (s m 15))))
+ edge-label)))
+ (list (list (map vertex-label (car a)) (cdr a))
+ (list (map vertex-label (car b)) (cdr b)))))
+
+(define (dijkistra-example)
+ ;; ((5 . 20) (4 . 20) (6 . 11) (1 . 0) (3 . 9) (2 . 7))
+ (map (lambda (a) (cons (vertex-label (car a)) (cdr a)))
+ (let ((graph (digraph->graph
+ (alist->digraph
+ '((1 2 7) (1 3 9) (1 6 14)
+ (2 3 10) (2 4 15)
+ (3 6 2) (3 4 11)
+ (4 5 6) (5 6 9))))))
+ (dijkstras-algorithm
+ graph
+ (car (graph-vertices graph))
+ edge-label))))
+
+(define (scc-example)
+ ;; http://en.wikipedia.org/wiki/File:Scc.png
+ ;; ((a b e) (c d h) (f g))
+ (map (lambda (scc) (map vertex-label scc))
+ (let ((graph (alist->digraph
+ '((a b)
+ (b c) (b e) (b f)
+ (c d) (c g)
+ (d c) (d h)
+ (e a) (e f)
+ (f g)
+ (g f)
+ (h g) (h d)))))
+ (strongly-connected-components graph))))
+
+(define (contract-edge-example)
+ ;; will look like a v structure
+ (let ((graph (alist->digraph '((a b) (c d)))))
+ (contract-edge-between!
+ graph
+ (find (lambda (v) (equal? 'b (vertex-label v))) (graph-vertices graph))
+ (find (lambda (v) (equal? 'd (vertex-label v))) (graph-vertices graph)))
+ (show-graph graph vertex->label: #t)))
+
+(define (show-graph-example)
+ ;; ;; http://en.wikipedia.org/wiki/File:Scc.png
+ (show-graph
+ (alist->digraph
+ '((a b)
+ (b c) (b e) (b f)
+ (c d) (c g)
+ (d c) (d h)
+ (e a) (e f)
+ (f g)
+ (g f)
+ (h g) (h d)))
+ vertex->label: #t))
+
+
+(define (maximum-flow-example)
+ ;; 12
+ (pp (let ((graph
+ (alist->digraph
+ '((s a 5) (s b 10) (s d 4)
+ (a c 1) (a t 3)
+ (b c 7) (b e 7) (b d 3)
+ (d e 6) (c t 5) (e t 4)))))
+ (car (graph-maximum-flow
+ graph
+ ;; source
+ (find-if (lambda (a) (eq? (vertex-label a) 's)) (graph-vertices graph))
+ ;; sink
+ (find-if (lambda (a) (eq? (vertex-label a) 't)) (graph-vertices graph))
+ ;; capacity
+ edge-label))))
+
+ ;; 4
+ (pp (let ((graph
+ (alist->digraph
+ '((1 2 8) (1 3 3)
+ (2 4 3) (3 4 1)
+ (2 5 1) (3 5 1)
+ (4 6 2) (5 6 3)))))
+ (car (graph-maximum-flow
+ graph
+ ;; source
+ (find-if (lambda (a) (eq? (vertex-label a) '1)) (graph-vertices graph))
+ ;; sink
+ (find-if (lambda (a) (eq? (vertex-label a) '6)) (graph-vertices graph))
+ ;; capacity
+ edge-label))))
+
+ ;; 5
+ (pp (let ((graph
+ (alist->digraph
+ '((a d 3) (a b 3)
+ (b c 4)
+ (c a 3) (c d 1) (c e 2)
+ (d e 2) (d f 6)
+ (e b 1) (e g 1)
+ (f g 9)))))
+ (car (graph-maximum-flow
+ graph
+ ;; source
+ (find-if (lambda (a) (eq? (vertex-label a) 'a)) (graph-vertices graph))
+ ;; sink
+ (find-if (lambda (a) (eq? (vertex-label a) 'g)) (graph-vertices graph))
+ ;; capacity
+ edge-label)))))
+
+(define (graph-laplacian-matrix-example)
+ ;; #(#(2 -1 -1 0 0 0)
+ ;; #(-1 3 -1 0 -1 0)
+ ;; #(-1 -1 3 -1 0 0)
+ ;; #(0 0 -1 2 -1 0)
+ ;; #(0 -1 0 -1 3 -1)
+ ;; #(0 0 0 0 -1 1))
+ (pp (let ((graph
+ (digraph->graph
+ (alist->digraph
+ ;; http://en.wikipedia.org/wiki/File:6n-graf.svg
+ '((1 2) (1 5)
+ (5 4) (5 2) (2 3)
+ (3 4) (4 6))))))
+ (graph-laplacian-matrix graph))))
+
+(define (graph-complement-example)
+ (show-graph (graph-complement
+ (alist->digraph
+ '((a b)
+ (b c) (b e) (b f)
+ (c d) (c g)
+ (d c) (d h)
+ (e a) (e f)
+ (f g)
+ (g f)
+ (h g) (h d))))))
+
+(define (graph-clique-example)
+ (list
+ (let ((graph
+ (digraph->graph
+ (alist->digraph
+ ;; http://en.wikipedia.org/wiki/File:6n-graf.svg
+ '((1 2) (1 5)
+ (5 4) (5 2) (2 3)
+ (3 4) (4 6))))))
+ ;; ((6 4) (4 3) (3 2) (4 5) (2 5 1))
+ (map (lambda (l) (map vertex-label l)) (graph-maximal-cliques graph)))
+ (let ((graph
+ (digraph->graph
+ (alist->digraph
+ '((1 2) (1 5)
+ (5 4) (5 2) (2 3)
+ (3 4) (4 6) (5 3) (2 4))))))
+ ;; ((6 4) (2 4 3 5) (2 5 1))
+ (map (lambda (l) (map vertex-label l)) (graph-maximal-cliques graph)))))
View
5 graph.meta
@@ -8,9 +8,9 @@
(doc-from-wiki)
(synopsis "A library of graph algorithms")
(depends
- (setup-helper "1.5.2")
+ setup-helper
(define-structure "1.0")
- (traversal "1.0")
+ (traversal "1.1")
(object-graph "1.2")
(nondeterminism "1.0")
(miscmacros "2.95")
@@ -20,5 +20,6 @@
(files "graph.meta"
"graph.release-info"
"graph.scm"
+ "examples/graph-overview.scm"
"test/graph.scm"
"graph.setup"))
View
296 graph.scm
@@ -33,23 +33,11 @@
(system (format #f "dot -Tpng ~a > ~a" dot-file png-file))
(system (format #f "feh --force-aliasing ~a" png-file)))))))
-;; http://en.wikipedia.org/wiki/Karger%27s_algorithm
-;; http://en.wikipedia.org/wiki/Book:Graph_Algorithms
-;; http://en.wikipedia.org/wiki/Book:Graph_Algorithms
-
;; edges are directed as far as this is concerned
(define-structure vertex label edges)
(define-structure edge label out in)
(define-structure graph vertices edges)
-;; http://en.wikipedia.org/wiki/Graph_algorithms#Graph_algorithms
-
-;;; what I want:
-;; alist->graph vs alist->digraph
-;; (mst digraph edge->weight) and (mst graph edge->weight)
-;; should be extensible
-;; different kind of representations: adjacency list, interleaved, dense and sparse matrix
-
(define-record-printer
(edge obj port)
(display (list (edge-label obj) (vertex-label (edge-out obj)) (vertex-label (edge-in obj))) port))
@@ -58,6 +46,15 @@
(graph obj port)
(pp (graph->alist obj) port))
+(define (for-each-vertex f graph) (for-each f (graph-vertices graph)))
+(define (for-each-indexed-vertex f graph) (for-each-indexed f (graph-vertices graph)))
+(define (map-vertex f graph) (map f (graph-vertices graph)))
+(define (map-indexed-vertex f graph) (map-indexed f (graph-vertices graph)))
+(define (for-each-edge f graph) (for-each f (graph-edges graph)))
+(define (for-each-indexed-edge f graph) (for-each-indexed f (graph-edges graph)))
+(define (map-edge f graph) (map f (graph-edges graph)))
+(define (map-indexed-edge f graph) (map-indexed f (graph-edges graph)))
+
(define (vertex-out-edges v) (remove-if-not (lambda (e) (eq? (edge-out e) v)) (vertex-edges v)))
(define (vertex-in-edges v) (remove-if-not (lambda (e) (eq? (edge-in e) v)) (vertex-edges v)))
(define (vertex-add-edge! v e) (set-vertex-edges! v (cons e (vertex-edges v))))
@@ -69,11 +66,12 @@
(define (vertex-incoming-edges? v) (not (null? (vertex-in-edges v))))
(define (copy-vertex v) (make-vertex (vertex-label v) (vertex-edges v)))
(define (copy-edge v) (make-edge (edge-label v) (edge-out v) (edge-in v)))
+(define (vertex-neighbours v) (map edge-in (vertex-out-edges v)))
(define (alist->digraph alist)
(let*
((vertices
- (map (lambda (label) (make-vertex label '())) (remove-duplicates
+ (map (lambda (label) (make-vertex label '())) (remove-duplicatese
(append (map first alist) (map second alist)))))
(edges (map (lambda (l)
(add-edge! (make-edge (if (> (length l) 2) (third l) #f)
@@ -122,20 +120,8 @@
(remove-if (lambda (e) (eq? (edge-in e) vertex)) edges))
(cons edge mst)))))))
-;; should be 39
-;; (mst
-;; (digraph->graph
-;; (alist->digraph
-;; '((a d 5) (a b 7)
-;; (b c 8) (b e 7) (b d 9)
-;; (c e 5)
-;; (d e 15) (d f 6)
-;; (e g 9) (e f 8)
-;; (g f 11))))
-;; edge-label)
-
(define (topological-sort-from-node graph nodes)
- ;; TODO This modifies nodes!!
+ ;; TODO This modifies nodes
;; node must have no incoming arcs
(let ((graph (copy-graph graph)))
(let loop ((s nodes) (l '()))
@@ -151,11 +137,6 @@
graph
(remove vertex-incoming-edges? (graph-vertices graph))))
-;; (topological-sort
-;; (alist->digraph
-;; '((7 11 #f) (7 8 #f) (5 11 #f) (3 8 #f) (3 10 #f)
-;; (11 2 #f) (11 9 #f) (11 10 #f) (8 9 #f))))
-
(define (tsp-f graph edge->weight zero cmp)
;; TODO must have positive weights
(let ((best-solution #f)
@@ -176,37 +157,13 @@
(loop (removeq (edge-out e) vertices)
(+ (edge->weight e) cost)
(cons (edge-out e) tour))))))
- (list best-solution best-cost)))
+ (cons best-solution best-cost)))
(define (tsp graph edge->weight) (tsp-f graph edge->weight +inf.0 >=))
(define (tsp-partial graph edge->weight best) (tsp-f graph edge->weight best >=))
(define (max-tsp graph edge->weight) (tsp-f graph edge->weight 0 <))
(define (max-tsp-partial graph edge->weight best) (tsp-f graph edge->weight best <))
-;; ;; 14
-;; (map vertex-label
-;; (car
-;; (tsp
-;; (digraph->graph
-;; (alist->digraph
-;; '((a b 2) (a e 2) (a d 1) (a f 2)
-;; (b c 4) (b d 5) (b e 1)
-;; (c e 2) (c f 3) (d e 4) (e f 2))))
-;; edge-label)))
-
-;; ;; 54
-;; (map vertex-label
-;; (car
-;; (tsp
-;; (digraph->graph
-;; (alist->digraph
-;; '((a b 10) (a c 15) (a s 10) (a e 14) (a m 11)
-;; (b m 15) (b s 9) (b e 13) (b c 8)
-;; (c s 10) (c m 16) (c e 11)
-;; (e s 6) (e m 9)
-;; (s m 15))))
-;; edge-label)))
-
(define (dijkstras-algorithm graph node edge->weight)
(let ((distances (alist->hash-table (map (lambda (v) (cons v +inf.0)) (graph-vertices graph)))))
(hash-table-set! distances node 0)
@@ -283,38 +240,46 @@
)))
-(define (for-each-dfs f root graph)
- (let loop ((explored '()) (unexplored (list root)))
+(define (for-each-b/d-fs f root graph bfs? #!key (duplicate-nodes? #t))
+ ;; default is dfs
+ ;; f :: new -> parent -> r; parent is #f for the root
+ ;; duplicate-nodes? never calls f with a node twice
+ ;; useful in undirected graphs
+ (let loop ((explored '()) (unexplored (list (cons root #f))))
(unless (null? unexplored)
- (let ((v (car unexplored)))
- (f v)
- (loop (cons v explored)
- (remove-duplicates
- (append
- (remove-if (lambda (a) (memq a explored))
- (map edge-in (vertex-out-edges v)))
- (cdr unexplored))))))))
-
-(define (for-each-bfs f root graph)
- (let loop ((explored '()) (unexplored (list root)))
- (unless (null? unexplored)
- (let ((v (car unexplored)))
- (f v)
- (loop (cons v explored)
- (remove-duplicates
- (append
- (cdr unexplored)
- (remove-if (lambda (a) (memq a explored))
- (map edge-in (vertex-out-edges v))))))))))
-
-(define (fold-dfs f i root graph)
+ (display (map vertex-label explored))(newline)
+ (display (map vertex-label (map car unexplored)))(newline)
+ (let* ((p (car unexplored)))
+ (f (car p) (cdr p))
+ (loop (cons (car p) explored)
+ (let* ((new (map (lambda (e) (cons (edge-in e) (car p)))
+ (vertex-out-edges (car p))))
+ (new (if duplicate-nodes?
+ new
+ (remove (lambda (a) (memq (car a) explored)) new)))
+ (merged (if bfs?
+ (append (cdr unexplored) new)
+ (append new (cdr unexplored)))))
+ (if duplicate-nodes?
+ merged
+ (remove-duplicates (lambda (a b) (eq? (car a) (car b))) merged))))))))
+
+(define (for-each-bfs f root graph #!rest args)
+ (apply for-each-b/d-fs f root graph #t args))
+
+(define (for-each-dfs f root graph #!rest args)
+ (apply for-each-b/d-fs f root graph #f args))
+
+(define (fold-dfs f i root graph #!rest args)
(let ((l i))
- (for-each-dfs (lambda (vertex) (set! l (f i vertex))) root graph)
+ (apply for-each-dfs (lambda (vertex) (set! l (f i vertex)))
+ root graph args)
l))
-(define (fold-bfs f i root graph)
+(define (fold-bfs f i root graph #!rest args)
(let ((l i))
- (for-each-bfs (lambda (vertex) (set! l (f i vertex))) root graph)
+ (apply for-each-bfs (lambda (vertex) (set! l (f i vertex)))
+ root graph args)
l))
;; http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
@@ -347,20 +312,6 @@
(graph-vertices graph))
components))
-;; http://en.wikipedia.org/wiki/File:Scc.png
-;; ((a b e) (c d h) (f g))
-;; (pp (map (lambda (scc) (map vertex-label scc))
-;; (let ((graph (alist->digraph
-;; '((a b)
-;; (b c) (b e) (b f)
-;; (c d) (c g)
-;; (d c) (d h)
-;; (e a) (e f)
-;; (f g)
-;; (g f)
-;; (h g) (h d)))))
-;; (strongly-connected-components graph))))
-
(define (number-vertices graph)
(for-each-indexed
(lambda (vertex n) (setp-vertex-label! vertex (lambda (l) (cons n l))))
@@ -373,7 +324,32 @@
graph)
graph)
-(define (show-graph graph #!key (edge->label #f) (vertex->label #f))
+(define (contract-edge-between! graph v1 v2)
+ (let ((v (make-vertex (gensym) '()))
+ (edges (remove-duplicatesq
+ (append (vertex-edges v1) (vertex-edges v2)))))
+ (for-each (lambda (e)
+ (delete-edge! e)
+ (set-graph-edges! graph (removeq e (graph-edges graph))))
+ edges)
+ (set-graph-vertices! graph (cons v (removeq v1 (removeq v2 (graph-vertices graph)))))
+ (for-each (lambda (e)
+ (let ((out (if (or (eq? (edge-out e) v1)
+ (eq? (edge-out e) v2))
+ v
+ (edge-out e)))
+ (in (if (or (eq? (edge-in e) v1)
+ (eq? (edge-in e) v2))
+ v
+ (edge-in e))))
+ (unless (or (eq? in out) (edge-between? out in))
+ (let ((new-edge (make-edge (edge-label e) out in)))
+ (add-edge! new-edge)
+ (set-graph-edges! graph (cons new-edge (graph-edges graph)))))))
+ edges)
+ v))
+
+(define (show-graph graph #!key (edge->label #f) (vertex->label #t))
(reset-graph)
(for-each (lambda (edge)
(let* ((n1 (register-node1 (edge-out edge)))
@@ -382,8 +358,8 @@
(when edge->label
(set-label e
(if (procedure? edge->label)
- (edge->label e)
- (format #f "~a" (edge-label e)))))))
+ (edge->label edge)
+ (format #f "~a" (edge-label edge)))))))
(graph-edges graph))
(when vertex->label
(for-each (lambda (vertex)
@@ -394,16 +370,112 @@
(graph-vertices graph)))
(show-object-graph/dot))
-;; ;; http://en.wikipedia.org/wiki/File:Scc.png
-;; (show-graph
-;; (alist->digraph
-;; '((a b)
-;; (b c) (b e) (b f)
-;; (c d) (c g)
-;; (d c) (d h)
-;; (e a) (e f)
-;; (f g)
-;; (g f)
-;; (h g) (h d)))
-;; vertex->label: #t)
+(define (graph-maximum-flow graph source sink edge->capacity)
+ ;; push-relabel algorithm without the gap heuristic
+ ;; doesn't take advantage of sparsity
+ ;; need to get rid of all list-refs
+ (let ((edge->capacity (lambda (e) (if e (edge->capacity e) 0)))
+ (n (length (graph-vertices graph)))
+ (flow (ht)) (height (ht)) (excess (ht)) (seen (ht))
+ (nodes (removeq source (removeq sink (graph-vertices graph)))))
+ (for-each (lambda (u)
+ (! excess u 0)
+ (! height u 0)
+ (! seen u 0)
+ (for-each (lambda (v) (! flow (cons u v) 0)) (graph-vertices graph)))
+ (graph-vertices graph))
+ (define (push u v)
+ (let* ((send (min (@ excess u) (- (edge->capacity (edge-between? u v)) (@ flow (cons u v))))))
+ (! flow (cons u v) (+ (@ flow (cons u v)) send))
+ (! flow (cons v u) (- (@ flow (cons v u)) send))
+ (! excess u (- (@ excess u) send))
+ (! excess v (+ (@ excess v) send))))
+ (define (relabel u)
+ (let ((min-height +inf.0))
+ (for-each (lambda (v)
+ (when (> (- (edge->capacity (edge-between? u v)) (@ flow (cons u v))) 0)
+ (set! min-height (min min-height (@ height v)))
+ (! height u (+ min-height 1))))
+ (graph-vertices graph))))
+ (define (discharge u)
+ (let loop ()
+ (when (> (@ excess u) 0)
+ (if (< (@ seen u) n)
+ (let* ((v (list-ref (graph-vertices graph) (@ seen u))))
+ (if (and (> (- (edge->capacity (edge-between? u v)) (@ flow (cons u v))) 0)
+ (> (@ height u) (@ height v)))
+ (push u v)
+ (! seen u (+ (@ seen u) 1))))
+ (begin (relabel u)
+ (! seen u 0)))
+ (loop))))
+ (! height source n)
+ (! excess source +inf.0)
+ (for-each (lambda (v) (push source v)) (graph-vertices graph))
+ (let loop ((p 0))
+ (when (< p (length nodes))
+ (let* ((u (list-ref nodes p))
+ (old-height (@ height u)))
+ (discharge u)
+ (if (> (@ height u) old-height)
+ (begin (set! nodes (cons u (list-remove nodes p)))
+ (loop 0))
+ (loop (+ p 1))))))
+ (cons
+ (let ((sum 0))
+ (hash-table-walk flow (lambda (key val) (when (eq? (car key) source)
+ (set! sum (+ sum val)))))
+ sum)
+ (hash-table->alist flow))))
+
+(define (graph-laplacian-matrix graph #!key (in-degree? #f))
+ ;; out degree is the default
+ ;; prevents a linear-algebra dependency, for now anyway
+ (define (map-n-matrix f i j)
+ (map-n-vector (lambda (i) (map-n-vector (lambda (j) (f i j)) j)) i))
+ (let ((vertices (graph-vertices graph))
+ (vertex-edges (if in-degree?
+ vertex-in-edges
+ vertex-out-edges)))
+ (map-n-matrix
+ (lambda (i j)
+ (cond ((= i j) (length (vertex-edges (list-ref vertices i))))
+ ((adjacent-vertices? (list-ref vertices i) (list-ref vertices j)) -1)
+ (else 0)))
+ (length vertices)
+ (length vertices))))
+
+(define (graph-complement graph #!key (vertices->edge-label #f) (simple-graph? #f))
+ (let ((vertices (map-vertex (lambda (v) (make-vertex (vertex-label v) '())) graph))
+ (edges '()))
+ (for-each
+ (lambda (v-new1 v-old1)
+ (for-each
+ (lambda (v-new2 v-old2)
+ (when (or (not (eq? v-old1 v-old2)) (not simple-graph?))
+ (unless (adjacent-vertices? v-old1 v-old2)
+ (let ((e (make-edge (if vertices->edge-label
+ (vertices->edge-label v-old1 v-old2)
+ #f)
+ v-new1 v-new2)))
+ (add-edge! e)
+ (push! e edges)))))
+ vertices (graph-vertices graph)))
+ vertices (graph-vertices graph))
+ (make-graph vertices edges)))
+
+(define (graph-maximal-cliques graph)
+ ;; Bron-Kerbosch, without pivoting or vertex ordering
+ (let ((max-cliques '()))
+ (let loop ((r '()) (p (graph-vertices graph)) (x '()))
+ (if (and (null? p) (null? x))
+ (push! r max-cliques)
+ (for-each (lambda (v)
+ (loop (cons v r)
+ (intersectionq (vertex-neighbours v) p)
+ (intersectionq (vertex-neighbours v) x))
+ (push! v x)
+ (set! p (removeq v p)))
+ p)))
+ max-cliques))
)
View
2  graph.setup
@@ -4,6 +4,6 @@
(verify-extension-name "graph")
-(setup-shared-extension-module 'graph (extension-version "1.0")
+(setup-shared-extension-module 'graph (extension-version "1.1")
#:inline? #t #:types? #t
#:compile-options '(-O3 -d2))

No commit comments for this range

Something went wrong with that request. Please try again.