Merge pull request #5 from adamnemecek/master

Refactoring a lot of things

Author: DanielDahan

Sources/Algorithm+Array.swift

@@ -75,6 +75,7 @@ extension Array where Element: Equatable {
      - Returns: An Int.
      */
     public func count(of elements: [Element]) -> Int {
+        
 		var c = 0
         for e in elements {
             for x in self where e == x {

Sources/Algorithm+Set.swift

@@ -34,7 +34,7 @@ extension Set: Probable {
      - Parameter of elements: A list of Elements.
      - Returns: An Int.
      */
-    public func count<Element: Equatable>(of elements: Element...) -> Int {
+    public func count(of elements: Element...) -> Int {
         return count(of: elements)
     }
 
@@ -43,7 +43,7 @@ extension Set: Probable {
      - Parameter of elements: An Array of Elements.
      - Returns: An Int.
      */
-    public func count<Element: Equatable>(of elements: [Element]) -> Int {
+    public func count(of elements: [Element]) -> Int {
         var c = 0
         for e in elements {
             for x in self {
@@ -60,7 +60,7 @@ extension Set: Probable {
      - Parameter of elements: A list of Elements.
      - Returns: A Double.
      */
-    public func probability<Element: Equatable>(of elements: Element...) -> Double {
+    public func probability(of elements: Element...) -> Double {
         return probability(of: elements)
     }
 
@@ -69,7 +69,7 @@ extension Set: Probable {
      - Parameter of elements: An Array of Elements.
      - Returns: A Double.
      */
-    public func probability<Element: Equatable>(of elements: [Element]) -> Double {
+    public func probability(of elements: [Element]) -> Double {
         return 0 < count ? Double(count(of: elements)) / Double(count) : 0
     }
 
@@ -99,7 +99,7 @@ extension Set: Probable {
      - Parameter elements: A list of Elements.
      - Returns: A Double.
      */
-    public func expectedValue<Element: Equatable>(trials: Int, for elements: Element...) -> Double {
+    public func expectedValue(trials: Int, for elements: Element...) -> Double {
         return expectedValue(trials: trials, for: elements)
     }
 
@@ -109,7 +109,7 @@ extension Set: Probable {
      - Parameter elements: An Array of Elements.
      - Returns: A Double.
      */
-    public func expectedValue<Element: Equatable>(trials: Int, for elements: [Element]) -> Double {
+    public func expectedValue(trials: Int, for elements: [Element]) -> Double {
         return Double(trials) * probability(of: elements)
     }
 }

Sources/Queue.swift

@@ -80,7 +80,7 @@ public struct Queue<Element>: CustomStringConvertible, Sequence {
 		:description:	Constructor.
 	*/
 	public init() {
-		list = DoublyLinkedList<Element>()
+		list = DoublyLinkedList()
 	}
 
 	//
@@ -89,7 +89,7 @@ public struct Queue<Element>: CustomStringConvertible, Sequence {
 	//	the next value in the sequence of nodes.
 	//	:returns:	Queue.Generator
 	//
-	public func makeIterator() -> Queue.Iterator {
+	public func makeIterator() -> Iterator {
 		return list.makeIterator()
 	}
 
@@ -118,21 +118,21 @@ public struct Queue<Element>: CustomStringConvertible, Sequence {
 	mutating public func removeAll() {
 		list.removeAll()
 	}
-}
 
-public func +<Element>(lhs: Queue<Element>, rhs: Queue<Element>) -> Queue<Element> {
-	var q = Queue<Element>()
-	for x in lhs {
-		q.enqueue(x)
-	}
-	for x in rhs {
-		q.enqueue(x)
-	}
-	return q
-}
+    public static func +(lhs: Queue, rhs: Queue) -> Queue<Element> {
+        var q = Queue<Element>()
+        for x in lhs {
+            q.enqueue(x)
+        }
+        for x in rhs {
+            q.enqueue(x)
+        }
+        return q
+    }
 
-public func +=<Element>(lhs: inout Queue<Element>, rhs: Queue<Element>) {
-	for x in rhs {
-		lhs.enqueue(x)
-	}
+    public static func +=(lhs: inout Queue, rhs: Queue) {
+        for x in rhs {
+            lhs.enqueue(x)
+        }
+    }
 }

Sources/RedBlackNode.swift

@@ -32,23 +32,23 @@ internal class RedBlackNode<Key: Comparable, Value>: Comparable, Equatable, Cust
 	/**
 		:name:	parent
 		:description:	A reference to the parent node of a given node.
-		- returns:	RedBlackNode<Key, Value>!
+		- returns:	RedBlackNode!
 	*/
-	internal var parent: RedBlackNode<Key, Value>!
+	internal var parent: RedBlackNode!
 
 	/**
 		:name:	left
 		:description:	A reference to the left child node of a given node.
-		- returns:	RedBlackNode<Key, Value>!
+		- returns:	RedBlackNode!
 	*/
-	internal var left: RedBlackNode<Key, Value>!
+	internal var left: RedBlackNode!
 
 	/**
 		:name:	right
 		:description:	A reference to the right child node of a given node.
-		- returns:	RedBlackNode<Key, Value>!
+		- returns:	RedBlackNode!
 	*/
-	internal var right: RedBlackNode<Key, Value>!
+	internal var right: RedBlackNode!
 
 	/**
 		:name:	isRed
@@ -102,7 +102,7 @@ internal class RedBlackNode<Key: Comparable, Value>: Comparable, Equatable, Cust
 		:name:	init
 		:description:	Constructor used for nodes that store data.
 	*/
-	internal init(parent: RedBlackNode<Key, Value>, sentinel: RedBlackNode<Key, Value>, key: Key, value: Value?) {
+	internal init(parent: RedBlackNode, sentinel: RedBlackNode, key: Key, value: Value?) {
 		self.key = key
 		self.value = value
 		self.parent = parent
@@ -111,24 +111,14 @@ internal class RedBlackNode<Key: Comparable, Value>: Comparable, Equatable, Cust
 		isRed = true
 		order = 1
 	}
+    
+    static func ==(lhs: RedBlackNode, rhs: RedBlackNode) -> Bool {
+        return lhs.key == rhs.key
+    }
+    
+    static func <(lhs: RedBlackNode, rhs: RedBlackNode) -> Bool {
+        return lhs.key < rhs.key
+    }
 }
 
-func ==<Key : Comparable, Value>(lhs: RedBlackNode<Key, Value>, rhs: RedBlackNode<Key, Value>) -> Bool {
-	return lhs.key == rhs.key
-}
-
-func <=<Key : Comparable, Value>(lhs: RedBlackNode<Key, Value>, rhs: RedBlackNode<Key, Value>) -> Bool {
-	return lhs.key <= rhs.key
-}
-
-func >=<Key : Comparable, Value>(lhs: RedBlackNode<Key, Value>, rhs: RedBlackNode<Key, Value>) -> Bool {
-	return lhs.key >= rhs.key
-}
-
-func ><Key : Comparable, Value>(lhs: RedBlackNode<Key, Value>, rhs: RedBlackNode<Key, Value>) -> Bool {
-	return lhs.key > rhs.key
-}
 
-func <<Key : Comparable, Value>(lhs: RedBlackNode<Key, Value>, rhs: RedBlackNode<Key, Value>) -> Bool {
-	return lhs.key < rhs.key
-}

Sources/RedBlackTree.swift

@@ -28,14 +28,18 @@
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-public struct RedBlackTree<Key: Comparable, Value>: Probable, Collection, CustomStringConvertible {
+public struct RedBlackTree<Key: Comparable, Value>: Probable, Collection, BidirectionalCollection, CustomStringConvertible {
     /// Returns the position immediately after the given index.
     ///
     /// - Parameter i: A valid index of the collection. `i` must be less than
     ///   `endIndex`.
     /// - Returns: The index value immediately after `i`.
     public func index(after i: Int) -> Int {
-        return i < endIndex ? i + 1 : 0
+        return i + 1
+    }
+
+    public func index(before i: Int) -> Int {
+        return i - 1
     }
 
 	public typealias Iterator = AnyIterator<(key: Key, value: Value?)>
@@ -78,37 +82,6 @@ public struct RedBlackTree<Key: Comparable, Value>: Probable, Collection, Custom
         return "[" + map { "\($0)" }.joined(separator: ", ") + "]"
 	}
 
-	/**
-		:name:	first
-		:description:	Get the first node value in the tree, this is
-		the first node based on the order of keys where
-		k1 <= k2 <= Key3 ... <= Keyn
-		- returns:	(key: Key, value: Value?)?
-	*/
-	public var first: (key: Key, value: Value?)? {
-		return isEmpty ? nil : self[0]
-	}
-
-	/**
-		:name:	last
-		:description:	Get the last node value in the tree, this is
-		the last node based on the order of keys where
-		k1 <= k2 <= Key3 ... <= Keyn
-		- returns:	(key: Key, value: Value?)?
-	*/
-	public var last: (key: Key, value: Value?)? {
-		return isEmpty ? nil : self[count - 1]
-	}
-
-	/**
-		:name:	isEmpty
-		:description:	A boolean of whether the RedBlackTree is empty.
-		- returns:	Bool
-	*/
-	public var isEmpty: Bool {
-		return 0 == count
-	}
-
 	/**
 		:name:	startIndex
 		:description:	Conforms to the Collection Protocol.
@@ -752,52 +725,43 @@ public struct RedBlackTree<Key: Comparable, Value>: Probable, Collection, Custom
 	private func validateOrder(_ order: Int) {
 		assert(order > startIndex || order <= endIndex, "[Algorithm Error: Order out of bounds.]")
 	}
-}
-
-public func ==<Key : Comparable, Value>(lhs: RedBlackTree<Key, Value>, rhs: RedBlackTree<Key, Value>) -> Bool {
-    guard lhs.count == rhs.count else {
-		return false
-	}
 
-	for i in 0..<lhs.count {
-		if lhs[i].key != rhs[i].key {
-			return false
-		}
-	}
-	return true
-}
-
-public func !=<Key : Comparable, Value>(lhs: RedBlackTree<Key, Value>, rhs: RedBlackTree<Key, Value>) -> Bool {
-	return !(lhs == rhs)
-}
-
-public func +<Key : Comparable, Value>(lhs: RedBlackTree<Key, Value>, rhs: RedBlackTree<Key, Value>) -> RedBlackTree<Key, Value> {
-	var t = RedBlackTree<Key, Value>()
-    for (k, v) in lhs {
-        t.insert(value: v, for: k)
+    public static func ==(lhs: RedBlackTree, rhs: RedBlackTree) -> Bool {
+        return lhs.count == rhs.count && lhs.elementsEqual(rhs) {
+            $0.0.key == $0.1.key
+        }
     }
-    for (k, v) in rhs {
-        t.insert(value: v, for: k)
-	}
-	return t
-}
 
-public func +=<Key : Comparable, Value>(lhs: inout RedBlackTree<Key, Value>, rhs: RedBlackTree<Key, Value>) {
-	for (k, v) in rhs {
-		lhs.insert(value: v, for: k)
-	}
+    public static func +(lhs: RedBlackTree, rhs: RedBlackTree) -> RedBlackTree<Key, Value> {
+        var t = RedBlackTree()
+        for (k, v) in lhs {
+            t.insert(value: v, for: k)
+        }
+        for (k, v) in rhs {
+            t.insert(value: v, for: k)
+        }
+        return t
+    }
+    
+    public static func +=(lhs: inout RedBlackTree, rhs: RedBlackTree) {
+        for (k, v) in rhs {
+            lhs.insert(value: v, for: k)
+        }
+    }
+    
+    public static func -(lhs: RedBlackTree, rhs: RedBlackTree) -> RedBlackTree {
+        var t = rhs
+        for (k, _) in rhs {
+            t.removeValue(for: k)
+        }
+        return t
+    }
+    
+    public static func -=(lhs: inout RedBlackTree, rhs: RedBlackTree) {
+        for (k, _) in rhs {
+            lhs.removeValue(for: k)
+        }
+    }
 }
 
-public func -<Key : Comparable, Value>(lhs: RedBlackTree<Key, Value>, rhs: RedBlackTree<Key, Value>) -> RedBlackTree<Key, Value> {
-	var t = rhs
-	for (k, _) in rhs {
-        t.removeValue(for: k)
-	}
-	return t
-}
 
-public func -=<Key : Comparable, Value>(lhs: inout RedBlackTree<Key, Value>, rhs: RedBlackTree<Key, Value>) {
-	for (k, _) in rhs {
-		lhs.removeValue(for: k)
-	}
-}