Pull down Graph from dn-m/NotationModel/SpelledPitch (#173)

Author: jsbean

.travis.yml

@@ -4,11 +4,11 @@ os:
 language: generic
 sudo: required
 dist: trusty
-osx_image: xcode9
+osx_image: xcode10
 install:
   - eval "$(curl -sL https://swiftenv.fuller.li/install.sh)"
 env:
-  - SWIFT_VERSION=DEVELOPMENT-SNAPSHOT-2018-05-30-a
+  - SWIFT_VERSION=4.2
 script:
   - swift package update
   - swift test

Sources/DataStructures/Graph/DirectedGraph.swift

@@ -0,0 +1,60 @@
+//
+//  DirectedGraph.swift
+//  DataStructures
+//
+//  Created by James Bean on 9/27/18.
+//
+
+/// Unweighted, directed graph.
+public struct DirectedGraph <Node: Hashable>: UnweightedGraphProtocol, DirectedGraphProtocol {
+
+    // MARK: - Instance Properties
+
+    /// All of the nodes contained herein.
+    ///
+    /// A `Node` is any `Hashable`-conforming value.
+    public var nodes: Set<Node>
+
+    /// All of the edges contained herein.
+    ///
+    /// An `Edge` is an `OrderedPair` of `Node` values.
+    public var edges: Set<Edge>
+}
+
+extension DirectedGraph {
+
+    // MARK: - Type Aliases
+
+    /// The type of edges which connect nodes.
+    public typealias Edge = OrderedPair<Node>
+}
+
+extension DirectedGraph {
+
+    // MARK: - Initializers
+
+    /// Creates a `DirectedGraph` with the given set of nodes, with no edges between the nodes.
+    @inlinable
+    public init(_ nodes: Set<Node> = []) {
+        self.nodes = nodes
+        self.edges = []
+    }
+
+    /// Creates a `DirectedGraph` with the given set of nodes and the given set of edges connecting the
+    /// nodes.
+    @inlinable
+    public init(_ nodes: Set<Node> = [], _ edges: Set<Edge> = []) {
+        self.init(nodes)
+        self.edges = edges
+    }
+
+    /// Creates a `DirectedGraph` which is composed a path of nodes.
+    @inlinable
+    public init <C> (path: C) where C: Collection, C.Element == Node {
+        self.nodes = Set(path)
+        self.edges = Set(nodes.pairs.map(OrderedPair.init))
+    }
+}
+
+extension DirectedGraph: Equatable { }
+extension DirectedGraph: Hashable { }

Sources/DataStructures/Graph/Graph.swift

@@ -0,0 +1,53 @@
+//
+//  Graph.swift
+//  DataStructures
+//
+//  Created by James Bean on 9/27/18.
+//
+
+/// Unweighted, undirected graph.
+public struct Graph <Node: Hashable>: UnweightedGraphProtocol, UndirectedGraphProtocol {
+
+    // MARK: - Instance Properties
+
+    /// All of the nodes contained herein.
+    ///
+    /// A `Node` is any `Hashable`-conforming value.
+    public var nodes: Set<Node>
+
+    /// All of the edges contained herein.
+    ///
+    /// An `Edge` is an `UnorderedPair` of `Node` values.
+    public var edges: Set<Edge>
+}
+
+extension Graph {
+
+    // MARK: - Type Aliases
+
+    /// The type of edges which connect nodes.
+    public typealias Edge = UnorderedPair<Node>
+}
+
+extension Graph {
+
+    // MARK: - Initializers
+
+    /// Creates a `Graph` with the given set of nodes, with no edges between the nodes.
+    @inlinable
+    public init(_ nodes: Set<Node> = []) {
+        self.nodes = nodes
+        self.edges = []
+    }
+
+    /// Creates a `Graph` with the given set of nodes and the given set of edges connecting the
+    /// nodes.
+    @inlinable
+    public init(_ nodes: Set<Node> = [], _ edges: Set<Edge> = []) {
+        self.init(nodes)
+        self.edges = edges
+    }
+}
+
+extension Graph: Equatable { }
+extension Graph: Hashable { }

Sources/DataStructures/Graph/Protocols/DirectedGraphProtocol.swift

@@ -0,0 +1,9 @@
+//
+//  DirectedGraphProtocol.swift
+//  DataStructures
+//
+//  Created by James Bean on 9/27/18.
+//
+
+/// Interface for directed graphs.
+public protocol DirectedGraphProtocol: GraphProtocol where Edge == OrderedPair<Node> { }

Sources/DataStructures/Graph/Protocols/GraphProtocol.swift

@@ -0,0 +1,138 @@
+//
+//  GraphProtocol.swift
+//  DataStructures
+//
+//  Created by James Bean on 9/27/18.
+//
+
+/// Interface for graph-like tyes.
+public protocol GraphProtocol {
+
+    // MARK: - Associated Types
+
+    /// The type of nodes contained herein.
+    associatedtype Node: Hashable
+
+    /// The type of edges contained herein.
+    associatedtype Edge: SymmetricPair & Hashable where Edge.A == Node
+
+    // MARK: - Instance Properties
+
+    /// All of the nodes contained herein.
+    var nodes: Set<Node> { get set }
+
+    /// All of the edges contained herein.
+    var edges: Set<Edge> { get }
+
+    // MARK: - Initializers
+
+    /// Creates a `GraphProtocol`-conforming type value with the given set of `nodes`.
+    init(_ nodes: Set<Node>)
+
+    // MARK: - Instance Methods
+
+    /// Removes the edge from the given `source` to the given `destination`.
+    mutating func removeEdge(from source: Node, to destination: Node)
+}
+
+extension GraphProtocol {
+
+    /// Inserts the given `node` without making any connections to other nodes contained herein.
+    @inlinable
+    public mutating func insert(_ node: Node) {
+        nodes.insert(node)
+    }
+
+    /// - Returns: `true` if the `GraphProtocol`-conforming type value contains the given `node`.
+    /// Otherwise, `false`.
+    @inlinable
+    public func contains(_ node: Node) -> Bool {
+        return nodes.contains(node)
+    }
+    
+    /// - Returns: `true` if this graph contains an edge between given `source` and `destination`.
+    /// Otherwise, `false`.
+    @inlinable
+    public func containsEdge(from source: Node, to destination: Node) -> Bool {
+        return contains(Edge(source,destination))
+    }
+    
+    /// Returns: `true` if the `GraphProtocol`-conforming type value contains the given `edge`.
+    /// Otherwise, `false`.
+    @inlinable
+    public func contains(_ edge: Edge) -> Bool {
+        return edges.contains(edge)
+    }
+
+    /// - Returns: A set of nodes connected to the given `source`, in the given set of
+    /// `nodes`.
+    ///
+    /// If `nodes` is empty, then any nodes contained herein are able to be included in the
+    /// resultant set.
+    @inlinable
+    public func neighbors(of source: Node, in nodes: Set<Node>? = nil) -> Set<Node> {
+        return (nodes ?? self.nodes).filter { edges.contains(Edge(source,$0)) }
+    }
+    
+    /// - Returns: A set of edges outgoing from the given `source`.
+    @inlinable
+    public func edges(from source: Node) -> Set<Edge> {
+        return Set(neighbors(of: source).map { Edge(source, $0) })
+    }
+    
+    /// - Returns: A set of edges incident to the given `destination`.
+    @inlinable
+    public func edges(to destination: Node) -> Set<Edge> {
+        return Set(nodes.lazy.map { Edge($0, destination) }.filter(edges.contains))
+    }
+
+    /// - Returns: An array of `Node` values in breadth first order.
+    @inlinable
+    public func breadthFirstSearch(from source: Node, to destination: Node? = nil) -> [Node] {
+        var visited: [Node] = []
+        var queue = Queue<Node>()
+        queue.enqueue(source)
+        visited.append(source)
+        while !queue.isEmpty {
+            let node = queue.dequeue()
+            for neighbor in neighbors(of: node) where !visited.contains(neighbor) {
+                queue.enqueue(neighbor)
+                visited.append(neighbor)
+                if neighbor == destination { return visited }
+            }
+        }
+        return visited
+    }
+
+    /// - Returns: An array of `Node` values from the given `source` to the given `destination`.
+    ///
+    /// In the case that there are more than one paths from the given `source` to the given
+    /// `destination`, the path with the fewest edges is returned.
+    @inlinable
+    public func shortestUnweightedPath(from source: Node, to destination: Node) -> [Node]? {
+        var breadcrumbs: [Node: Node] = [:]
+        func backtrace() -> [Node] {
+            var path = [destination]
+            var cursor = destination
+            while cursor != source {
+                path.insert(breadcrumbs[cursor]!, at: 0)
+                cursor = breadcrumbs[cursor]!
+            }
+            return path
+        }
+        if source == destination { return .init([source]) }
+        var unvisited = nodes
+        var queue = Queue<Node>()
+        queue.enqueue(source)
+        while !queue.isEmpty {
+            let node = queue.dequeue()
+            for neighbor in neighbors(of: node, in: unvisited) {
+                queue.enqueue(neighbor)
+                unvisited.remove(neighbor)
+                breadcrumbs[neighbor] = node
+                if neighbor == destination { return backtrace() }
+            }
+        }
+        return nil
+    }
+}

Sources/DataStructures/Graph/Protocols/UndirectedGraphProtocol.swift

@@ -0,0 +1,9 @@
+//
+//  UndirectedGraphProtocol.swift
+//  DataStructures
+//
+//  Created by James Bean on 9/27/18.
+//
+
+/// Interface for undirected graphs.
+public protocol UndirectedGraphProtocol: GraphProtocol where Edge == UnorderedPair<Node> { }

Sources/DataStructures/Graph/Protocols/UnweightedGraphProtocol.swift

@@ -0,0 +1,61 @@
+//
+//  UnweightedGraphProtocol.swift
+//  DataStructures
+//
+//  Created by James Bean on 9/27/18.
+//
+
+/// Interface for unweighted graphs.
+public protocol UnweightedGraphProtocol: GraphProtocol {
+
+    // MARK: - Instance Properties
+
+    /// All of the edges contained herein.
+    var edges: Set<Edge> { get set }
+
+    // MARK: - Initializers
+
+    /// Creates an `UnweightedGraphProtocol`-conforming type value with the given set of `nodes`
+    /// and the given set of `edges`.
+    init(_ nodes: Set<Node>, _ edges: Set<Edge>)
+}
+
+extension UnweightedGraphProtocol {
+
+    /// Creates an `UnweightedGraphProtocol`-conforming type value which is composed a path of
+    /// nodes.
+    @inlinable
+    public init <S> (path: S) where S: Sequence, S.Element == Node {
+        self.init(Set(path), Set(path.pairs.map(Edge.init)))
+    }
+}
+
+extension UnweightedGraphProtocol {
+
+    // MARK: - Modifying
+
+    /// Inserts an edge between the given `source` and `destination` nodes.
+    ///
+    /// If the `source` or `destination` nodes are not yet contained herein, they are inserted.
+    @inlinable
+    public mutating func insertEdge(from source: Node, to destination: Node) {
+        insert(source)
+        insert(destination)
+        edges.insert(Edge(source,destination))
+    }
+
+    /// Removes the edge between the given `source` and `destination` nodes.
+    @inlinable
+    public mutating func removeEdge(from source: Node, to destination: Node) {
+        edges.remove(Edge(source,destination))
+    }
+}
+
+extension UnweightedGraphProtocol {
+
+    /// - Returns: A new graph with the union of the nodes and edges of the two given graphs.
+    @inlinable
+    public static func + (lhs: Self, rhs: Self) -> Self {
+        return .init(lhs.nodes.union(rhs.nodes), lhs.edges.union(rhs.edges))
+    }
+}