diff --git a/Sources/Classes/Full View/FullViewAnimation.swift b/Sources/Classes/Full View/FullViewAnimation.swift
index b003e16..b9565da 100644
--- a/Sources/Classes/Full View/FullViewAnimation.swift	
+++ b/Sources/Classes/Full View/FullViewAnimation.swift	
@@ -53,7 +53,7 @@ public extension Spruce {
     ///   - recursiveDepth: an int describing how deep into the view hiearchy the subview search should go, defaults to 0
     ///   - completion: a closure that is called upon the final animation completing. A `Bool` is passed into the closure letting you know if the animation has completed. **Note:** If you stop animations on the whole animating view, then `false` will be passed into the completion closure. However, if the final animation is allowed to proceed then `true` will be the value passed into the completion closure.
     public func animate(withSortFunction sortFunction: SortFunction, duration: StockTimingFunction, prepare: PrepareHandler? = nil, animation: Animation, exclude: [UIView]? = nil, recursiveDepth: Int = 0, completion: CompletionHandler? = nil) {
-        let weightedViews = sortFunction.weights(forView: self.view, recursiveDepth: recursiveDepth)
+        let weightedViews = sortFunction.weights(for: self.view, recursiveDepth: recursiveDepth)
         var timedViews = duration.timingFunction.timeOffsets(forViews: weightedViews)
         timedViews = timedViews.sorted { (left, right) -> Bool in
             return left.timeOffset < right.timeOffset
@@ -76,5 +76,8 @@ public extension Spruce {
                               view: animatedView,
                               completion: ((index == timedViews.count - 1) ? completion : nil))
         }
+        
+        let array = [1,2,3,4,5]
+        array.reversed()
     }
 }
diff --git a/Sources/Classes/Sort Functions/CorneredSortFunction.swift b/Sources/Classes/Sort Functions/CorneredSortFunction.swift
index 09d032e..865b6a5 100644
--- a/Sources/Classes/Sort Functions/CorneredSortFunction.swift	
+++ b/Sources/Classes/Sort Functions/CorneredSortFunction.swift	
@@ -36,21 +36,21 @@ public struct CorneredSortFunction: CornerSortFunction {
         self.corner = corner
     }
     
-    public func weights(forView view: UIView, recursiveDepth: Int) -> [WeightedView] {
-        let comparisonPoint = distancePoint(view: view)
+    public func weights(for view: UIView, recursiveDepth: Int) -> [WeightedView] {
         let subviews = view.spruce.subviews(withRecursiveDepth: recursiveDepth)
+        let comparisonPoint = distancePoint(view: view, subviews: subviews)
         
         var maxWeight: Double = 0.0
         
-        let weightedViews: [WeightedView] = subviews.map {
+        var weightedViews: [WeightedView] = subviews.map {
             let distance = Double(abs(comparisonPoint.x - $0.referencePoint.x) + abs(comparisonPoint.y - $0.referencePoint.y))
             maxWeight = max(maxWeight, distance)
             return WeightedView(spruceView: $0, weight: distance)
         }
         
         if reversed {
-            for var weightedView in weightedViews {
-                weightedView.weight = maxWeight - weightedView.weight
+            for index in 0..<weightedViews.count {
+                weightedViews[index].weight = maxWeight - weightedViews[index].weight
             }
         }
         
diff --git a/Sources/Classes/Sort Functions/DefaultSortFunction.swift b/Sources/Classes/Sort Functions/DefaultSortFunction.swift
index 7a305fd..c661d39 100644
--- a/Sources/Classes/Sort Functions/DefaultSortFunction.swift	
+++ b/Sources/Classes/Sort Functions/DefaultSortFunction.swift	
@@ -33,7 +33,7 @@ public struct DefaultSortFunction: SortFunction {
         
     }
     
-    public func weights(forView view: UIView, recursiveDepth: Int) -> [WeightedView] {
+    public func weights(for view: UIView, recursiveDepth: Int) -> [WeightedView] {
         let subviews = view.spruce.subviews(withRecursiveDepth: recursiveDepth)
         var currentWeight: Double = 0.0
         var weightedViews: [WeightedView] = []
diff --git a/Sources/Classes/Sort Functions/InlineSortFunction.swift b/Sources/Classes/Sort Functions/InlineSortFunction.swift
index 1ff716f..181c2d3 100644
--- a/Sources/Classes/Sort Functions/InlineSortFunction.swift	
+++ b/Sources/Classes/Sort Functions/InlineSortFunction.swift	
@@ -37,7 +37,7 @@ public struct InlineSortFunction: CornerSortFunction {
         self.corner = corner
     }
     
-    public func weights(forView view: UIView, recursiveDepth: Int) -> [WeightedView] {
+    public func weights(for view: UIView, recursiveDepth: Int) -> [WeightedView] {
         let comparisonPoint = distancePoint(view: view)
         let subviews = view.spruce.subviews(withRecursiveDepth: recursiveDepth)
 
diff --git a/Sources/Classes/Sort Functions/Protocols/DistanceSortFunction.swift b/Sources/Classes/Sort Functions/Protocols/DistanceSortFunction.swift
index acac3e6..7f132b6 100644
--- a/Sources/Classes/Sort Functions/Protocols/DistanceSortFunction.swift	
+++ b/Sources/Classes/Sort Functions/Protocols/DistanceSortFunction.swift	
@@ -66,21 +66,21 @@ public extension DistanceSortFunction {
     ///   - view: the view whose subviews should be animated. This view should not be included in the returned array
     ///   - recursiveDepth: an int describing how deep into the view hiearchy the subview search should go, defaults to 0. A value of 0 is the same as calling the `subviews` on the actual view itself. Therefore a depth of 1 will be getting the subviews of each of the subviews, etc...
     /// - Returns: an array of `WeightedView`'s which contain references to the view needed to be animated and the weight for the animation of that individual view relative to the overall animation
-    public func weights(forView view: UIView, recursiveDepth: Int) -> [WeightedView] {
+    public func weights(for view: UIView, recursiveDepth: Int) -> [WeightedView] {
         let subviews = view.spruce.subviews(withRecursiveDepth: recursiveDepth)
         let comparisonPoint = distancePoint(view: view, subviews: subviews)
         
         var maxWeight: Double = 0.0
         
-        let weightedViews: [WeightedView] = subviews.map {
+        var weightedViews: [WeightedView] = subviews.map {
             let distance = distanceBetween(comparisonPoint, and: $0.referencePoint)
             maxWeight = max(maxWeight, distance)
             return WeightedView(spruceView: $0, weight: distance)
         }
         
         if reversed {
-            for var weightedView in weightedViews {
-                weightedView.weight = maxWeight - weightedView.weight
+            for index in 0..<weightedViews.count {
+                weightedViews[index].weight = maxWeight - weightedViews[index].weight
             }
         }
         
diff --git a/Sources/Classes/Sort Functions/Protocols/SortFunction.swift b/Sources/Classes/Sort Functions/Protocols/SortFunction.swift
index 0658267..edb18c3 100644
--- a/Sources/Classes/Sort Functions/Protocols/SortFunction.swift	
+++ b/Sources/Classes/Sort Functions/Protocols/SortFunction.swift	
@@ -51,11 +51,11 @@ extension WeightedView: Equatable, Comparable {
 public protocol SortFunction {
     
     /// Given a view, view sort the subviews in a way that matches the desired specification of the `SortFunction`. In an example case, if you wanted a radial sort function then this method would return an array of the subviews such that their weights would be smaller near the center of the view and grow as they get further from the center point.
-    /// - Note: This method simply calls the `weights(forView view: UIView, recursiveDepth: Int)` with a `recursiveDepth` of `0`.
+    /// - Note: This method simply calls the `weights(for view: UIView, recursiveDepth: Int)` with a `recursiveDepth` of `0`.
     ///
     /// - Parameter view: the view whose subviews should be animated. This view should not be included in the returned array
     /// - Returns: an array of `WeightedView`'s which contain references to the view needed to be animated and the weight for the animation of that individual view relative to the overall animation
-    func weights(forView view: UIView) -> [WeightedView]
+    func weights(for view: UIView) -> [WeightedView]
     
     /// Given a view, view sort the subviews in a way that matches the desired specification of the `SortFunction`. In an example case, if you wanted a radial sort function then this method would return an array of the subviews such that their weights would be smaller near the center of the view and grow as they get further from the center point.
     ///
@@ -63,11 +63,11 @@ public protocol SortFunction {
     ///   - view: the view whose subviews should be animated. This view should not be included in the returned array
     ///   - recursiveDepth: an int describing how deep into the view hiearchy the subview search should go, defaults to 0. A value of 0 is the same as calling the `subviews` on the actual view itself. Therefore a depth of 1 will be getting the subviews of each of the subviews, etc...
     /// - Returns: an array of `WeightedView`'s which contain references to the view needed to be animated and the weight for the animation of that individual view relative to the overall animation
-    func weights(forView view: UIView, recursiveDepth: Int) -> [WeightedView]
+    func weights(for view: UIView, recursiveDepth: Int) -> [WeightedView]
 }
 
 public extension SortFunction {
-    func weights(forView view: UIView) -> [WeightedView] {
-        return weights(forView: view, recursiveDepth: 0)
+    func weights(for view: UIView) -> [WeightedView] {
+        return weights(for: view, recursiveDepth: 0)
     }
 }
diff --git a/Sources/Classes/Sort Functions/RandomSortFunction.swift b/Sources/Classes/Sort Functions/RandomSortFunction.swift
index 3d66e03..af1306a 100644
--- a/Sources/Classes/Sort Functions/RandomSortFunction.swift	
+++ b/Sources/Classes/Sort Functions/RandomSortFunction.swift	
@@ -33,7 +33,7 @@ public struct RandomSortFunction: SortFunction {
         
     }
     
-    public func weights(forView view: UIView, recursiveDepth: Int) -> [WeightedView] {
+    public func weights(for view: UIView, recursiveDepth: Int) -> [WeightedView] {
         var subviews = view.spruce.subviews(withRecursiveDepth: recursiveDepth)
         subviews.shuffle()
         
diff --git a/Sources/Classes/Sort Functions/WeightedSortFunction.swift b/Sources/Classes/Sort Functions/WeightedSortFunction.swift
index c8ff929..6d01e28 100644
--- a/Sources/Classes/Sort Functions/WeightedSortFunction.swift	
+++ b/Sources/Classes/Sort Functions/WeightedSortFunction.swift	
@@ -44,12 +44,12 @@ public struct WeightedSortFunction: PositionSortFunction, WeightSortFunction {
         self.position = position
     }
     
-    public func weights(forView view: UIView, recursiveDepth: Int) -> [WeightedView] {
+    public func weights(for view: UIView, recursiveDepth: Int) -> [WeightedView] {
         let subviews = view.spruce.subviews(withRecursiveDepth: recursiveDepth)
         let comparisonPoint = distancePoint(view: view, subviews: subviews)
         var maxWeight: Double = 0.0
         
-        let weightedViews: [WeightedView] = subviews.map {
+        var weightedViews: [WeightedView] = subviews.map {
             let horizontalDistance = comparisonPoint.spruce.horizontalDistance(to: $0.referencePoint) * horizontalWeight.coefficient
             let verticalDistance = comparisonPoint.spruce.verticalDistance(to: $0.referencePoint) * verticalWeight.coefficient
             let distance = horizontalDistance + verticalDistance
@@ -58,8 +58,8 @@ public struct WeightedSortFunction: PositionSortFunction, WeightSortFunction {
         }
         
         if reversed {
-            for var weightedView in weightedViews {
-                weightedView.weight = maxWeight - weightedView.weight
+            for index in 0..<weightedViews.count {
+                weightedViews[index].weight = maxWeight - weightedViews[index].weight
             }
         }
         
diff --git a/Spruce/Spruce.xcodeproj/project.pbxproj b/Spruce/Spruce.xcodeproj/project.pbxproj
index b3370ec..35341e9 100644
--- a/Spruce/Spruce.xcodeproj/project.pbxproj
+++ b/Spruce/Spruce.xcodeproj/project.pbxproj
@@ -44,7 +44,7 @@
 		DBFA708F1E5CBC44000CF1DB /* DefaultSortFunctionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DBFA708E1E5CBC44000CF1DB /* DefaultSortFunctionTests.swift */; };
 		DBFA70911E5CBF10000CF1DB /* LinearSortFunctionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DBFA70901E5CBF10000CF1DB /* LinearSortFunctionTests.swift */; };
 		DBFA70931E5CC052000CF1DB /* InlineSortFunctionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DBFA70921E5CC052000CF1DB /* InlineSortFunctionTests.swift */; };
-		DBFA709A1E5DEBE5000CF1DB /* ContinuousWeightedSortFunctionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DBFA70991E5DEBE5000CF1DB /* ContinuousWeightedSortFunctionTests.swift */; };
+		DBFA709A1E5DEBE5000CF1DB /* WeightedSortFunctionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DBFA70991E5DEBE5000CF1DB /* WeightedSortFunctionTests.swift */; };
 		DBFAC1311E4A5DEE00F534D5 /* SortFunctionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DBFAC1301E4A5DEE00F534D5 /* SortFunctionTests.swift */; };
 		DBFAC1371E4A67E600F534D5 /* CorneredSortFunctionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = DBFAC1361E4A67E600F534D5 /* CorneredSortFunctionTests.swift */; };
 /* End PBXBuildFile section */
@@ -100,7 +100,7 @@
 		DBFA708E1E5CBC44000CF1DB /* DefaultSortFunctionTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DefaultSortFunctionTests.swift; sourceTree = "<group>"; };
 		DBFA70901E5CBF10000CF1DB /* LinearSortFunctionTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = LinearSortFunctionTests.swift; sourceTree = "<group>"; };
 		DBFA70921E5CC052000CF1DB /* InlineSortFunctionTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = InlineSortFunctionTests.swift; sourceTree = "<group>"; };
-		DBFA70991E5DEBE5000CF1DB /* ContinuousWeightedSortFunctionTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ContinuousWeightedSortFunctionTests.swift; sourceTree = "<group>"; };
+		DBFA70991E5DEBE5000CF1DB /* WeightedSortFunctionTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = WeightedSortFunctionTests.swift; sourceTree = "<group>"; };
 		DBFAC1301E4A5DEE00F534D5 /* SortFunctionTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SortFunctionTests.swift; sourceTree = "<group>"; };
 		DBFAC1361E4A67E600F534D5 /* CorneredSortFunctionTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = CorneredSortFunctionTests.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
@@ -272,7 +272,7 @@
 				DBFA708E1E5CBC44000CF1DB /* DefaultSortFunctionTests.swift */,
 				DBFA70901E5CBF10000CF1DB /* LinearSortFunctionTests.swift */,
 				DBFA70921E5CC052000CF1DB /* InlineSortFunctionTests.swift */,
-				DBFA70991E5DEBE5000CF1DB /* ContinuousWeightedSortFunctionTests.swift */,
+				DBFA70991E5DEBE5000CF1DB /* WeightedSortFunctionTests.swift */,
 				DB7C757E1E7858BE0008C75C /* RandomSortFunctionTests.swift */,
 			);
 			path = "Sort Function Tests";
@@ -429,7 +429,7 @@
 			files = (
 				DB20E5771E4BADA9004C5A96 /* RadialSortFunctionTests.swift in Sources */,
 				DBFAC1371E4A67E600F534D5 /* CorneredSortFunctionTests.swift in Sources */,
-				DBFA709A1E5DEBE5000CF1DB /* ContinuousWeightedSortFunctionTests.swift in Sources */,
+				DBFA709A1E5DEBE5000CF1DB /* WeightedSortFunctionTests.swift in Sources */,
 				DBFA708F1E5CBC44000CF1DB /* DefaultSortFunctionTests.swift in Sources */,
 				DBFA70911E5CBF10000CF1DB /* LinearSortFunctionTests.swift in Sources */,
 				DBFA70931E5CC052000CF1DB /* InlineSortFunctionTests.swift in Sources */,
diff --git a/Spruce/SpruceTests/Sort Function Tests/ContinuousWeightedSortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/ContinuousWeightedSortFunctionTests.swift
deleted file mode 100644
index ee5de9d..0000000
--- a/Spruce/SpruceTests/Sort Function Tests/ContinuousWeightedSortFunctionTests.swift	
+++ /dev/null
@@ -1,1058 +0,0 @@
-//
-//  ContinuousWeightedSortFunctionTests.swift
-//  Spruce
-//
-//  Copyright (c) 2017 WillowTree, Inc.
-
-//  Permission is hereby granted, free of charge, to any person obtaining a copy
-//  of this software and associated documentation files (the "Software"), to deal
-//  in the Software without restriction, including without limitation the rights
-//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-//  copies of the Software, and to permit persons to whom the Software is
-//  furnished to do so, subject to the following conditions:
-
-//  The above copyright notice and this permission notice shall be included in
-//  all copies or substantial portions of the Software.
-
-//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-//  THE SOFTWARE.
-//
-
-
-import XCTest
-@testable import Spruce
-
-class ContinuousWeightedSortFunctionTests: SortFunctionTests {
-    
-    func testContinuousWeightedSortFunction(withStartPosition position: Position, horizontalWeight: Weight, verticalWeight: Weight, expected: [TimeInterval], expectedReversed: [TimeInterval]) {
-        var sortFunction = ContinuousWeightedSortFunction(position: position, duration: 1.0, horizontalWeight: horizontalWeight, verticalWeight: verticalWeight)
-        let timedViews = sortFunction.timeOffsets(view: animatableView)
-        
-        compare(timedViews: timedViews, toExpected: expected)
-        
-        sortFunction.reversed = true
-        let timedViewsReversed = sortFunction.timeOffsets(view: animatableView)
-        compare(timedViews: timedViewsReversed, toExpected: expectedReversed)
-    }
-    
-    func testContinuousWeightedSortFunctionWithEmptyView() {
-        let sortFunction = ContinuousWeightedSortFunction(position: .topLeft, duration: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: UIView())
-        
-        XCTAssertEqual(timedViews.count, 0)
-    }
-    
-    func testTopLeftLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.0,0.125,0.25,0.375,0.5,
-                        0.125,0.25,0.375,0.5,0.625,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.375,0.5,0.625,0.75,0.875,
-                        0.5,0.625,0.75,0.875,1.0]
-        let expectedReversed = [1.0,0.875,0.75,0.625,0.5,
-                                0.875,0.75,0.625,0.5,0.375,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.625,0.5,0.375,0.25,0.125,
-                                0.5,0.375,0.25,0.125,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopLeftLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.0,0.0833333333333333,0.166666666666667,0.25,0.333333333333333,
-                        0.166666666666667,0.25,0.333333333333333,0.416666666666667,0.5,
-                        0.333333333333333,0.416666666666667,0.5,0.583333333333333,0.666666666666667,
-                        0.5,0.583333333333333,0.666666666666667,0.75,0.833333333333333,
-                        0.666666666666667,0.75,0.833333333333333,0.916666666666667,1.0]
-        let expectedReversed = [1.0,0.916666666666667,0.833333333333333,0.75,0.666666666666667,
-                                0.833333333333333,0.75,0.666666666666667,0.583333333333333,0.5,
-                                0.666666666666667,0.583333333333333,0.5,0.416666666666667,0.333333333333333,
-                                0.5,0.416666666666667,0.333333333333333,0.25,0.166666666666667,
-                                0.333333333333333,0.25,0.166666666666667,0.0833333333333334,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopLeftMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667,
-                        0.0833333333333333,0.25,0.416666666666667,0.583333333333333,0.75,
-                        0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                        0.25,0.416666666666667,0.583333333333333,0.75,0.916666666666667,
-                        0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0]
-        let expectedReversed = [1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333,
-                                0.916666666666667,0.75,0.583333333333333,0.416666666666667,0.25,
-                                0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                                0.75,0.583333333333333,0.416666666666667,0.25,0.0833333333333334,
-                                0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopLeftMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.0,0.125,0.25,0.375,0.5,
-                        0.125,0.25,0.375,0.5,0.625,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.375,0.5,0.625,0.75,0.875,
-                        0.5,0.625,0.75,0.875,1.0]
-        let expectedReversed = [1.0,0.875,0.75,0.625,0.5,
-                                0.875,0.75,0.625,0.5,0.375,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.625,0.5,0.375,0.25,0.125,
-                                0.5,0.375,0.25,0.125,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopLeftHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.0,0.2,0.4,0.6,0.8,
-                        0.05,0.25,0.45,0.65,0.85,
-                        0.1,0.3,0.5,0.7,0.9,
-                        0.15,0.35,0.55,0.75,0.95,
-                        0.2,0.4,0.6,0.8,1.0]
-        let expectedReversed = [1.0,0.8,0.6,0.4,0.2,
-                                0.95,0.75,0.55,0.35,0.15,
-                                0.9,0.7,0.5,0.3,0.1,
-                                0.85,0.65,0.45,0.25,0.05,
-                                0.8,0.6,0.4,0.2,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopLeftHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667,
-                        0.0833333333333333,0.25,0.416666666666667,0.583333333333333,0.75,
-                        0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                        0.25,0.416666666666667,0.583333333333333,0.75,0.916666666666667,
-                        0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0]
-        let expectedReversed = [1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333,
-                                0.916666666666667,0.75,0.583333333333333,0.416666666666667,0.25,
-                                0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                                0.75,0.583333333333333,0.416666666666667,0.25,0.0833333333333334,
-                                0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopLeftHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [0.0,0.125,0.25,0.375,0.5,
-                        0.125,0.25,0.375,0.5,0.625,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.375,0.5,0.625,0.75,0.875,
-                        0.5,0.625,0.75,0.875,1.0]
-        let expectedReversed = [1.0,0.875,0.75,0.625,0.5,
-                                0.875,0.75,0.625,0.5,0.375,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.625,0.5,0.375,0.25,0.125,
-                                0.5,0.375,0.25,0.125,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopLeftCustomWeightsWeightedContinousSortFunction() {
-        let expected = [0.0,0.0688405797101449,0.13768115942029,0.206521739130435,0.27536231884058,
-                        0.181159420289855,0.25,0.318840579710145,0.38768115942029,0.456521739130435,
-                        0.36231884057971,0.431159420289855,0.5,0.568840579710145,0.63768115942029,
-                        0.543478260869565,0.61231884057971,0.681159420289855,0.75,0.818840579710145,
-                        0.72463768115942,0.793478260869565,0.86231884057971,0.931159420289855,1.0]
-        let expectedReversed = [1.0,0.931159420289855,0.86231884057971,0.793478260869565,0.72463768115942,
-                                0.818840579710145,0.75,0.681159420289855,0.61231884057971,0.543478260869565,
-                                0.63768115942029,0.568840579710145,0.5,0.431159420289855,0.36231884057971,
-                                0.456521739130435,0.38768115942029,0.318840579710145,0.25,0.181159420289855,
-                                0.27536231884058,0.206521739130435,0.13768115942029,0.068840579710145,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopMiddleLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.25,0.0,0.25,0.5,
-                        0.625,0.375,0.125,0.375,0.625,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.875,0.625,0.375,0.625,0.875,
-                        1.0,0.75,0.5,0.75,1.0]
-        let expectedReversed = [0.5,0.75,1.0,0.75,0.5,
-                                0.375,0.625,0.875,0.625,0.375,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.125,0.375,0.625,0.375,0.125,
-                                0.0,0.25,0.5,0.25,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopMiddleLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.333333333333333,0.166666666666667,0.0,0.166666666666667,0.333333333333333,
-                        0.5,0.333333333333333,0.166666666666667,0.333333333333333,0.5,
-                        0.666666666666667,0.5,0.333333333333333,0.5,0.666666666666667,
-                        0.833333333333333,0.666666666666667,0.5,0.666666666666667,0.833333333333333,
-                        1.0,0.833333333333333,0.666666666666667,0.833333333333333,1.0]
-        let expectedReversed = [0.666666666666667,0.833333333333333,1.0,0.833333333333333,0.666666666666667,
-                                0.5,0.666666666666667,0.833333333333333,0.666666666666667,0.5,
-                                0.333333333333333,0.5,0.666666666666667,0.5,0.333333333333333,
-                                0.166666666666667,0.333333333333333,0.5,0.333333333333333,0.166666666666667,
-                                0.0,0.166666666666667,0.333333333333333,0.166666666666667,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopMiddleMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.666666666666667,0.333333333333333,0.0,0.333333333333333,0.666666666666667,
-                        0.75,0.416666666666667,0.0833333333333333,0.416666666666667,0.75,
-                        0.833333333333333,0.5,0.166666666666667,0.5,0.833333333333333,
-                        0.916666666666667,0.583333333333333,0.25,0.583333333333333,0.916666666666667,
-                        1.0,0.666666666666667,0.333333333333333,0.666666666666667,1.0]
-        let expectedReversed = [0.333333333333333,0.666666666666667,1.0,0.666666666666667,0.333333333333333,
-                                0.25,0.583333333333333,0.916666666666667,0.583333333333333,0.25,
-                                0.166666666666667,0.5,0.833333333333333,0.5,0.166666666666667,
-                                0.0833333333333334,0.416666666666667,0.75,0.416666666666667,0.0833333333333334,
-                                0.0,0.333333333333333,0.666666666666667,0.333333333333333,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopMiddleMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.25,0.0,0.25,0.5,
-                        0.625,0.375,0.125,0.375,0.625,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.875,0.625,0.375,0.625,0.875,
-                        1.0,0.75,0.5,0.75,1.0]
-        let expectedReversed = [0.5,0.75,1.0,0.75,0.5,
-                                0.375,0.625,0.875,0.625,0.375,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.125,0.375,0.625,0.375,0.125,
-                                0.0,0.25,0.5,0.25,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopMiddleHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.8,0.4,0.0,0.4,0.8,
-                        0.85,0.45,0.05,0.45,0.85,
-                        0.9,0.5,0.1,0.5,0.9,
-                        0.95,0.55,0.15,0.55,0.95,
-                        1.0,0.6,0.2,0.6,1.0]
-        let expectedReversed = [0.2,0.6,1.0,0.6,0.2,
-                                0.15,0.55,0.95,0.55,0.15,
-                                0.1,0.5,0.9,0.5,0.1,
-                                0.05,0.45,0.85,0.45,0.05,
-                                0.0,0.4,0.8,0.4,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopMiddleHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.666666666666667,0.333333333333333,0.0,0.333333333333333,0.666666666666667,
-                        0.75,0.416666666666667,0.0833333333333333,0.416666666666667,0.75,
-                        0.833333333333333,0.5,0.166666666666667,0.5,0.833333333333333,
-                        0.916666666666667,0.583333333333333,0.25,0.583333333333333,0.916666666666667,
-                        1.0,0.666666666666667,0.333333333333333,0.666666666666667,1.0]
-        let expectedReversed = [0.333333333333333,0.666666666666667,1.0,0.666666666666667,0.333333333333333,
-                                0.25,0.583333333333333,0.916666666666667,0.583333333333333,0.25,
-                                0.166666666666667,0.5,0.833333333333333,0.5,0.166666666666667,
-                                0.0833333333333334,0.416666666666667,0.75,0.416666666666667,0.0833333333333334,
-                                0.0,0.333333333333333,0.666666666666667,0.333333333333333,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopMiddleHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.25,0.0,0.25,0.5,
-                        0.625,0.375,0.125,0.375,0.625,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.875,0.625,0.375,0.625,0.875,
-                        1.0,0.75,0.5,0.75,1.0]
-        let expectedReversed = [0.5,0.75,1.0,0.75,0.5,
-                                0.375,0.625,0.875,0.625,0.375,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.125,0.375,0.625,0.375,0.125,
-                                0.0,0.25,0.5,0.25,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopMiddleCustomWeightsWeightedContinousSortFunction() {
-        let expected = [0.27536231884058,0.13768115942029,0.0,0.13768115942029,0.27536231884058,
-                        0.456521739130435,0.318840579710145,0.181159420289855,0.318840579710145,0.456521739130435,
-                        0.63768115942029,0.5,0.36231884057971,0.5,0.63768115942029,
-                        0.818840579710145,0.681159420289855,0.543478260869565,0.681159420289855,0.818840579710145,
-                        1.0,0.86231884057971,0.72463768115942,0.86231884057971,1.0]
-        let expectedReversed = [0.72463768115942,0.86231884057971,1.0,0.86231884057971,0.72463768115942,
-                                0.543478260869565,0.681159420289855,0.818840579710145,0.681159420289855,0.543478260869565,
-                                0.36231884057971,0.5,0.63768115942029,0.5,0.36231884057971,
-                                0.181159420289855,0.318840579710145,0.456521739130435,0.318840579710145,0.181159420289855,
-                                0.0,0.13768115942029,0.27536231884058,0.13768115942029,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopRightLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.375,0.25,0.125,0.0,
-                        0.625,0.5,0.375,0.25,0.125,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.875,0.75,0.625,0.5,0.375,
-                        1.0,0.875,0.75,0.625,0.5]
-        let expectedReversed = [0.5,0.625,0.75,0.875,1.0,
-                                0.375,0.5,0.625,0.75,0.875,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.125,0.25,0.375,0.5,0.625,
-                                0.0,0.125,0.25,0.375,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopRightLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.333333333333333,0.25,0.166666666666667,0.0833333333333333,0.0,
-                        0.5,0.416666666666667,0.333333333333333,0.25,0.166666666666667,
-                        0.666666666666667,0.583333333333333,0.5,0.416666666666667,0.333333333333333,
-                        0.833333333333333,0.75,0.666666666666667,0.583333333333333,0.5,
-                        1.0,0.916666666666667,0.833333333333333,0.75,0.666666666666667]
-        let expectedReversed = [0.666666666666667,0.75,0.833333333333333,0.916666666666667,1.0,
-                                0.5,0.583333333333333,0.666666666666667,0.75,0.833333333333333,
-                                0.333333333333333,0.416666666666667,0.5,0.583333333333333,0.666666666666667,
-                                0.166666666666667,0.25,0.333333333333333,0.416666666666667,0.5,
-                                0.0,0.0833333333333334,0.166666666666667,0.25,0.333333333333333]
-        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopRightMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0,
-                        0.75,0.583333333333333,0.416666666666667,0.25,0.0833333333333333,
-                        0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                        0.916666666666667,0.75,0.583333333333333,0.416666666666667,0.25,
-                        1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333]
-        let expectedReversed = [0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0,
-                                0.25,0.416666666666667,0.583333333333333,0.75,0.916666666666667,
-                                0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                                0.0833333333333334,0.25,0.416666666666667,0.583333333333333,0.75,
-                                0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667]
-        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopRightMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.375,0.25,0.125,0.0,
-                        0.625,0.5,0.375,0.25,0.125,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.875,0.75,0.625,0.5,0.375,
-                        1.0,0.875,0.75,0.625,0.5]
-        let expectedReversed = [0.5,0.625,0.75,0.875,1.0,
-                                0.375,0.5,0.625,0.75,0.875,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.125,0.25,0.375,0.5,0.625,
-                                0.0,0.125,0.25,0.375,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopRightHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.8,0.6,0.4,0.2,0.0,
-                        0.85,0.65,0.45,0.25,0.05,
-                        0.9,0.7,0.5,0.3,0.1,
-                        0.95,0.75,0.55,0.35,0.15,
-                        1.0,0.8,0.6,0.4,0.2]
-        let expectedReversed = [0.2,0.4,0.6,0.8,1.0,
-                                0.15,0.35,0.55,0.75,0.95,
-                                0.1,0.3,0.5,0.7,0.9,
-                                0.05,0.25,0.45,0.65,0.85,
-                                0.0,0.2,0.4,0.6,0.8]
-        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopRightHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0,
-                        0.75,0.583333333333333,0.416666666666667,0.25,0.0833333333333333,
-                        0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                        0.916666666666667,0.75,0.583333333333333,0.416666666666667,0.25,
-                        1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333]
-        let expectedReversed = [0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0,
-                                0.25,0.416666666666667,0.583333333333333,0.75,0.916666666666667,
-                                0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                                0.0833333333333334,0.25,0.416666666666667,0.583333333333333,0.75,
-                                0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667]
-        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopRightHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.375,0.25,0.125,0.0,
-                        0.625,0.5,0.375,0.25,0.125,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.875,0.75,0.625,0.5,0.375,
-                        1.0,0.875,0.75,0.625,0.5]
-        let expectedReversed = [0.5,0.625,0.75,0.875,1.0,
-                                0.375,0.5,0.625,0.75,0.875,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.125,0.25,0.375,0.5,0.625,
-                                0.0,0.125,0.25,0.375,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testTopRightCustomWeightsWeightedContinousSortFunction() {
-        let expected = [0.27536231884058,0.206521739130435,0.13768115942029,0.0688405797101449,0.0,
-                        0.456521739130435,0.38768115942029,0.318840579710145,0.25,0.181159420289855,
-                        0.63768115942029,0.568840579710145,0.5,0.431159420289855,0.36231884057971,
-                        0.818840579710145,0.75,0.681159420289855,0.61231884057971,0.543478260869565,
-                        1.0,0.931159420289855,0.86231884057971,0.793478260869565,0.72463768115942]
-        let expectedReversed = [0.72463768115942,0.793478260869565,0.86231884057971,0.931159420289855,1.0,
-                                0.543478260869565,0.61231884057971,0.681159420289855,0.75,0.818840579710145,
-                                0.36231884057971,0.431159420289855,0.5,0.568840579710145,0.63768115942029,
-                                0.181159420289855,0.25,0.318840579710145,0.38768115942029,0.456521739130435,
-                                0.0,0.068840579710145,0.13768115942029,0.206521739130435,0.27536231884058]
-        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testLeftLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.625,0.75,0.875,1.0,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.0,0.125,0.25,0.375,0.5,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.5,0.625,0.75,0.875,1.0]
-        let expectedReversed = [0.5,0.375,0.25,0.125,0.0,
-                                0.75,0.625,0.5,0.375,0.25,
-                                1.0,0.875,0.75,0.625,0.5,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.5,0.375,0.25,0.125,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testLeftLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.666666666666667,0.75,0.833333333333333,0.916666666666667,1.0,
-                        0.333333333333333,0.416666666666667,0.5,0.583333333333333,0.666666666666667,
-                        0.0,0.0833333333333333,0.166666666666667,0.25,0.333333333333333,
-                        0.333333333333333,0.416666666666667,0.5,0.583333333333333,0.666666666666667,
-                        0.666666666666667,0.75,0.833333333333333,0.916666666666667,1.0]
-        let expectedReversed = [0.333333333333333,0.25,0.166666666666667,0.0833333333333334,0.0,
-                                0.666666666666667,0.583333333333333,0.5,0.416666666666667,0.333333333333333,
-                                1.0,0.916666666666667,0.833333333333333,0.75,0.666666666666667,
-                                0.666666666666667,0.583333333333333,0.5,0.416666666666667,0.333333333333333,
-                                0.333333333333333,0.25,0.166666666666667,0.0833333333333334,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testLeftMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0,
-                        0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                        0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667,
-                        0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                        0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0]
-        let expectedReversed = [0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0,
-                                0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                                1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333,
-                                0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                                0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testLeftMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.625,0.75,0.875,1.0,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.0,0.125,0.25,0.375,0.5,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.5,0.625,0.75,0.875,1.0]
-        let expectedReversed = [0.5,0.375,0.25,0.125,0.0,
-                                0.75,0.625,0.5,0.375,0.25,
-                                1.0,0.875,0.75,0.625,0.5,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.5,0.375,0.25,0.125,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testLeftHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.2,0.4,0.6,0.8,1.0,
-                        0.1,0.3,0.5,0.7,0.9,
-                        0.0,0.2,0.4,0.6,0.8,
-                        0.1,0.3,0.5,0.7,0.9,
-                        0.2,0.4,0.6,0.8,1.0]
-        let expectedReversed = [0.8,0.6,0.4,0.2,0.0,
-                                0.9,0.7,0.5,0.3,0.1,
-                                1.0,0.8,0.6,0.4,0.2,
-                                0.9,0.7,0.5,0.3,0.1,
-                                0.8,0.6,0.4,0.2,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testLeftHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0,
-                        0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                        0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667,
-                        0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                        0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0]
-        let expectedReversed = [0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0,
-                                0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                                1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333,
-                                0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                                0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testLeftHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.625,0.75,0.875,1.0,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.0,0.125,0.25,0.375,0.5,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.5,0.625,0.75,0.875,1.0]
-        let expectedReversed = [0.5,0.375,0.25,0.125,0.0,
-                                0.75,0.625,0.5,0.375,0.25,
-                                1.0,0.875,0.75,0.625,0.5,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.5,0.375,0.25,0.125,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testLeftCustomWeightsWeightedContinousSortFunction() {
-        let expected = [0.72463768115942,0.793478260869565,0.86231884057971,0.931159420289855,1.0,
-                        0.36231884057971,0.431159420289855,0.5,0.568840579710145,0.63768115942029,
-                        0.0,0.0688405797101449,0.13768115942029,0.206521739130435,0.27536231884058,
-                        0.36231884057971,0.431159420289855,0.5,0.568840579710145,0.63768115942029,
-                        0.72463768115942,0.793478260869565,0.86231884057971,0.931159420289855,1.0]
-        let expectedReversed = [0.27536231884058,0.206521739130435,0.13768115942029,0.068840579710145,0.0,
-                                0.63768115942029,0.568840579710145,0.5,0.431159420289855,0.36231884057971,
-                                1.0,0.931159420289855,0.86231884057971,0.793478260869565,0.72463768115942,
-                                0.63768115942029,0.568840579710145,0.5,0.431159420289855,0.36231884057971,
-                                0.27536231884058,0.206521739130435,0.13768115942029,0.068840579710145,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testMiddleLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.75,0.5,0.75,1.0,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.5,0.25,0.0,0.25,0.5,
-                        0.75,0.5,0.25,0.5,0.75,
-                        1.0,0.75,0.5,0.75,1.0]
-        let expectedReversed = [0.0,0.25,0.5,0.25,0.0,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.5,0.75,1.0,0.75,0.5,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.0,0.25,0.5,0.25,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testMiddleLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.833333333333333,0.666666666666667,0.833333333333333,1.0,
-                        0.666666666666667,0.5,0.333333333333333,0.5,0.666666666666667,
-                        0.333333333333333,0.166666666666667,0.0,0.166666666666667,0.333333333333333,
-                        0.666666666666667,0.5,0.333333333333333,0.5,0.666666666666667,
-                        1.0,0.833333333333333,0.666666666666667,0.833333333333333,1.0]
-        let expectedReversed = [0.0,0.166666666666667,0.333333333333333,0.166666666666667,0.0,
-                                0.333333333333333,0.5,0.666666666666667,0.5,0.333333333333333,
-                                0.666666666666667,0.833333333333333,1.0,0.833333333333333,0.666666666666667,
-                                0.333333333333333,0.5,0.666666666666667,0.5,0.333333333333333,
-                                0.0,0.166666666666667,0.333333333333333,0.166666666666667,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testMiddleMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.666666666666667,0.333333333333333,0.666666666666667,1.0,
-                        0.833333333333333,0.5,0.166666666666667,0.5,0.833333333333333,
-                        0.666666666666667,0.333333333333333,0.0,0.333333333333333,0.666666666666667,
-                        0.833333333333333,0.5,0.166666666666667,0.5,0.833333333333333,
-                        1.0,0.666666666666667,0.333333333333333,0.666666666666667,1.0]
-        let expectedReversed = [0.0,0.333333333333333,0.666666666666667,0.333333333333333,0.0,
-                                0.166666666666667,0.5,0.833333333333333,0.5,0.166666666666667,
-                                0.333333333333333,0.666666666666667,1.0,0.666666666666667,0.333333333333333,
-                                0.166666666666667,0.5,0.833333333333333,0.5,0.166666666666667,
-                                0.0,0.333333333333333,0.666666666666667,0.333333333333333,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testMiddleMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.75,0.5,0.75,1.0,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.5,0.25,0.0,0.25,0.5,
-                        0.75,0.5,0.25,0.5,0.75,
-                        1.0,0.75,0.5,0.75,1.0]
-        let expectedReversed = [0.0,0.25,0.5,0.25,0.0,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.5,0.75,1.0,0.75,0.5,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.0,0.25,0.5,0.25,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testMiddleHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.6,0.2,0.6,1.0,
-                        0.9,0.5,0.1,0.5,0.9,
-                        0.8,0.4,0.0,0.4,0.8,
-                        0.9,0.5,0.1,0.5,0.9,
-                        1.0,0.6,0.2,0.6,1.0]
-        let expectedReversed = [0.0,0.4,0.8,0.4,0.0,
-                                0.1,0.5,0.9,0.5,0.1,
-                                0.2,0.6,1.0,0.6,0.2,
-                                0.1,0.5,0.9,0.5,0.1,
-                                0.0,0.4,0.8,0.4,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testMiddleHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.666666666666667,0.333333333333333,0.666666666666667,1.0,
-                        0.833333333333333,0.5,0.166666666666667,0.5,0.833333333333333,
-                        0.666666666666667,0.333333333333333,0.0,0.333333333333333,0.666666666666667,
-                        0.833333333333333,0.5,0.166666666666667,0.5,0.833333333333333,
-                        1.0,0.666666666666667,0.333333333333333,0.666666666666667,1.0]
-        let expectedReversed = [0.0,0.333333333333333,0.666666666666667,0.333333333333333,0.0,
-                                0.166666666666667,0.5,0.833333333333333,0.5,0.166666666666667,
-                                0.333333333333333,0.666666666666667,1.0,0.666666666666667,0.333333333333333,
-                                0.166666666666667,0.5,0.833333333333333,0.5,0.166666666666667,
-                                0.0,0.333333333333333,0.666666666666667,0.333333333333333,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testMiddleHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.75,0.5,0.75,1.0,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.5,0.25,0.0,0.25,0.5,
-                        0.75,0.5,0.25,0.5,0.75,
-                        1.0,0.75,0.5,0.75,1.0]
-        let expectedReversed = [0.0,0.25,0.5,0.25,0.0,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.5,0.75,1.0,0.75,0.5,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.0,0.25,0.5,0.25,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testMiddleCustomWeightsWeightedContinousSortFunction() {
-        let expected = [1.0,0.86231884057971,0.72463768115942,0.86231884057971,1.0,
-                        0.63768115942029,0.5,0.36231884057971,0.5,0.63768115942029,
-                        0.27536231884058,0.13768115942029,0.0,0.13768115942029,0.27536231884058,
-                        0.63768115942029,0.5,0.36231884057971,0.5,0.63768115942029,
-                        1.0,0.86231884057971,0.72463768115942,0.86231884057971,1.0]
-        let expectedReversed = [0.0,0.13768115942029,0.27536231884058,0.13768115942029,0.0,
-                                0.36231884057971,0.5,0.63768115942029,0.5,0.36231884057971,
-                                0.72463768115942,0.86231884057971,1.0,0.86231884057971,0.72463768115942,
-                                0.36231884057971,0.5,0.63768115942029,0.5,0.36231884057971,
-                                0.0,0.13768115942029,0.27536231884058,0.13768115942029,0.0]
-        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testRightLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.875,0.75,0.625,0.5,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.5,0.375,0.25,0.125,0.0,
-                        0.75,0.625,0.5,0.375,0.25,
-                        1.0,0.875,0.75,0.625,0.5]
-        let expectedReversed = [0.0,0.125,0.25,0.375,0.5,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.5,0.625,0.75,0.875,1.0,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.0,0.125,0.25,0.375,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testRightLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.916666666666667,0.833333333333333,0.75,0.666666666666667,
-                        0.666666666666667,0.583333333333333,0.5,0.416666666666667,0.333333333333333,
-                        0.333333333333333,0.25,0.166666666666667,0.0833333333333333,0.0,
-                        0.666666666666667,0.583333333333333,0.5,0.416666666666667,0.333333333333333,
-                        1.0,0.916666666666667,0.833333333333333,0.75,0.666666666666667]
-        let expectedReversed = [0.0,0.0833333333333334,0.166666666666667,0.25,0.333333333333333,
-                                0.333333333333333,0.416666666666667,0.5,0.583333333333333,0.666666666666667,
-                                0.666666666666667,0.75,0.833333333333333,0.916666666666667,1.0,
-                                0.333333333333333,0.416666666666667,0.5,0.583333333333333,0.666666666666667,
-                                0.0,0.0833333333333334,0.166666666666667,0.25,0.333333333333333]
-        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testRightMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333,
-                        0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                        0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0,
-                        0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                        1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333]
-        let expectedReversed = [0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667,
-                                0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                                0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0,
-                                0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                                0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667]
-        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testRightMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.875,0.75,0.625,0.5,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.5,0.375,0.25,0.125,0.0,
-                        0.75,0.625,0.5,0.375,0.25,
-                        1.0,0.875,0.75,0.625,0.5]
-        let expectedReversed = [0.0,0.125,0.25,0.375,0.5,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.5,0.625,0.75,0.875,1.0,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.0,0.125,0.25,0.375,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testRightHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.8,0.6,0.4,0.2,
-                        0.9,0.7,0.5,0.3,0.1,
-                        0.8,0.6,0.4,0.2,0.0,
-                        0.9,0.7,0.5,0.3,0.1,
-                        1.0,0.8,0.6,0.4,0.2]
-        let expectedReversed = [0.0,0.2,0.4,0.6,0.8,
-                                0.1,0.3,0.5,0.7,0.9,
-                                0.2,0.4,0.6,0.8,1.0,
-                                0.1,0.3,0.5,0.7,0.9,
-                                0.0,0.2,0.4,0.6,0.8]
-        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testRightHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333,
-                        0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                        0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0,
-                        0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                        1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333]
-        let expectedReversed = [0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667,
-                                0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                                0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0,
-                                0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                                0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667]
-        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testRightHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.875,0.75,0.625,0.5,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.5,0.375,0.25,0.125,0.0,
-                        0.75,0.625,0.5,0.375,0.25,
-                        1.0,0.875,0.75,0.625,0.5]
-        let expectedReversed = [0.0,0.125,0.25,0.375,0.5,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.5,0.625,0.75,0.875,1.0,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.0,0.125,0.25,0.375,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testRightCustomWeightsWeightedContinousSortFunction() {
-        let expected = [1.0,0.931159420289855,0.86231884057971,0.793478260869565,0.72463768115942,
-                        0.63768115942029,0.568840579710145,0.5,0.431159420289855,0.36231884057971,
-                        0.27536231884058,0.206521739130435,0.13768115942029,0.0688405797101449,0.0,
-                        0.63768115942029,0.568840579710145,0.5,0.431159420289855,0.36231884057971,
-                        1.0,0.931159420289855,0.86231884057971,0.793478260869565,0.72463768115942]
-        let expectedReversed = [0.0,0.068840579710145,0.13768115942029,0.206521739130435,0.27536231884058,
-                                0.36231884057971,0.431159420289855,0.5,0.568840579710145,0.63768115942029,
-                                0.72463768115942,0.793478260869565,0.86231884057971,0.931159420289855,1.0,
-                                0.36231884057971,0.431159420289855,0.5,0.568840579710145,0.63768115942029,
-                                0.0,0.068840579710145,0.13768115942029,0.206521739130435,0.27536231884058]
-        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomLeftLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.625,0.75,0.875,1.0,
-                        0.375,0.5,0.625,0.75,0.875,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.125,0.25,0.375,0.5,0.625,
-                        0.0,0.125,0.25,0.375,0.5]
-        let expectedReversed = [0.5,0.375,0.25,0.125,0.0,
-                                0.625,0.5,0.375,0.25,0.125,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.875,0.75,0.625,0.5,0.375,
-                                1.0,0.875,0.75,0.625,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomLeftLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.666666666666667,0.75,0.833333333333333,0.916666666666667,1.0,
-                        0.5,0.583333333333333,0.666666666666667,0.75,0.833333333333333,
-                        0.333333333333333,0.416666666666667,0.5,0.583333333333333,0.666666666666667,
-                        0.166666666666667,0.25,0.333333333333333,0.416666666666667,0.5,
-                        0.0,0.0833333333333333,0.166666666666667,0.25,0.333333333333333]
-        let expectedReversed = [0.333333333333333,0.25,0.166666666666667,0.0833333333333334,0.0,
-                                0.5,0.416666666666667,0.333333333333333,0.25,0.166666666666667,
-                                0.666666666666667,0.583333333333333,0.5,0.416666666666667,0.333333333333333,
-                                0.833333333333333,0.75,0.666666666666667,0.583333333333333,0.5,
-                                1.0,0.916666666666667,0.833333333333333,0.75,0.666666666666667]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomLeftMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0,
-                        0.25,0.416666666666667,0.583333333333333,0.75,0.916666666666667,
-                        0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                        0.0833333333333333,0.25,0.416666666666667,0.583333333333333,0.75,
-                        0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667]
-        let expectedReversed = [0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0,
-                                0.75,0.583333333333333,0.416666666666667,0.25,0.0833333333333334,
-                                0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                                0.916666666666667,0.75,0.583333333333333,0.416666666666667,0.25,
-                                1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomLeftMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.625,0.75,0.875,1.0,
-                        0.375,0.5,0.625,0.75,0.875,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.125,0.25,0.375,0.5,0.625,
-                        0.0,0.125,0.25,0.375,0.5]
-        let expectedReversed = [0.5,0.375,0.25,0.125,0.0,
-                                0.625,0.5,0.375,0.25,0.125,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.875,0.75,0.625,0.5,0.375,
-                                1.0,0.875,0.75,0.625,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomLeftHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [0.2,0.4,0.6,0.8,1.0,
-                        0.15,0.35,0.55,0.75,0.95,
-                        0.1,0.3,0.5,0.7,0.9,
-                        0.05,0.25,0.45,0.65,0.85,
-                        0.0,0.2,0.4,0.6,0.8]
-        let expectedReversed = [0.8,0.6,0.4,0.2,0.0,
-                                0.85,0.65,0.45,0.25,0.05,
-                                0.9,0.7,0.5,0.3,0.1,
-                                0.95,0.75,0.55,0.35,0.15,
-                                1.0,0.8,0.6,0.4,0.2]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomLeftHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0,
-                        0.25,0.416666666666667,0.583333333333333,0.75,0.916666666666667,
-                        0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                        0.0833333333333333,0.25,0.416666666666667,0.583333333333333,0.75,
-                        0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667]
-        let expectedReversed = [0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0,
-                                0.75,0.583333333333333,0.416666666666667,0.25,0.0833333333333334,
-                                0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                                0.916666666666667,0.75,0.583333333333333,0.416666666666667,0.25,
-                                1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomLeftHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [0.5,0.625,0.75,0.875,1.0,
-                        0.375,0.5,0.625,0.75,0.875,
-                        0.25,0.375,0.5,0.625,0.75,
-                        0.125,0.25,0.375,0.5,0.625,
-                        0.0,0.125,0.25,0.375,0.5]
-        let expectedReversed = [0.5,0.375,0.25,0.125,0.0,
-                                0.625,0.5,0.375,0.25,0.125,
-                                0.75,0.625,0.5,0.375,0.25,
-                                0.875,0.75,0.625,0.5,0.375,
-                                1.0,0.875,0.75,0.625,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomLeftCustomWeightsWeightedContinousSortFunction() {
-        let expected = [0.72463768115942,0.793478260869565,0.86231884057971,0.931159420289855,1.0,
-                        0.543478260869565,0.61231884057971,0.681159420289855,0.75,0.818840579710145,
-                        0.36231884057971,0.431159420289855,0.5,0.568840579710145,0.63768115942029,
-                        0.181159420289855,0.25,0.318840579710145,0.38768115942029,0.456521739130435,
-                        0.0,0.0688405797101449,0.13768115942029,0.206521739130435,0.27536231884058]
-        let expectedReversed = [0.27536231884058,0.206521739130435,0.13768115942029,0.068840579710145,0.0,
-                                0.456521739130435,0.38768115942029,0.318840579710145,0.25,0.181159420289855,
-                                0.63768115942029,0.568840579710145,0.5,0.431159420289855,0.36231884057971,
-                                0.818840579710145,0.75,0.681159420289855,0.61231884057971,0.543478260869565,
-                                1.0,0.931159420289855,0.86231884057971,0.793478260869565,0.72463768115942]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomMiddleLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.75,0.5,0.75,1.0,
-                        0.875,0.625,0.375,0.625,0.875,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.625,0.375,0.125,0.375,0.625,
-                        0.5,0.25,0.0,0.25,0.5]
-        let expectedReversed = [0.0,0.25,0.5,0.25,0.0,
-                                0.125,0.375,0.625,0.375,0.125,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.375,0.625,0.875,0.625,0.375,
-                                0.5,0.75,1.0,0.75,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomMiddleLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.833333333333333,0.666666666666667,0.833333333333333,1.0,
-                        0.833333333333333,0.666666666666667,0.5,0.666666666666667,0.833333333333333,
-                        0.666666666666667,0.5,0.333333333333333,0.5,0.666666666666667,
-                        0.5,0.333333333333333,0.166666666666667,0.333333333333333,0.5,
-                        0.333333333333333,0.166666666666667,0.0,0.166666666666667,0.333333333333333]
-        let expectedReversed = [0.0,0.166666666666667,0.333333333333333,0.166666666666667,0.0,
-                                0.166666666666667,0.333333333333333,0.5,0.333333333333333,0.166666666666667,
-                                0.333333333333333,0.5,0.666666666666667,0.5,0.333333333333333,
-                                0.5,0.666666666666667,0.833333333333333,0.666666666666667,0.5,
-                                0.666666666666667,0.833333333333333,1.0,0.833333333333333,0.666666666666667]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomMiddleMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.666666666666667,0.333333333333333,0.666666666666667,1.0,
-                        0.916666666666667,0.583333333333333,0.25,0.583333333333333,0.916666666666667,
-                        0.833333333333333,0.5,0.166666666666667,0.5,0.833333333333333,
-                        0.75,0.416666666666667,0.0833333333333333,0.416666666666667,0.75,
-                        0.666666666666667,0.333333333333333,0.0,0.333333333333333,0.666666666666667]
-        let expectedReversed = [0.0,0.333333333333333,0.666666666666667,0.333333333333333,0.0,
-                                0.0833333333333334,0.416666666666667,0.75,0.416666666666667,0.0833333333333334,
-                                0.166666666666667,0.5,0.833333333333333,0.5,0.166666666666667,
-                                0.25,0.583333333333333,0.916666666666667,0.583333333333333,0.25,
-                                0.333333333333333,0.666666666666667,1.0,0.666666666666667,0.333333333333333]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomMiddleMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.75,0.5,0.75,1.0,
-                        0.875,0.625,0.375,0.625,0.875,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.625,0.375,0.125,0.375,0.625,
-                        0.5,0.25,0.0,0.25,0.5]
-        let expectedReversed = [0.0,0.25,0.5,0.25,0.0,
-                                0.125,0.375,0.625,0.375,0.125,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.375,0.625,0.875,0.625,0.375,
-                                0.5,0.75,1.0,0.75,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomMiddleHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.6,0.2,0.6,1.0,
-                        0.95,0.55,0.15,0.55,0.95,
-                        0.9,0.5,0.1,0.5,0.9,
-                        0.85,0.45,0.05,0.45,0.85,
-                        0.8,0.4,0.0,0.4,0.8]
-        let expectedReversed = [0.0,0.4,0.8,0.4,0.0,
-                                0.05,0.45,0.85,0.45,0.05,
-                                0.1,0.5,0.9,0.5,0.1,
-                                0.15,0.55,0.95,0.55,0.15,
-                                0.2,0.6,1.0,0.6,0.2]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomMiddleHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.666666666666667,0.333333333333333,0.666666666666667,1.0,
-                        0.916666666666667,0.583333333333333,0.25,0.583333333333333,0.916666666666667,
-                        0.833333333333333,0.5,0.166666666666667,0.5,0.833333333333333,
-                        0.75,0.416666666666667,0.0833333333333333,0.416666666666667,0.75,
-                        0.666666666666667,0.333333333333333,0.0,0.333333333333333,0.666666666666667]
-        let expectedReversed = [0.0,0.333333333333333,0.666666666666667,0.333333333333333,0.0,
-                                0.0833333333333334,0.416666666666667,0.75,0.416666666666667,0.0833333333333334,
-                                0.166666666666667,0.5,0.833333333333333,0.5,0.166666666666667,
-                                0.25,0.583333333333333,0.916666666666667,0.583333333333333,0.25,
-                                0.333333333333333,0.666666666666667,1.0,0.666666666666667,0.333333333333333]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomMiddleHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.75,0.5,0.75,1.0,
-                        0.875,0.625,0.375,0.625,0.875,
-                        0.75,0.5,0.25,0.5,0.75,
-                        0.625,0.375,0.125,0.375,0.625,
-                        0.5,0.25,0.0,0.25,0.5]
-        let expectedReversed = [0.0,0.25,0.5,0.25,0.0,
-                                0.125,0.375,0.625,0.375,0.125,
-                                0.25,0.5,0.75,0.5,0.25,
-                                0.375,0.625,0.875,0.625,0.375,
-                                0.5,0.75,1.0,0.75,0.5]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomMiddleCustomWeightsWeightedContinousSortFunction() {
-        let expected = [1.0,0.86231884057971,0.72463768115942,0.86231884057971,1.0,
-                        0.818840579710145,0.681159420289855,0.543478260869565,0.681159420289855,0.818840579710145,
-                        0.63768115942029,0.5,0.36231884057971,0.5,0.63768115942029,
-                        0.456521739130435,0.318840579710145,0.181159420289855,0.318840579710145,0.456521739130435,
-                        0.27536231884058,0.13768115942029,0.0,0.13768115942029,0.27536231884058]
-        let expectedReversed = [0.0,0.13768115942029,0.27536231884058,0.13768115942029,0.0,
-                                0.181159420289855,0.318840579710145,0.456521739130435,0.318840579710145,0.181159420289855,
-                                0.36231884057971,0.5,0.63768115942029,0.5,0.36231884057971,
-                                0.543478260869565,0.681159420289855,0.818840579710145,0.681159420289855,0.543478260869565,
-                                0.72463768115942,0.86231884057971,1.0,0.86231884057971,0.72463768115942]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomRightLightHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.875,0.75,0.625,0.5,
-                        0.875,0.75,0.625,0.5,0.375,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.625,0.5,0.375,0.25,0.125,
-                        0.5,0.375,0.25,0.125,0.0]
-        let expectedReversed = [0.0,0.125,0.25,0.375,0.5,
-                                0.125,0.25,0.375,0.5,0.625,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.375,0.5,0.625,0.75,0.875,
-                                0.5,0.625,0.75,0.875,1.0]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomRightLightHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.916666666666667,0.833333333333333,0.75,0.666666666666667,
-                        0.833333333333333,0.75,0.666666666666667,0.583333333333333,0.5,
-                        0.666666666666667,0.583333333333333,0.5,0.416666666666667,0.333333333333333,
-                        0.5,0.416666666666667,0.333333333333333,0.25,0.166666666666667,
-                        0.333333333333333,0.25,0.166666666666667,0.0833333333333333,0.0]
-        let expectedReversed = [0.0,0.0833333333333334,0.166666666666667,0.25,0.333333333333333,
-                                0.166666666666667,0.25,0.333333333333333,0.416666666666667,0.5,
-                                0.333333333333333,0.416666666666667,0.5,0.583333333333333,0.666666666666667,
-                                0.5,0.583333333333333,0.666666666666667,0.75,0.833333333333333,
-                                0.666666666666667,0.75,0.833333333333333,0.916666666666667,1.0]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomRightMediumHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333,
-                        0.916666666666667,0.75,0.583333333333333,0.416666666666667,0.25,
-                        0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                        0.75,0.583333333333333,0.416666666666667,0.25,0.0833333333333333,
-                        0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0]
-        let expectedReversed = [0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667,
-                                0.0833333333333334,0.25,0.416666666666667,0.583333333333333,0.75,
-                                0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                                0.25,0.416666666666667,0.583333333333333,0.75,0.916666666666667,
-                                0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomRightMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.875,0.75,0.625,0.5,
-                        0.875,0.75,0.625,0.5,0.375,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.625,0.5,0.375,0.25,0.125,
-                        0.5,0.375,0.25,0.125,0.0]
-        let expectedReversed = [0.0,0.125,0.25,0.375,0.5,
-                                0.125,0.25,0.375,0.5,0.625,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.375,0.5,0.625,0.75,0.875,
-                                0.5,0.625,0.75,0.875,1.0]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomRightHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.8,0.6,0.4,0.2,
-                        0.95,0.75,0.55,0.35,0.15,
-                        0.9,0.7,0.5,0.3,0.1,
-                        0.85,0.65,0.45,0.25,0.05,
-                        0.8,0.6,0.4,0.2,0.0]
-        let expectedReversed = [0.0,0.2,0.4,0.6,0.8,
-                                0.05,0.25,0.45,0.65,0.85,
-                                0.1,0.3,0.5,0.7,0.9,
-                                0.15,0.35,0.55,0.75,0.95,
-                                0.2,0.4,0.6,0.8,1.0]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomRightHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.833333333333333,0.666666666666667,0.5,0.333333333333333,
-                        0.916666666666667,0.75,0.583333333333333,0.416666666666667,0.25,
-                        0.833333333333333,0.666666666666667,0.5,0.333333333333333,0.166666666666667,
-                        0.75,0.583333333333333,0.416666666666667,0.25,0.0833333333333333,
-                        0.666666666666667,0.5,0.333333333333333,0.166666666666667,0.0]
-        let expectedReversed = [0.0,0.166666666666667,0.333333333333333,0.5,0.666666666666667,
-                                0.0833333333333334,0.25,0.416666666666667,0.583333333333333,0.75,
-                                0.166666666666667,0.333333333333333,0.5,0.666666666666667,0.833333333333333,
-                                0.25,0.416666666666667,0.583333333333333,0.75,0.916666666666667,
-                                0.333333333333333,0.5,0.666666666666667,0.833333333333333,1.0]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomRightHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
-        let expected = [1.0,0.875,0.75,0.625,0.5,
-                        0.875,0.75,0.625,0.5,0.375,
-                        0.75,0.625,0.5,0.375,0.25,
-                        0.625,0.5,0.375,0.25,0.125,
-                        0.5,0.375,0.25,0.125,0.0]
-        let expectedReversed = [0.0,0.125,0.25,0.375,0.5,
-                                0.125,0.25,0.375,0.5,0.625,
-                                0.25,0.375,0.5,0.625,0.75,
-                                0.375,0.5,0.625,0.75,0.875,
-                                0.5,0.625,0.75,0.875,1.0]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
-    }
-    
-    func testBottomRightCustomWeightsWeightedContinousSortFunction() {
-        let expected = [1.0,0.931159420289855,0.86231884057971,0.793478260869565,0.72463768115942,
-                        0.818840579710145,0.75,0.681159420289855,0.61231884057971,0.543478260869565,
-                        0.63768115942029,0.568840579710145,0.5,0.431159420289855,0.36231884057971,
-                        0.456521739130435,0.38768115942029,0.318840579710145,0.25,0.181159420289855,
-                        0.27536231884058,0.206521739130435,0.13768115942029,0.0688405797101449,0.0]
-        let expectedReversed = [0.0,0.068840579710145,0.13768115942029,0.206521739130435,0.27536231884058,
-                                0.181159420289855,0.25,0.318840579710145,0.38768115942029,0.456521739130435,
-                                0.36231884057971,0.431159420289855,0.5,0.568840579710145,0.63768115942029,
-                                0.543478260869565,0.61231884057971,0.681159420289855,0.75,0.818840579710145,
-                                0.72463768115942,0.793478260869565,0.86231884057971,0.931159420289855,1.0]
-        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
-    }
-}
-
diff --git a/Spruce/SpruceTests/Sort Function Tests/CorneredSortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/CorneredSortFunctionTests.swift
index a49e5ab..bdd33a4 100644
--- a/Spruce/SpruceTests/Sort Function Tests/CorneredSortFunctionTests.swift	
+++ b/Spruce/SpruceTests/Sort Function Tests/CorneredSortFunctionTests.swift	
@@ -31,78 +31,85 @@ class CorneredSortFunctionTests: SortFunctionTests {
     
     func testCorneredSortFunction(withCorner corner: Corner, expected: [Double], expectedReversed: [Double]) {
         var sortFunction = CorneredSortFunction(corner: corner)
-        let timedViews = sortFunction.timeOffsets(view: animatableView)
+        let weightedViews = sortFunction.weights(for: animatableView)
         
-        compare(timedViews: timedViews, toExpected: expected)
+        compare(weightedViews: weightedViews, toExpected: expected)
         
         sortFunction.reversed = true
-        let timedViewsReversed = sortFunction.timeOffsets(view: animatableView)
-        compare(timedViews: timedViewsReversed, toExpected: expectedReversed)
+        let weightedViewsReversed = sortFunction.weights(for: animatableView)
+        compare(weightedViews: weightedViewsReversed, toExpected: expectedReversed)
+        
+        print("")
+        print("let expected = ", terminator: "")
+        printWeightedViews(weightedViews)
+        print("let expectedReversed = ", terminator: "")
+        printWeightedViews(weightedViewsReversed)
+        print("")
     }
     
     func testCorneredSortFunctionWithEmptyView() {
-        let sortFunction = CorneredSortFunction(corner: .topLeft, interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: UIView())
+        let sortFunction = CorneredSortFunction(corner: .topLeft)
+        let timedViews = sortFunction.weights(for: UIView())
         
         XCTAssertEqual(timedViews.count, 0)
     }
     
     func testTopLeftCorneredSortFunction() {
-        let expected = [0.0,0.1,0.2,0.3,0.4,
-                        0.1,0.2,0.3,0.4,0.5,
-                        0.2,0.3,0.4,0.5,0.6,
-                        0.3,0.4,0.5,0.6,0.7,
-                        0.4,0.5,0.6,0.7,0.8]
-        let expectedReversed = [0.8,0.7,0.6,0.5,0.4,
-                                0.7,0.6,0.5,0.4,0.3,
-                                0.6,0.5,0.4,0.3,0.2,
-                                0.5,0.4,0.3,0.2,0.1,
-                                0.4,0.3,0.2,0.1,0.0]
+        let expected = [0.0,100.0,200.0,300.0,400.0,
+                        100.0,200.0,300.0,400.0,500.0,
+                        200.0,300.0,400.0,500.0,600.0,
+                        300.0,400.0,500.0,600.0,700.0,
+                        400.0,500.0,600.0,700.0,800.0]
+        let expectedReversed = [800.0,700.0,600.0,500.0,400.0,
+                                700.0,600.0,500.0,400.0,300.0,
+                                600.0,500.0,400.0,300.0,200.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                400.0,300.0,200.0,100.0,0.0]
         
         testCorneredSortFunction(withCorner: .topLeft, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testTopRightCorneredSortFunction() {
-        let expected = [0.4,0.3,0.2,0.1,0.0,
-                        0.5,0.4,0.3,0.2,0.1,
-                        0.6,0.5,0.4,0.3,0.2,
-                        0.7,0.6,0.5,0.4,0.3,
-                        0.8,0.7,0.6,0.5,0.4]
-        let expectedReversed = [0.4,0.5,0.6,0.7,0.8,
-                                0.3,0.4,0.5,0.6,0.7,
-                                0.2,0.3,0.4,0.5,0.6,
-                                0.1,0.2,0.3,0.4,0.5,
-                                0.0,0.1,0.2,0.3,0.4]
+        let expected = [400.0,300.0,200.0,100.0,0.0,
+                        500.0,400.0,300.0,200.0,100.0,
+                        600.0,500.0,400.0,300.0,200.0,
+                        700.0,600.0,500.0,400.0,300.0,
+                        800.0,700.0,600.0,500.0,400.0]
+        let expectedReversed = [400.0,500.0,600.0,700.0,800.0,
+                                300.0,400.0,500.0,600.0,700.0,
+                                200.0,300.0,400.0,500.0,600.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                0.0,100.0,200.0,300.0,400.0]
         
         testCorneredSortFunction(withCorner: .topRight, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testBottomLeftCorneredSortFunction() {
-        let expected = [0.4,0.5,0.6,0.7,0.8,
-                        0.3,0.4,0.5,0.6,0.7,
-                        0.2,0.3,0.4,0.5,0.6,
-                        0.1,0.2,0.3,0.4,0.5,
-                        0.0,0.1,0.2,0.3,0.4]
-        let expectedReversed = [0.4,0.3,0.2,0.1,0.0,
-                                0.5,0.4,0.3,0.2,0.1,
-                                0.6,0.5,0.4,0.3,0.2,
-                                0.7,0.6,0.5,0.4,0.3,
-                                0.8,0.7,0.6,0.5,0.4]
+        let expected = [400.0,500.0,600.0,700.0,800.0,
+                        300.0,400.0,500.0,600.0,700.0,
+                        200.0,300.0,400.0,500.0,600.0,
+                        100.0,200.0,300.0,400.0,500.0,
+                        0.0,100.0,200.0,300.0,400.0]
+        let expectedReversed = [400.0,300.0,200.0,100.0,0.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                600.0,500.0,400.0,300.0,200.0,
+                                700.0,600.0,500.0,400.0,300.0,
+                                800.0,700.0,600.0,500.0,400.0]
         
         testCorneredSortFunction(withCorner: .bottomLeft, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testBottomRightCorneredSortFunction() {
-        let expected = [0.8,0.7,0.6,0.5,0.4,
-                        0.7,0.6,0.5,0.4,0.3,
-                        0.6,0.5,0.4,0.3,0.2,
-                        0.5,0.4,0.3,0.2,0.1,
-                        0.4,0.3,0.2,0.1,0.0]
-        let expectedReversed = [0.0,0.1,0.2,0.3,0.4,
-                                0.1,0.2,0.3,0.4,0.5,
-                                0.2,0.3,0.4,0.5,0.6,
-                                0.3,0.4,0.5,0.6,0.7,
-                                0.4,0.5,0.6,0.7,0.8]
+        let expected = [800.0,700.0,600.0,500.0,400.0,
+                        700.0,600.0,500.0,400.0,300.0,
+                        600.0,500.0,400.0,300.0,200.0,
+                        500.0,400.0,300.0,200.0,100.0,
+                        400.0,300.0,200.0,100.0,0.0]
+        let expectedReversed = [0.0,100.0,200.0,300.0,400.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                200.0,300.0,400.0,500.0,600.0,
+                                300.0,400.0,500.0,600.0,700.0,
+                                400.0,500.0,600.0,700.0,800.0]
         
         testCorneredSortFunction(withCorner: .bottomRight, expected: expected, expectedReversed: expectedReversed)
     }
diff --git a/Spruce/SpruceTests/Sort Function Tests/DefaultSortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/DefaultSortFunctionTests.swift
index 5705ca9..b4faa5a 100644
--- a/Spruce/SpruceTests/Sort Function Tests/DefaultSortFunctionTests.swift	
+++ b/Spruce/SpruceTests/Sort Function Tests/DefaultSortFunctionTests.swift	
@@ -30,33 +30,21 @@ import XCTest
 class DefaultSortFunctionTests: SortFunctionTests {
     
     func testDefaultSortFunction() {
-        let sortFunction = DefaultSortFunction(interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: animatableView)
-        
-        let expected = [0.0,0.1,0.2,0.3,0.4,
-                        0.5,0.6,0.7,0.8,0.9,
-                        1.0,1.1,1.2,1.3,1.4,
-                        1.5,1.6,1.7,1.8,1.9,
-                        2.0,2.1,2.2,2.3,2.4]
-        compare(timedViews: timedViews, toExpected: expected)
-    }
-    
-    func testNoDelaySortFunction() {
         let sortFunction = DefaultSortFunction()
-        let timedViews = sortFunction.timeOffsets(view: animatableView)
+        let weightedViews = sortFunction.weights(for: animatableView)
         
-        let expected = [0.0,0.0,0.0,0.0,0.0,
-                        0.0,0.0,0.0,0.0,0.0,
-                        0.0,0.0,0.0,0.0,0.0,
-                        0.0,0.0,0.0,0.0,0.0,
-                        0.0,0.0,0.0,0.0,0.0]
-        compare(timedViews: timedViews, toExpected: expected)
+        let expected = [0.0,1.0,2.0,3.0,4.0,
+                        5.0,6.0,7.0,8.0,9.0,
+                        10.0,11.0,12.0,13.0,14.0,
+                        15.0,16.0,17.0,18.0,19.0,
+                        20.0,21.0,22.0,23.0,24.0]
+        compare(weightedViews: weightedViews, toExpected: expected)
     }
 
     func testDefaultSortFunctionWithEmptyView() {
         let sortFunction = DefaultSortFunction()
-        let timedViews = sortFunction.timeOffsets(view: UIView())
+        let weightedViews = sortFunction.weights(for: UIView())
         
-        XCTAssertEqual(timedViews.count, 0)
+        XCTAssertEqual(weightedViews.count, 0)
     }
 }
diff --git a/Spruce/SpruceTests/Sort Function Tests/InlineSortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/InlineSortFunctionTests.swift
index b3ca576..6b64b2b 100644
--- a/Spruce/SpruceTests/Sort Function Tests/InlineSortFunctionTests.swift	
+++ b/Spruce/SpruceTests/Sort Function Tests/InlineSortFunctionTests.swift	
@@ -30,76 +30,76 @@ import XCTest
 class InlineSortFunctionTests: SortFunctionTests {
     
     func testInlineSortFunctions(withStartCorner corner: Corner, expected: [TimeInterval], expectedReversed: [TimeInterval]) {
-        var sortFunction = InlineSortFunction(corner: corner, interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: animatableView)
+        var sortFunction = InlineSortFunction(corner: corner)
+        let weightedViews = sortFunction.weights(for: animatableView)
         
-        compare(timedViews: timedViews, toExpected: expected)
+        compare(weightedViews: weightedViews, toExpected: expected)
         
         sortFunction.reversed = true
-        let timedViewsReversed = sortFunction.timeOffsets(view: animatableView)
-        compare(timedViews: timedViewsReversed, toExpected: expectedReversed)
+        let weightedViewsReversed = sortFunction.weights(for: animatableView)
+        compare(weightedViews: weightedViewsReversed, toExpected: expectedReversed)
     }
     
     func testInlineSortFunctionWithEmptyView() {
-        let sortFunction = InlineSortFunction(corner: .topLeft, interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: UIView())
+        let sortFunction = InlineSortFunction(corner: .topLeft)
+        let timedViews = sortFunction.weights(for: UIView())
         
         XCTAssertEqual(timedViews.count, 0)
     }
     
     func testTopLeftInlineSortFunction() {
-        let expected = [0.0,0.1,0.2,0.3,0.4,
-                        0.5,0.6,0.7,0.8,0.9,
-                        1.0,1.1,1.2,1.3,1.4,
-                        1.5,1.6,1.7,1.8,1.9,
-                        2.0,2.1,2.2,2.3,2.4]
-        let expectedReversed = [2.4,2.3,2.2,2.1,2.0,
-                                1.9,1.8,1.7,1.6,1.5,
-                                1.4,1.3,1.2,1.1,1.0,
-                                0.9,0.8,0.7,0.6,0.5,
-                                0.4,0.3,0.2,0.1,0.0]
+        let expected = [0.0,1.0,2.0,3.0,4.0,
+                        5.0,6.0,7.0,8.0,9.0,
+                        10.0,11.0,12.0,13.0,14.0,
+                        15.0,16.0,17.0,18.0,19.0,
+                        20.0,21.0,22.0,23.0,24.0]
+        let expectedReversed = [24.0,23.0,22.0,21.0,20.0,
+                                19.0,18.0,17.0,16.0,15.0,
+                                14.0,13.0,12.0,11.0,10.0,
+                                9.0,8.0,7.0,6.0,5.0,
+                                4.0,3.0,2.0,1.0,0.0]
         testInlineSortFunctions(withStartCorner: .topLeft, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testTopRightInlineSortFunction() {
-        let expected = [0.4,0.3,0.2,0.1,0.0,
-                        0.9,0.8,0.7,0.6,0.5,
-                        1.4,1.3,1.2,1.1,1.0,
-                        1.9,1.8,1.7,1.6,1.5,
-                        2.4,2.3,2.2,2.1,2.0]
-        let expectedReversed = [2.0,2.1,2.2,2.3,2.4,
-                                1.5,1.6,1.7,1.8,1.9,
-                                1.0,1.1,1.2,1.3,1.4,
-                                0.5,0.6,0.7,0.8,0.9,
-                                0.0,0.1,0.2,0.3,0.4]
+        let expected = [4.0,3.0,2.0,1.0,0.0,
+                        9.0,8.0,7.0,6.0,5.0,
+                        14.0,13.0,12.0,11.0,10.0,
+                        19.0,18.0,17.0,16.0,15.0,
+                        24.0,23.0,22.0,21.0,20.0]
+        let expectedReversed = [20.0,21.0,22.0,23.0,24.0,
+                                15.0,16.0,17.0,18.0,19.0,
+                                10.0,11.0,12.0,13.0,14.0,
+                                5.0,6.0,7.0,8.0,9.0,
+                                0.0,1.0,2.0,3.0,4.0]
         testInlineSortFunctions(withStartCorner: .topRight, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testBottomLeftInlineSortFunction() {
-        let expected = [2.0,2.1,2.2,2.3,2.4,
-                        1.5,1.6,1.7,1.8,1.9,
-                        1.0,1.1,1.2,1.3,1.4,
-                        0.5,0.6,0.7,0.8,0.9,
-                        0.0,0.1,0.2,0.3,0.4]
-        let expectedReversed = [0.4,0.3,0.2,0.1,0.0,
-                                0.9,0.8,0.7,0.6,0.5,
-                                1.4,1.3,1.2,1.1,1.0,
-                                1.9,1.8,1.7,1.6,1.5,
-                                2.4,2.3,2.2,2.1,2.0]
+        let expected = [20.0,21.0,22.0,23.0,24.0,
+                        15.0,16.0,17.0,18.0,19.0,
+                        10.0,11.0,12.0,13.0,14.0,
+                        5.0,6.0,7.0,8.0,9.0,
+                        0.0,1.0,2.0,3.0,4.0]
+        let expectedReversed = [4.0,3.0,2.0,1.0,0.0,
+                                9.0,8.0,7.0,6.0,5.0,
+                                14.0,13.0,12.0,11.0,10.0,
+                                19.0,18.0,17.0,16.0,15.0,
+                                24.0,23.0,22.0,21.0,20.0]
         testInlineSortFunctions(withStartCorner: .bottomLeft, expected: expected, expectedReversed: expectedReversed)
     }
 
     func testBottomRightInlineSortFunction() {
-        let expected = [2.4,2.3,2.2,2.1,2.0,
-                        1.9,1.8,1.7,1.6,1.5,
-                        1.4,1.3,1.2,1.1,1.0,
-                        0.9,0.8,0.7,0.6,0.5,
-                        0.4,0.3,0.2,0.1,0.0]
-        let expectedReversed = [0.0,0.1,0.2,0.3,0.4,
-                                0.5,0.6,0.7,0.8,0.9,
-                                1.0,1.1,1.2,1.3,1.4,
-                                1.5,1.6,1.7,1.8,1.9,
-                                2.0,2.1,2.2,2.3,2.4]
+        let expected = [24.0,23.0,22.0,21.0,20.0,
+                        19.0,18.0,17.0,16.0,15.0,
+                        14.0,13.0,12.0,11.0,10.0,
+                        9.0,8.0,7.0,6.0,5.0,
+                        4.0,3.0,2.0,1.0,0.0]
+        let expectedReversed = [0.0,1.0,2.0,3.0,4.0,
+                                5.0,6.0,7.0,8.0,9.0,
+                                10.0,11.0,12.0,13.0,14.0,
+                                15.0,16.0,17.0,18.0,19.0,
+                                20.0,21.0,22.0,23.0,24.0]
         testInlineSortFunctions(withStartCorner: .bottomRight, expected: expected, expectedReversed: expectedReversed)
     }
 }
diff --git a/Spruce/SpruceTests/Sort Function Tests/LinearSortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/LinearSortFunctionTests.swift
index c70a0dd..980ff15 100644
--- a/Spruce/SpruceTests/Sort Function Tests/LinearSortFunctionTests.swift	
+++ b/Spruce/SpruceTests/Sort Function Tests/LinearSortFunctionTests.swift	
@@ -30,76 +30,83 @@ import XCTest
 class LinearSortFunctionTests: SortFunctionTests {
     
     func testLinearSortFunctions(withDirection direction: Direction, expected: [TimeInterval], expectedReversed: [TimeInterval]) {
-        var sortFunction = LinearSortFunction(direction: direction, interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: animatableView)
+        var sortFunction = LinearSortFunction(direction: direction)
+        let weightedViews = sortFunction.weights(for: animatableView)
         
-        compare(timedViews: timedViews, toExpected: expected)
+        compare(weightedViews: weightedViews, toExpected: expected)
         
         sortFunction.reversed = true
-        let timedViewsReversed = sortFunction.timeOffsets(view: animatableView)
-        compare(timedViews: timedViewsReversed, toExpected: expectedReversed)
+        let weightedViewsReversed = sortFunction.weights(for: animatableView)
+        compare(weightedViews: weightedViewsReversed, toExpected: expectedReversed)
+        
+        print("")
+        print("let expected = ", terminator: "")
+        printWeightedViews(weightedViews)
+        print("let expectedReversed = ", terminator: "")
+        printWeightedViews(weightedViewsReversed)
+        print("")
     }
     
     func testLinearSortFunctionWithEmptyView() {
-        let sortFunction = LinearSortFunction(direction: .topToBottom, interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: UIView())
+        let sortFunction = LinearSortFunction(direction: .topToBottom)
+        let timedViews = sortFunction.weights(for: UIView())
         
         XCTAssertEqual(timedViews.count, 0)
     }
     
     func testTopToBottomLinearSortFunction() {
-        let expected = [0.0,0.0,0.0,0.0,0.0,
-                        0.1,0.1,0.1,0.1,0.1,
-                        0.2,0.2,0.2,0.2,0.2,
-                        0.3,0.3,0.3,0.3,0.3,
-                        0.4,0.4,0.4,0.4,0.4]
-        let expectedReversed = [0.4,0.4,0.4,0.4,0.4,
-                                0.3,0.3,0.3,0.3,0.3,
-                                0.2,0.2,0.2,0.2,0.2,
-                                0.1,0.1,0.1,0.1,0.1,
+        let expected = [50.0,50.0,50.0,50.0,50.0,
+                        150.0,150.0,150.0,150.0,150.0,
+                        250.0,250.0,250.0,250.0,250.0,
+                        350.0,350.0,350.0,350.0,350.0,
+                        450.0,450.0,450.0,450.0,450.0]
+        let expectedReversed = [400.0,400.0,400.0,400.0,400.0,
+                                300.0,300.0,300.0,300.0,300.0,
+                                200.0,200.0,200.0,200.0,200.0,
+                                100.0,100.0,100.0,100.0,100.0,
                                 0.0,0.0,0.0,0.0,0.0]
         testLinearSortFunctions(withDirection: .topToBottom, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testBottomToTopLinearSortFunction() {
-        let expected = [0.4,0.4,0.4,0.4,0.4,
-                        0.3,0.3,0.3,0.3,0.3,
-                        0.2,0.2,0.2,0.2,0.2,
-                        0.1,0.1,0.1,0.1,0.1,
-                        0.0,0.0,0.0,0.0,0.0]
+        let expected = [450.0,450.0,450.0,450.0,450.0,
+                        350.0,350.0,350.0,350.0,350.0,
+                        250.0,250.0,250.0,250.0,250.0,
+                        150.0,150.0,150.0,150.0,150.0,
+                        50.0,50.0,50.0,50.0,50.0]
         let expectedReversed = [0.0,0.0,0.0,0.0,0.0,
-                                0.1,0.1,0.1,0.1,0.1,
-                                0.2,0.2,0.2,0.2,0.2,
-                                0.3,0.3,0.3,0.3,0.3,
-                                0.4,0.4,0.4,0.4,0.4]
+                                100.0,100.0,100.0,100.0,100.0,
+                                200.0,200.0,200.0,200.0,200.0,
+                                300.0,300.0,300.0,300.0,300.0,
+                                400.0,400.0,400.0,400.0,400.0]
         testLinearSortFunctions(withDirection: .bottomToTop, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testLeftToRightLinearSortFunction() {
-        let expected = [0.0,0.1,0.2,0.3,0.4,
-                        0.0,0.1,0.2,0.3,0.4,
-                        0.0,0.1,0.2,0.3,0.4,
-                        0.0,0.1,0.2,0.3,0.4,
-                        0.0,0.1,0.2,0.3,0.4]
-        let expectedReversed = [0.4,0.3,0.2,0.1,0.0,
-                                0.4,0.3,0.2,0.1,0.0,
-                                0.4,0.3,0.2,0.1,0.0,
-                                0.4,0.3,0.2,0.1,0.0,
-                                0.4,0.3,0.2,0.1,0.0]
+        let expected = [50.0,150.0,250.0,350.0,450.0,
+                        50.0,150.0,250.0,350.0,450.0,
+                        50.0,150.0,250.0,350.0,450.0,
+                        50.0,150.0,250.0,350.0,450.0,
+                        50.0,150.0,250.0,350.0,450.0]
+        let expectedReversed = [400.0,300.0,200.0,100.0,0.0,
+                                400.0,300.0,200.0,100.0,0.0,
+                                400.0,300.0,200.0,100.0,0.0,
+                                400.0,300.0,200.0,100.0,0.0,
+                                400.0,300.0,200.0,100.0,0.0]
         testLinearSortFunctions(withDirection: .leftToRight, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testRightToLeftLinearSortFunction() {
-        let expected = [0.4,0.3,0.2,0.1,0.0,
-                        0.4,0.3,0.2,0.1,0.0,
-                        0.4,0.3,0.2,0.1,0.0,
-                        0.4,0.3,0.2,0.1,0.0,
-                        0.4,0.3,0.2,0.1,0.0]
-        let expectedReversed = [0.0,0.1,0.2,0.3,0.4,
-                                0.0,0.1,0.2,0.3,0.4,
-                                0.0,0.1,0.2,0.3,0.4,
-                                0.0,0.1,0.2,0.3,0.4,
-                                0.0,0.1,0.2,0.3,0.4]
+        let expected = [450.0,350.0,250.0,150.0,50.0,
+                        450.0,350.0,250.0,150.0,50.0,
+                        450.0,350.0,250.0,150.0,50.0,
+                        450.0,350.0,250.0,150.0,50.0,
+                        450.0,350.0,250.0,150.0,50.0]
+        let expectedReversed = [0.0,100.0,200.0,300.0,400.0,
+                                0.0,100.0,200.0,300.0,400.0,
+                                0.0,100.0,200.0,300.0,400.0,
+                                0.0,100.0,200.0,300.0,400.0,
+                                0.0,100.0,200.0,300.0,400.0]
         testLinearSortFunctions(withDirection: .rightToLeft, expected: expected, expectedReversed: expectedReversed)
     }
 }
diff --git a/Spruce/SpruceTests/Sort Function Tests/RadialSortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/RadialSortFunctionTests.swift
index 04152a1..c7a1694 100644
--- a/Spruce/SpruceTests/Sort Function Tests/RadialSortFunctionTests.swift	
+++ b/Spruce/SpruceTests/Sort Function Tests/RadialSortFunctionTests.swift	
@@ -29,146 +29,153 @@ import XCTest
 class RadialSortFunctionTests: SortFunctionTests {
     
     func testRadialSortFunction(withPosition position: Position, expected: [TimeInterval], expectedReversed: [TimeInterval]) {
-        var sortFunction = RadialSortFunction(position: position, interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: animatableView)
+        var sortFunction = RadialSortFunction(position: position)
+        let weightedViews = sortFunction.weights(for: animatableView)
         
-        compare(timedViews: timedViews, toExpected: expected)
+        compare(weightedViews: weightedViews, toExpected: expected)
         
         sortFunction.reversed = true
-        let timedViewsReversed = sortFunction.timeOffsets(view: animatableView)
-        compare(timedViews: timedViewsReversed, toExpected: expectedReversed)
+        let weightedViewsReversed = sortFunction.weights(for: animatableView)
+        compare(weightedViews: weightedViewsReversed, toExpected: expectedReversed)
+        
+        print("")
+        print("let expected = ", terminator: "")
+        printWeightedViews(weightedViews)
+        print("let expectedReversed = ", terminator: "")
+        printWeightedViews(weightedViewsReversed)
+        print("")
     }
     
     func testRadialSortFunctionWithEmptyView() {
-        let sortFunction = RadialSortFunction(position: .topLeft, interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: UIView())
+        let sortFunction = RadialSortFunction(position: .topLeft)
+        let timedViews = sortFunction.weights(for: UIView())
         
         XCTAssertEqual(timedViews.count, 0)
     }
     
     func testTopLeftRadialSortFunction() {
-        let expected = [0.0,0.1,0.3,0.6,0.9,
-                        0.1,0.2,0.4,0.7,1.0,
-                        0.3,0.4,0.5,0.8,1.2,
-                        0.6,0.7,0.8,1.1,1.3,
-                        0.9,1.0,1.2,1.3,1.4]
-        let expectedReversed = [1.4,1.3,1.1,0.8,0.5,
-                                1.3,1.2,1.0,0.7,0.4,
-                                1.1,1.0,0.9,0.6,0.2,
-                                0.8,0.7,0.6,0.3,0.1,
-                                0.5,0.4,0.2,0.1,0.0]
+        let expected = [0.0,100.0,200.0,300.0,400.0,
+                        100.0,141.42135623731,223.606797749979,316.227766016838,412.310562561766,
+                        200.0,223.606797749979,282.842712474619,360.555127546399,447.213595499958,
+                        300.0,316.227766016838,360.555127546399,424.264068711929,500.0,
+                        400.0,412.310562561766,447.213595499958,500.0,565.685424949238]
+        let expectedReversed = [565.685424949238,465.685424949238,365.685424949238,265.685424949238,165.685424949238,
+                                465.685424949238,424.264068711929,342.078627199259,249.4576589324,153.374862387472,
+                                365.685424949238,342.078627199259,282.842712474619,205.130297402839,118.47182944928,
+                                265.685424949238,249.4576589324,205.130297402839,141.42135623731,65.685424949238,
+                                165.685424949238,153.374862387472,118.47182944928,65.685424949238,0.0]
         testRadialSortFunction(withPosition: .topLeft, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testTopMiddleRadialSortFunction() {
-        let expected = [0.3,0.1,0.0,0.1,0.3,
-                        0.4,0.2,0.1,0.2,0.4,
-                        0.5,0.4,0.3,0.4,0.5,
-                        0.8,0.7,0.6,0.7,0.8,
-                        1.1,1.0,0.9,1.0,1.1]
-        let expectedReversed = [0.8,1.0,1.1,1.0,0.8,
-                                0.7,0.9,1.0,0.9,0.7,
-                                0.6,0.7,0.8,0.7,0.6,
-                                0.3,0.4,0.5,0.4,0.3,
-                                0.0,0.1,0.2,0.1,0.0]
+        let expected = [200.0,100.0,0.0,100.0,200.0,
+                        223.606797749979,141.42135623731,100.0,141.42135623731,223.606797749979,
+                        282.842712474619,223.606797749979,200.0,223.606797749979,282.842712474619,
+                        360.555127546399,316.227766016838,300.0,316.227766016838,360.555127546399,
+                        447.213595499958,412.310562561766,400.0,412.310562561766,447.213595499958]
+        let expectedReversed = [247.213595499958,347.213595499958,447.213595499958,347.213595499958,247.213595499958,
+                                223.606797749979,305.792239262648,347.213595499958,305.792239262648,223.606797749979,
+                                164.370883025339,223.606797749979,247.213595499958,223.606797749979,164.370883025339,
+                                86.658467953559,130.98582948312,147.213595499958,130.98582948312,86.658467953559,
+                                0.0,34.9030329381919,47.2135954999579,34.9030329381919,0.0]
         testRadialSortFunction(withPosition: .topMiddle, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testTopRightRadialSortFunction() {
-        let expected = [0.9,0.6,0.3,0.1,0.0,
-                        1.0,0.7,0.4,0.2,0.1,
-                        1.2,0.8,0.5,0.4,0.3,
-                        1.3,1.1,0.8,0.7,0.6,
-                        1.4,1.3,1.2,1.0,0.9]
-        let expectedReversed = [0.5,0.8,1.1,1.3,1.4,
-                                0.4,0.7,1.0,1.2,1.3,
-                                0.2,0.6,0.9,1.0,1.1,
-                                0.1,0.3,0.6,0.7,0.8,
-                                0.0,0.1,0.2,0.4,0.5]
+        let expected = [400.0,300.0,200.0,100.0,0.0,
+                        412.310562561766,316.227766016838,223.606797749979,141.42135623731,100.0,
+                        447.213595499958,360.555127546399,282.842712474619,223.606797749979,200.0,
+                        500.0,424.264068711929,360.555127546399,316.227766016838,300.0,
+                        565.685424949238,500.0,447.213595499958,412.310562561766,400.0]
+        let expectedReversed = [165.685424949238,265.685424949238,365.685424949238,465.685424949238,565.685424949238,
+                                153.374862387472,249.4576589324,342.078627199259,424.264068711929,465.685424949238,
+                                118.47182944928,205.130297402839,282.842712474619,342.078627199259,365.685424949238,
+                                65.685424949238,141.42135623731,205.130297402839,249.4576589324,265.685424949238,
+                                0.0,65.685424949238,118.47182944928,153.374862387472,165.685424949238]
         testRadialSortFunction(withPosition: .topRight, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testLeftRadialSortFunction() {
-        let expected = [0.3,0.4,0.5,0.8,1.1,
-                        0.1,0.2,0.4,0.7,1.0,
-                        0.0,0.1,0.3,0.6,0.9,
-                        0.1,0.2,0.4,0.7,1.0,
-                        0.3,0.4,0.5,0.8,1.1]
-        let expectedReversed = [0.8,0.7,0.6,0.3,0.0,
-                                1.0,0.9,0.7,0.4,0.1,
-                                1.1,1.0,0.8,0.5,0.2,
-                                1.0,0.9,0.7,0.4,0.1,
-                                0.8,0.7,0.6,0.3,0.0]
+        let expected = [200.0,223.606797749979,282.842712474619,360.555127546399,447.213595499958,
+                        100.0,141.42135623731,223.606797749979,316.227766016838,412.310562561766,
+                        0.0,100.0,200.0,300.0,400.0,
+                        100.0,141.42135623731,223.606797749979,316.227766016838,412.310562561766,
+                        200.0,223.606797749979,282.842712474619,360.555127546399,447.213595499958]
+        let expectedReversed = [247.213595499958,223.606797749979,164.370883025339,86.658467953559,0.0,
+                                347.213595499958,305.792239262648,223.606797749979,130.98582948312,34.9030329381919,
+                                447.213595499958,347.213595499958,247.213595499958,147.213595499958,47.2135954999579,
+                                347.213595499958,305.792239262648,223.606797749979,130.98582948312,34.9030329381919,
+                                247.213595499958,223.606797749979,164.370883025339,86.658467953559,0.0]
         testRadialSortFunction(withPosition: .left, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testMiddleRadialSortFunction() {
-        let expected = [0.5,0.4,0.3,0.4,0.5,
-                        0.4,0.2,0.1,0.2,0.4,
-                        0.3,0.1,0.0,0.1,0.3,
-                        0.4,0.2,0.1,0.2,0.4,
-                        0.5,0.4,0.3,0.4,0.5]
-        let expectedReversed = [0.0,0.1,0.2,0.1,0.0,
-                                0.1,0.3,0.4,0.3,0.1,
-                                0.2,0.4,0.5,0.4,0.2,
-                                0.1,0.3,0.4,0.3,0.1,
-                                0.0,0.1,0.2,0.1,0.0]
+        let expected = [282.842712474619,223.606797749979,200.0,223.606797749979,282.842712474619,
+                        223.606797749979,141.42135623731,100.0,141.42135623731,223.606797749979,
+                        200.0,100.0,0.0,100.0,200.0,
+                        223.606797749979,141.42135623731,100.0,141.42135623731,223.606797749979,
+                        282.842712474619,223.606797749979,200.0,223.606797749979,282.842712474619]
+        let expectedReversed = [0.0,59.2359147246401,82.842712474619,59.2359147246401,0.0,
+                                59.2359147246401,141.42135623731,182.842712474619,141.42135623731,59.2359147246401,
+                                82.842712474619,182.842712474619,282.842712474619,182.842712474619,82.842712474619,
+                                59.2359147246401,141.42135623731,182.842712474619,141.42135623731,59.2359147246401,
+                                0.0,59.2359147246401,82.842712474619,59.2359147246401,0.0]
         testRadialSortFunction(withPosition: .middle, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testRightRadialSortFunction() {
-        let expected = [1.1,0.8,0.5,0.4,0.3,
-                        1.0,0.7,0.4,0.2,0.1,
-                        0.9,0.6,0.3,0.1,0.0,
-                        1.0,0.7,0.4,0.2,0.1,
-                        1.1,0.8,0.5,0.4,0.3]
-        let expectedReversed = [0.0,0.3,0.6,0.7,0.8,
-                                0.1,0.4,0.7,0.9,1.0,
-                                0.2,0.5,0.8,1.0,1.1,
-                                0.1,0.4,0.7,0.9,1.0,
-                                0.0,0.3,0.6,0.7,0.8]
+        let expected = [447.213595499958,360.555127546399,282.842712474619,223.606797749979,200.0,
+                        412.310562561766,316.227766016838,223.606797749979,141.42135623731,100.0,
+                        400.0,300.0,200.0,100.0,0.0,
+                        412.310562561766,316.227766016838,223.606797749979,141.42135623731,100.0,
+                        447.213595499958,360.555127546399,282.842712474619,223.606797749979,200.0]
+        let expectedReversed = [0.0,86.658467953559,164.370883025339,223.606797749979,247.213595499958,
+                                34.9030329381919,130.98582948312,223.606797749979,305.792239262648,347.213595499958,
+                                47.2135954999579,147.213595499958,247.213595499958,347.213595499958,447.213595499958,
+                                34.9030329381919,130.98582948312,223.606797749979,305.792239262648,347.213595499958,
+                                0.0,86.658467953559,164.370883025339,223.606797749979,247.213595499958]
         testRadialSortFunction(withPosition: .right, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testBottomLeftRadialSortFunction() {
-        let expected = [0.9,1.0,1.2,1.3,1.4,
-                        0.6,0.7,0.8,1.1,1.3,
-                        0.3,0.4,0.5,0.8,1.2,
-                        0.1,0.2,0.4,0.7,1.0,
-                        0.0,0.1,0.3,0.6,0.9]
-        let expectedReversed = [0.5,0.4,0.2,0.1,0.0,
-                                0.8,0.7,0.6,0.3,0.1,
-                                1.1,1.0,0.9,0.6,0.2,
-                                1.3,1.2,1.0,0.7,0.4,
-                                1.4,1.3,1.1,0.8,0.5]
+        let expected = [400.0,412.310562561766,447.213595499958,500.0,565.685424949238,
+                        300.0,316.227766016838,360.555127546399,424.264068711929,500.0,
+                        200.0,223.606797749979,282.842712474619,360.555127546399,447.213595499958,
+                        100.0,141.42135623731,223.606797749979,316.227766016838,412.310562561766,
+                        0.0,100.0,200.0,300.0,400.0]
+        let expectedReversed = [165.685424949238,153.374862387472,118.47182944928,65.685424949238,0.0,
+                                265.685424949238,249.4576589324,205.130297402839,141.42135623731,65.685424949238,
+                                365.685424949238,342.078627199259,282.842712474619,205.130297402839,118.47182944928,
+                                465.685424949238,424.264068711929,342.078627199259,249.4576589324,153.374862387472,
+                                565.685424949238,465.685424949238,365.685424949238,265.685424949238,165.685424949238]
         testRadialSortFunction(withPosition: .bottomLeft, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testBottomMiddleRadialSortFunction() {
-        let expected = [1.1,1.0,0.9,1.0,1.1,
-                        0.8,0.7,0.6,0.7,0.8,
-                        0.5,0.4,0.3,0.4,0.5,
-                        0.4,0.2,0.1,0.2,0.4,
-                        0.3,0.1,0.0,0.1,0.3]
-        let expectedReversed = [0.0,0.1,0.2,0.1,0.0,
-                                0.3,0.4,0.5,0.4,0.3,
-                                0.6,0.7,0.8,0.7,0.6,
-                                0.7,0.9,1.0,0.9,0.7,
-                                0.8,1.0,1.1,1.0,0.8]
+        let expected = [447.213595499958,412.310562561766,400.0,412.310562561766,447.213595499958,
+                        360.555127546399,316.227766016838,300.0,316.227766016838,360.555127546399,
+                        282.842712474619,223.606797749979,200.0,223.606797749979,282.842712474619,
+                        223.606797749979,141.42135623731,100.0,141.42135623731,223.606797749979,
+                        200.0,100.0,0.0,100.0,200.0]
+        let expectedReversed = [0.0,34.9030329381919,47.2135954999579,34.9030329381919,0.0,
+                                86.658467953559,130.98582948312,147.213595499958,130.98582948312,86.658467953559,
+                                164.370883025339,223.606797749979,247.213595499958,223.606797749979,164.370883025339,
+                                223.606797749979,305.792239262648,347.213595499958,305.792239262648,223.606797749979,
+                                247.213595499958,347.213595499958,447.213595499958,347.213595499958,247.213595499958]
         testRadialSortFunction(withPosition: .bottomMiddle, expected: expected, expectedReversed: expectedReversed)
     }
     
     func testBottomRightRadialSortFunction() {
-        let expected = [1.4,1.3,1.2,1.0,0.9,
-                        1.3,1.1,0.8,0.7,0.6,
-                        1.2,0.8,0.5,0.4,0.3,
-                        1.0,0.7,0.4,0.2,0.1,
-                        0.9,0.6,0.3,0.1,0.0]
-        let expectedReversed = [0.0,0.1,0.2,0.4,0.5,
-                                0.1,0.3,0.6,0.7,0.8,
-                                0.2,0.6,0.9,1.0,1.1,
-                                0.4,0.7,1.0,1.2,1.3,
-                                0.5,0.8,1.1,1.3,1.4]
+        let expected = [565.685424949238,500.0,447.213595499958,412.310562561766,400.0,
+                        500.0,424.264068711929,360.555127546399,316.227766016838,300.0,
+                        447.213595499958,360.555127546399,282.842712474619,223.606797749979,200.0,
+                        412.310562561766,316.227766016838,223.606797749979,141.42135623731,100.0,
+                        400.0,300.0,200.0,100.0,0.0]
+        let expectedReversed = [0.0,65.685424949238,118.47182944928,153.374862387472,165.685424949238,
+                                65.685424949238,141.42135623731,205.130297402839,249.4576589324,265.685424949238,
+                                118.47182944928,205.130297402839,282.842712474619,342.078627199259,365.685424949238,
+                                153.374862387472,249.4576589324,342.078627199259,424.264068711929,465.685424949238,
+                                165.685424949238,265.685424949238,365.685424949238,465.685424949238,565.685424949238]
         testRadialSortFunction(withPosition: .bottomRight, expected: expected, expectedReversed: expectedReversed)
     }
 }
diff --git a/Spruce/SpruceTests/Sort Function Tests/RandomSortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/RandomSortFunctionTests.swift
index 683b86d..17acbc1 100644
--- a/Spruce/SpruceTests/Sort Function Tests/RandomSortFunctionTests.swift	
+++ b/Spruce/SpruceTests/Sort Function Tests/RandomSortFunctionTests.swift	
@@ -12,15 +12,15 @@ import XCTest
 class RandomSortFunctionTests: SortFunctionTests {
     
     func testRandomSortFunction() {
-        let sortFunction = RandomSortFunction(interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: animatableView)
+        let sortFunction = RandomSortFunction()
+        let timedViews = sortFunction.weights(for: animatableView)
         
         XCTAssertEqual(timedViews.count, 25)
     }
     
     func testRandomSortFunctionWithEmptyView() {
-        let sortFunction = RandomSortFunction(interObjectDelay: 0.1)
-        let timedViews = sortFunction.timeOffsets(view: UIView())
+        let sortFunction = RandomSortFunction()
+        let timedViews = sortFunction.weights(for: UIView())
         
         XCTAssertEqual(timedViews.count, 0)
     }
diff --git a/Spruce/SpruceTests/Sort Function Tests/SortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/SortFunctionTests.swift
index 17fdede..e5f43cc 100644
--- a/Spruce/SpruceTests/Sort Function Tests/SortFunctionTests.swift	
+++ b/Spruce/SpruceTests/Sort Function Tests/SortFunctionTests.swift	
@@ -65,26 +65,26 @@ class SortFunctionTests: XCTestCase {
         XCTAssertEqual(animatableView.subviews.count, squaresPerRow * squaresPerRow)
     }
     
-    func compare(timedViews: [Double], toExpected expected: [TimeInterval]) {
-        XCTAssertEqual(timedViews.count, expected.count)
+    func compare(weightedViews: [WeightedView], toExpected expected: [Double]) {
+        XCTAssertEqual(weightedViews.count, expected.count)
         
-        guard timedViews.count == expected.count else {
+        guard weightedViews.count == expected.count else {
             XCTFail("TimedViews not equal to expected")
             return
         }
         
-        for timedView in timedViews {
-            guard let index = timedView.spruceView.view?.tag else {
+        for weightedView in weightedViews {
+            guard let index = weightedView.spruceView.view?.tag else {
                 XCTFail("Failed to find UIView Object")
                 continue
             }
-            let expectedDelay = expected[index]
-            XCTAssertEqualWithAccuracy(timedView.timeOffset, expectedDelay, accuracy: 0.000001)
+            let expectedWeight = expected[index]
+            XCTAssertEqualWithAccuracy(weightedView.weight, expectedWeight, accuracy: 0.000001)
         }
     }
     
-    func printTimedViews(_ timedViews: [Double]) {
-        let timedViews = timedViews.sorted { (left, right) -> Bool in
+    func printWeightedViews(_ weightedViews: [WeightedView]) {
+        let weightedViews = weightedViews.sorted { (left, right) -> Bool in
             guard let leftTag = left.spruceView.view?.tag,
                 let rightTag = right.spruceView.view?.tag else {
                 XCTFail("Failed to find UIView Object")
@@ -93,12 +93,12 @@ class SortFunctionTests: XCTestCase {
             return leftTag < rightTag
         }
         print("[", terminator: "")
-        for index in 0..<timedViews.count {
-            if index == timedViews.count - 1 {
-                print("\(timedViews[index].timeOffset)]", terminator: "")
+        for index in 0..<weightedViews.count {
+            if index == weightedViews.count - 1 {
+                print("\(weightedViews[index].weight)]", terminator: "")
             }
             else {
-                print("\(timedViews[index].timeOffset),", terminator: "")
+                print("\(weightedViews[index].weight),", terminator: "")
             }
             
             if index % 5 == 4 {
diff --git a/Spruce/SpruceTests/Sort Function Tests/WeightedSortFunctionTests.swift b/Spruce/SpruceTests/Sort Function Tests/WeightedSortFunctionTests.swift
new file mode 100644
index 0000000..ad4c171
--- /dev/null
+++ b/Spruce/SpruceTests/Sort Function Tests/WeightedSortFunctionTests.swift	
@@ -0,0 +1,1065 @@
+//
+//  WeightedSortFunctionTests.swift
+//  Spruce
+//
+//  Copyright (c) 2017 WillowTree, Inc.
+
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+
+
+import XCTest
+@testable import Spruce
+
+class WeightedSortFunctionTests: SortFunctionTests {
+    
+    func testContinuousWeightedSortFunction(withStartPosition position: Position, horizontalWeight: Weight, verticalWeight: Weight, expected: [TimeInterval], expectedReversed: [TimeInterval]) {
+        var sortFunction = WeightedSortFunction(position: position, horizontalWeight: horizontalWeight, verticalWeight: verticalWeight)
+        let weightedViews = sortFunction.weights(for: animatableView)
+        
+        compare(weightedViews: weightedViews, toExpected: expected)
+        
+        sortFunction.reversed = true
+        let weightedViewsReversed = sortFunction.weights(for: animatableView)
+        compare(weightedViews: weightedViewsReversed, toExpected: expectedReversed)
+        
+        print("")
+        print("let expected = ", terminator: "")
+        printWeightedViews(weightedViews)
+        print("let expectedReversed = ", terminator: "")
+        printWeightedViews(weightedViewsReversed)
+        print("")
+    }
+    
+    func testContinuousWeightedSortFunctionWithEmptyView() {
+        let sortFunction = WeightedSortFunction(position: .topLeft)
+        let timedViews = sortFunction.weights(for: UIView())
+        
+        XCTAssertEqual(timedViews.count, 0)
+    }
+    
+    func testTopLeftLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [0.0,50.0,100.0,150.0,200.0,
+                        50.0,100.0,150.0,200.0,250.0,
+                        100.0,150.0,200.0,250.0,300.0,
+                        150.0,200.0,250.0,300.0,350.0,
+                        200.0,250.0,300.0,350.0,400.0]
+        let expectedReversed = [400.0,350.0,300.0,250.0,200.0,
+                                350.0,300.0,250.0,200.0,150.0,
+                                300.0,250.0,200.0,150.0,100.0,
+                                250.0,200.0,150.0,100.0,50.0,
+                                200.0,150.0,100.0,50.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopLeftLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [0.0,50.0,100.0,150.0,200.0,
+                        100.0,150.0,200.0,250.0,300.0,
+                        200.0,250.0,300.0,350.0,400.0,
+                        300.0,350.0,400.0,450.0,500.0,
+                        400.0,450.0,500.0,550.0,600.0]
+        let expectedReversed = [600.0,550.0,500.0,450.0,400.0,
+                                500.0,450.0,400.0,350.0,300.0,
+                                400.0,350.0,300.0,250.0,200.0,
+                                300.0,250.0,200.0,150.0,100.0,
+                                200.0,150.0,100.0,50.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopLeftMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [0.0,100.0,200.0,300.0,400.0,
+                        50.0,150.0,250.0,350.0,450.0,
+                        100.0,200.0,300.0,400.0,500.0,
+                        150.0,250.0,350.0,450.0,550.0,
+                        200.0,300.0,400.0,500.0,600.0]
+        let expectedReversed = [600.0,500.0,400.0,300.0,200.0,
+                                550.0,450.0,350.0,250.0,150.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                450.0,350.0,250.0,150.0,50.0,
+                                400.0,300.0,200.0,100.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopLeftMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [0.0,100.0,200.0,300.0,400.0,
+                        100.0,200.0,300.0,400.0,500.0,
+                        200.0,300.0,400.0,500.0,600.0,
+                        300.0,400.0,500.0,600.0,700.0,
+                        400.0,500.0,600.0,700.0,800.0]
+        let expectedReversed = [800.0,700.0,600.0,500.0,400.0,
+                                700.0,600.0,500.0,400.0,300.0,
+                                600.0,500.0,400.0,300.0,200.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                400.0,300.0,200.0,100.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopLeftHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [0.0,200.0,400.0,600.0,800.0,
+                        50.0,250.0,450.0,650.0,850.0,
+                        100.0,300.0,500.0,700.0,900.0,
+                        150.0,350.0,550.0,750.0,950.0,
+                        200.0,400.0,600.0,800.0,1000.0]
+        let expectedReversed = [1000.0,800.0,600.0,400.0,200.0,
+                                950.0,750.0,550.0,350.0,150.0,
+                                900.0,700.0,500.0,300.0,100.0,
+                                850.0,650.0,450.0,250.0,50.0,
+                                800.0,600.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopLeftHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [0.0,200.0,400.0,600.0,800.0,
+                        100.0,300.0,500.0,700.0,900.0,
+                        200.0,400.0,600.0,800.0,1000.0,
+                        300.0,500.0,700.0,900.0,1100.0,
+                        400.0,600.0,800.0,1000.0,1200.0]
+        let expectedReversed = [1200.0,1000.0,800.0,600.0,400.0,
+                                1100.0,900.0,700.0,500.0,300.0,
+                                1000.0,800.0,600.0,400.0,200.0,
+                                900.0,700.0,500.0,300.0,100.0,
+                                800.0,600.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopLeftHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [0.0,200.0,400.0,600.0,800.0,
+                        200.0,400.0,600.0,800.0,1000.0,
+                        400.0,600.0,800.0,1000.0,1200.0,
+                        600.0,800.0,1000.0,1200.0,1400.0,
+                        800.0,1000.0,1200.0,1400.0,1600.0]
+        let expectedReversed = [1600.0,1400.0,1200.0,1000.0,800.0,
+                                1400.0,1200.0,1000.0,800.0,600.0,
+                                1200.0,1000.0,800.0,600.0,400.0,
+                                1000.0,800.0,600.0,400.0,200.0,
+                                800.0,600.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopLeftCustomWeightsWeightedContinousSortFunction() {
+        let expected = [0.0,190.0,380.0,570.0,760.0,
+                        500.0,690.0,880.0,1070.0,1260.0,
+                        1000.0,1190.0,1380.0,1570.0,1760.0,
+                        1500.0,1690.0,1880.0,2070.0,2260.0,
+                        2000.0,2190.0,2380.0,2570.0,2760.0]
+        let expectedReversed = [2760.0,2570.0,2380.0,2190.0,2000.0,
+                                2260.0,2070.0,1880.0,1690.0,1500.0,
+                                1760.0,1570.0,1380.0,1190.0,1000.0,
+                                1260.0,1070.0,880.0,690.0,500.0,
+                                760.0,570.0,380.0,190.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topLeft, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopMiddleLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [100.0,50.0,0.0,50.0,100.0,
+                        150.0,100.0,50.0,100.0,150.0,
+                        200.0,150.0,100.0,150.0,200.0,
+                        250.0,200.0,150.0,200.0,250.0,
+                        300.0,250.0,200.0,250.0,300.0]
+        let expectedReversed = [200.0,250.0,300.0,250.0,200.0,
+                                150.0,200.0,250.0,200.0,150.0,
+                                100.0,150.0,200.0,150.0,100.0,
+                                50.0,100.0,150.0,100.0,50.0,
+                                0.0,50.0,100.0,50.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopMiddleLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [100.0,50.0,0.0,50.0,100.0,
+                        200.0,150.0,100.0,150.0,200.0,
+                        300.0,250.0,200.0,250.0,300.0,
+                        400.0,350.0,300.0,350.0,400.0,
+                        500.0,450.0,400.0,450.0,500.0]
+        let expectedReversed = [400.0,450.0,500.0,450.0,400.0,
+                                300.0,350.0,400.0,350.0,300.0,
+                                200.0,250.0,300.0,250.0,200.0,
+                                100.0,150.0,200.0,150.0,100.0,
+                                0.0,50.0,100.0,50.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopMiddleMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,100.0,0.0,100.0,200.0,
+                        250.0,150.0,50.0,150.0,250.0,
+                        300.0,200.0,100.0,200.0,300.0,
+                        350.0,250.0,150.0,250.0,350.0,
+                        400.0,300.0,200.0,300.0,400.0]
+        let expectedReversed = [200.0,300.0,400.0,300.0,200.0,
+                                150.0,250.0,350.0,250.0,150.0,
+                                100.0,200.0,300.0,200.0,100.0,
+                                50.0,150.0,250.0,150.0,50.0,
+                                0.0,100.0,200.0,100.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopMiddleMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,100.0,0.0,100.0,200.0,
+                        300.0,200.0,100.0,200.0,300.0,
+                        400.0,300.0,200.0,300.0,400.0,
+                        500.0,400.0,300.0,400.0,500.0,
+                        600.0,500.0,400.0,500.0,600.0]
+        let expectedReversed = [400.0,500.0,600.0,500.0,400.0,
+                                300.0,400.0,500.0,400.0,300.0,
+                                200.0,300.0,400.0,300.0,200.0,
+                                100.0,200.0,300.0,200.0,100.0,
+                                0.0,100.0,200.0,100.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopMiddleHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,200.0,0.0,200.0,400.0,
+                        450.0,250.0,50.0,250.0,450.0,
+                        500.0,300.0,100.0,300.0,500.0,
+                        550.0,350.0,150.0,350.0,550.0,
+                        600.0,400.0,200.0,400.0,600.0]
+        let expectedReversed = [200.0,400.0,600.0,400.0,200.0,
+                                150.0,350.0,550.0,350.0,150.0,
+                                100.0,300.0,500.0,300.0,100.0,
+                                50.0,250.0,450.0,250.0,50.0,
+                                0.0,200.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopMiddleHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,200.0,0.0,200.0,400.0,
+                        500.0,300.0,100.0,300.0,500.0,
+                        600.0,400.0,200.0,400.0,600.0,
+                        700.0,500.0,300.0,500.0,700.0,
+                        800.0,600.0,400.0,600.0,800.0]
+        let expectedReversed = [400.0,600.0,800.0,600.0,400.0,
+                                300.0,500.0,700.0,500.0,300.0,
+                                200.0,400.0,600.0,400.0,200.0,
+                                100.0,300.0,500.0,300.0,100.0,
+                                0.0,200.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopMiddleHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,200.0,0.0,200.0,400.0,
+                        600.0,400.0,200.0,400.0,600.0,
+                        800.0,600.0,400.0,600.0,800.0,
+                        1000.0,800.0,600.0,800.0,1000.0,
+                        1200.0,1000.0,800.0,1000.0,1200.0]
+        let expectedReversed = [800.0,1000.0,1200.0,1000.0,800.0,
+                                600.0,800.0,1000.0,800.0,600.0,
+                                400.0,600.0,800.0,600.0,400.0,
+                                200.0,400.0,600.0,400.0,200.0,
+                                0.0,200.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopMiddleCustomWeightsWeightedContinousSortFunction() {
+        let expected = [380.0,190.0,0.0,190.0,380.0,
+                        880.0,690.0,500.0,690.0,880.0,
+                        1380.0,1190.0,1000.0,1190.0,1380.0,
+                        1880.0,1690.0,1500.0,1690.0,1880.0,
+                        2380.0,2190.0,2000.0,2190.0,2380.0]
+        let expectedReversed = [2000.0,2190.0,2380.0,2190.0,2000.0,
+                                1500.0,1690.0,1880.0,1690.0,1500.0,
+                                1000.0,1190.0,1380.0,1190.0,1000.0,
+                                500.0,690.0,880.0,690.0,500.0,
+                                0.0,190.0,380.0,190.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topMiddle, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopRightLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,150.0,100.0,50.0,0.0,
+                        250.0,200.0,150.0,100.0,50.0,
+                        300.0,250.0,200.0,150.0,100.0,
+                        350.0,300.0,250.0,200.0,150.0,
+                        400.0,350.0,300.0,250.0,200.0]
+        let expectedReversed = [200.0,250.0,300.0,350.0,400.0,
+                                150.0,200.0,250.0,300.0,350.0,
+                                100.0,150.0,200.0,250.0,300.0,
+                                50.0,100.0,150.0,200.0,250.0,
+                                0.0,50.0,100.0,150.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopRightLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,150.0,100.0,50.0,0.0,
+                        300.0,250.0,200.0,150.0,100.0,
+                        400.0,350.0,300.0,250.0,200.0,
+                        500.0,450.0,400.0,350.0,300.0,
+                        600.0,550.0,500.0,450.0,400.0]
+        let expectedReversed = [400.0,450.0,500.0,550.0,600.0,
+                                300.0,350.0,400.0,450.0,500.0,
+                                200.0,250.0,300.0,350.0,400.0,
+                                100.0,150.0,200.0,250.0,300.0,
+                                0.0,50.0,100.0,150.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopRightMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,300.0,200.0,100.0,0.0,
+                        450.0,350.0,250.0,150.0,50.0,
+                        500.0,400.0,300.0,200.0,100.0,
+                        550.0,450.0,350.0,250.0,150.0,
+                        600.0,500.0,400.0,300.0,200.0]
+        let expectedReversed = [200.0,300.0,400.0,500.0,600.0,
+                                150.0,250.0,350.0,450.0,550.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                50.0,150.0,250.0,350.0,450.0,
+                                0.0,100.0,200.0,300.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopRightMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,300.0,200.0,100.0,0.0,
+                        500.0,400.0,300.0,200.0,100.0,
+                        600.0,500.0,400.0,300.0,200.0,
+                        700.0,600.0,500.0,400.0,300.0,
+                        800.0,700.0,600.0,500.0,400.0]
+        let expectedReversed = [400.0,500.0,600.0,700.0,800.0,
+                                300.0,400.0,500.0,600.0,700.0,
+                                200.0,300.0,400.0,500.0,600.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                0.0,100.0,200.0,300.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopRightHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [800.0,600.0,400.0,200.0,0.0,
+                        850.0,650.0,450.0,250.0,50.0,
+                        900.0,700.0,500.0,300.0,100.0,
+                        950.0,750.0,550.0,350.0,150.0,
+                        1000.0,800.0,600.0,400.0,200.0]
+        let expectedReversed = [200.0,400.0,600.0,800.0,1000.0,
+                                150.0,350.0,550.0,750.0,950.0,
+                                100.0,300.0,500.0,700.0,900.0,
+                                50.0,250.0,450.0,650.0,850.0,
+                                0.0,200.0,400.0,600.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopRightHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [800.0,600.0,400.0,200.0,0.0,
+                        900.0,700.0,500.0,300.0,100.0,
+                        1000.0,800.0,600.0,400.0,200.0,
+                        1100.0,900.0,700.0,500.0,300.0,
+                        1200.0,1000.0,800.0,600.0,400.0]
+        let expectedReversed = [400.0,600.0,800.0,1000.0,1200.0,
+                                300.0,500.0,700.0,900.0,1100.0,
+                                200.0,400.0,600.0,800.0,1000.0,
+                                100.0,300.0,500.0,700.0,900.0,
+                                0.0,200.0,400.0,600.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopRightHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [800.0,600.0,400.0,200.0,0.0,
+                        1000.0,800.0,600.0,400.0,200.0,
+                        1200.0,1000.0,800.0,600.0,400.0,
+                        1400.0,1200.0,1000.0,800.0,600.0,
+                        1600.0,1400.0,1200.0,1000.0,800.0]
+        let expectedReversed = [800.0,1000.0,1200.0,1400.0,1600.0,
+                                600.0,800.0,1000.0,1200.0,1400.0,
+                                400.0,600.0,800.0,1000.0,1200.0,
+                                200.0,400.0,600.0,800.0,1000.0,
+                                0.0,200.0,400.0,600.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testTopRightCustomWeightsWeightedContinousSortFunction() {
+        let expected = [760.0,570.0,380.0,190.0,0.0,
+                        1260.0,1070.0,880.0,690.0,500.0,
+                        1760.0,1570.0,1380.0,1190.0,1000.0,
+                        2260.0,2070.0,1880.0,1690.0,1500.0,
+                        2760.0,2570.0,2380.0,2190.0,2000.0]
+        let expectedReversed = [2000.0,2190.0,2380.0,2570.0,2760.0,
+                                1500.0,1690.0,1880.0,2070.0,2260.0,
+                                1000.0,1190.0,1380.0,1570.0,1760.0,
+                                500.0,690.0,880.0,1070.0,1260.0,
+                                0.0,190.0,380.0,570.0,760.0]
+        testContinuousWeightedSortFunction(withStartPosition: .topRight, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testLeftLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [100.0,150.0,200.0,250.0,300.0,
+                        50.0,100.0,150.0,200.0,250.0,
+                        0.0,50.0,100.0,150.0,200.0,
+                        50.0,100.0,150.0,200.0,250.0,
+                        100.0,150.0,200.0,250.0,300.0]
+        let expectedReversed = [200.0,150.0,100.0,50.0,0.0,
+                                250.0,200.0,150.0,100.0,50.0,
+                                300.0,250.0,200.0,150.0,100.0,
+                                250.0,200.0,150.0,100.0,50.0,
+                                200.0,150.0,100.0,50.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testLeftLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,250.0,300.0,350.0,400.0,
+                        100.0,150.0,200.0,250.0,300.0,
+                        0.0,50.0,100.0,150.0,200.0,
+                        100.0,150.0,200.0,250.0,300.0,
+                        200.0,250.0,300.0,350.0,400.0]
+        let expectedReversed = [200.0,150.0,100.0,50.0,0.0,
+                                300.0,250.0,200.0,150.0,100.0,
+                                400.0,350.0,300.0,250.0,200.0,
+                                300.0,250.0,200.0,150.0,100.0,
+                                200.0,150.0,100.0,50.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testLeftMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [100.0,200.0,300.0,400.0,500.0,
+                        50.0,150.0,250.0,350.0,450.0,
+                        0.0,100.0,200.0,300.0,400.0,
+                        50.0,150.0,250.0,350.0,450.0,
+                        100.0,200.0,300.0,400.0,500.0]
+        let expectedReversed = [400.0,300.0,200.0,100.0,0.0,
+                                450.0,350.0,250.0,150.0,50.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                450.0,350.0,250.0,150.0,50.0,
+                                400.0,300.0,200.0,100.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testLeftMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,300.0,400.0,500.0,600.0,
+                        100.0,200.0,300.0,400.0,500.0,
+                        0.0,100.0,200.0,300.0,400.0,
+                        100.0,200.0,300.0,400.0,500.0,
+                        200.0,300.0,400.0,500.0,600.0]
+        let expectedReversed = [400.0,300.0,200.0,100.0,0.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                600.0,500.0,400.0,300.0,200.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                400.0,300.0,200.0,100.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testLeftHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [100.0,300.0,500.0,700.0,900.0,
+                        50.0,250.0,450.0,650.0,850.0,
+                        0.0,200.0,400.0,600.0,800.0,
+                        50.0,250.0,450.0,650.0,850.0,
+                        100.0,300.0,500.0,700.0,900.0]
+        let expectedReversed = [800.0,600.0,400.0,200.0,0.0,
+                                850.0,650.0,450.0,250.0,50.0,
+                                900.0,700.0,500.0,300.0,100.0,
+                                850.0,650.0,450.0,250.0,50.0,
+                                800.0,600.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testLeftHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,400.0,600.0,800.0,1000.0,
+                        100.0,300.0,500.0,700.0,900.0,
+                        0.0,200.0,400.0,600.0,800.0,
+                        100.0,300.0,500.0,700.0,900.0,
+                        200.0,400.0,600.0,800.0,1000.0]
+        let expectedReversed = [800.0,600.0,400.0,200.0,0.0,
+                                900.0,700.0,500.0,300.0,100.0,
+                                1000.0,800.0,600.0,400.0,200.0,
+                                900.0,700.0,500.0,300.0,100.0,
+                                800.0,600.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testLeftHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,600.0,800.0,1000.0,1200.0,
+                        200.0,400.0,600.0,800.0,1000.0,
+                        0.0,200.0,400.0,600.0,800.0,
+                        200.0,400.0,600.0,800.0,1000.0,
+                        400.0,600.0,800.0,1000.0,1200.0]
+        let expectedReversed = [800.0,600.0,400.0,200.0,0.0,
+                                1000.0,800.0,600.0,400.0,200.0,
+                                1200.0,1000.0,800.0,600.0,400.0,
+                                1000.0,800.0,600.0,400.0,200.0,
+                                800.0,600.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testLeftCustomWeightsWeightedContinousSortFunction() {
+        let expected = [1000.0,1190.0,1380.0,1570.0,1760.0,
+                        500.0,690.0,880.0,1070.0,1260.0,
+                        0.0,190.0,380.0,570.0,760.0,
+                        500.0,690.0,880.0,1070.0,1260.0,
+                        1000.0,1190.0,1380.0,1570.0,1760.0]
+        let expectedReversed = [760.0,570.0,380.0,190.0,0.0,
+                                1260.0,1070.0,880.0,690.0,500.0,
+                                1760.0,1570.0,1380.0,1190.0,1000.0,
+                                1260.0,1070.0,880.0,690.0,500.0,
+                                760.0,570.0,380.0,190.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .left, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testMiddleLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,150.0,100.0,150.0,200.0,
+                        150.0,100.0,50.0,100.0,150.0,
+                        100.0,50.0,0.0,50.0,100.0,
+                        150.0,100.0,50.0,100.0,150.0,
+                        200.0,150.0,100.0,150.0,200.0]
+        let expectedReversed = [0.0,50.0,100.0,50.0,0.0,
+                                50.0,100.0,150.0,100.0,50.0,
+                                100.0,150.0,200.0,150.0,100.0,
+                                50.0,100.0,150.0,100.0,50.0,
+                                0.0,50.0,100.0,50.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testMiddleLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [300.0,250.0,200.0,250.0,300.0,
+                        200.0,150.0,100.0,150.0,200.0,
+                        100.0,50.0,0.0,50.0,100.0,
+                        200.0,150.0,100.0,150.0,200.0,
+                        300.0,250.0,200.0,250.0,300.0]
+        let expectedReversed = [0.0,50.0,100.0,50.0,0.0,
+                                100.0,150.0,200.0,150.0,100.0,
+                                200.0,250.0,300.0,250.0,200.0,
+                                100.0,150.0,200.0,150.0,100.0,
+                                0.0,50.0,100.0,50.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testMiddleMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [300.0,200.0,100.0,200.0,300.0,
+                        250.0,150.0,50.0,150.0,250.0,
+                        200.0,100.0,0.0,100.0,200.0,
+                        250.0,150.0,50.0,150.0,250.0,
+                        300.0,200.0,100.0,200.0,300.0]
+        let expectedReversed = [0.0,100.0,200.0,100.0,0.0,
+                                50.0,150.0,250.0,150.0,50.0,
+                                100.0,200.0,300.0,200.0,100.0,
+                                50.0,150.0,250.0,150.0,50.0,
+                                0.0,100.0,200.0,100.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testMiddleMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,300.0,200.0,300.0,400.0,
+                        300.0,200.0,100.0,200.0,300.0,
+                        200.0,100.0,0.0,100.0,200.0,
+                        300.0,200.0,100.0,200.0,300.0,
+                        400.0,300.0,200.0,300.0,400.0]
+        let expectedReversed = [0.0,100.0,200.0,100.0,0.0,
+                                100.0,200.0,300.0,200.0,100.0,
+                                200.0,300.0,400.0,300.0,200.0,
+                                100.0,200.0,300.0,200.0,100.0,
+                                0.0,100.0,200.0,100.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testMiddleHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [500.0,300.0,100.0,300.0,500.0,
+                        450.0,250.0,50.0,250.0,450.0,
+                        400.0,200.0,0.0,200.0,400.0,
+                        450.0,250.0,50.0,250.0,450.0,
+                        500.0,300.0,100.0,300.0,500.0]
+        let expectedReversed = [0.0,200.0,400.0,200.0,0.0,
+                                50.0,250.0,450.0,250.0,50.0,
+                                100.0,300.0,500.0,300.0,100.0,
+                                50.0,250.0,450.0,250.0,50.0,
+                                0.0,200.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testMiddleHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [600.0,400.0,200.0,400.0,600.0,
+                        500.0,300.0,100.0,300.0,500.0,
+                        400.0,200.0,0.0,200.0,400.0,
+                        500.0,300.0,100.0,300.0,500.0,
+                        600.0,400.0,200.0,400.0,600.0]
+        let expectedReversed = [0.0,200.0,400.0,200.0,0.0,
+                                100.0,300.0,500.0,300.0,100.0,
+                                200.0,400.0,600.0,400.0,200.0,
+                                100.0,300.0,500.0,300.0,100.0,
+                                0.0,200.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testMiddleHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [800.0,600.0,400.0,600.0,800.0,
+                        600.0,400.0,200.0,400.0,600.0,
+                        400.0,200.0,0.0,200.0,400.0,
+                        600.0,400.0,200.0,400.0,600.0,
+                        800.0,600.0,400.0,600.0,800.0]
+        let expectedReversed = [0.0,200.0,400.0,200.0,0.0,
+                                200.0,400.0,600.0,400.0,200.0,
+                                400.0,600.0,800.0,600.0,400.0,
+                                200.0,400.0,600.0,400.0,200.0,
+                                0.0,200.0,400.0,200.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testMiddleCustomWeightsWeightedContinousSortFunction() {
+        let expected = [1380.0,1190.0,1000.0,1190.0,1380.0,
+                        880.0,690.0,500.0,690.0,880.0,
+                        380.0,190.0,0.0,190.0,380.0,
+                        880.0,690.0,500.0,690.0,880.0,
+                        1380.0,1190.0,1000.0,1190.0,1380.0]
+        let expectedReversed = [0.0,190.0,380.0,190.0,0.0,
+                                500.0,690.0,880.0,690.0,500.0,
+                                1000.0,1190.0,1380.0,1190.0,1000.0,
+                                500.0,690.0,880.0,690.0,500.0,
+                                0.0,190.0,380.0,190.0,0.0]
+        testContinuousWeightedSortFunction(withStartPosition: .middle, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testRightLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [300.0,250.0,200.0,150.0,100.0,
+                        250.0,200.0,150.0,100.0,50.0,
+                        200.0,150.0,100.0,50.0,0.0,
+                        250.0,200.0,150.0,100.0,50.0,
+                        300.0,250.0,200.0,150.0,100.0]
+        let expectedReversed = [0.0,50.0,100.0,150.0,200.0,
+                                50.0,100.0,150.0,200.0,250.0,
+                                100.0,150.0,200.0,250.0,300.0,
+                                50.0,100.0,150.0,200.0,250.0,
+                                0.0,50.0,100.0,150.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testRightLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,350.0,300.0,250.0,200.0,
+                        300.0,250.0,200.0,150.0,100.0,
+                        200.0,150.0,100.0,50.0,0.0,
+                        300.0,250.0,200.0,150.0,100.0,
+                        400.0,350.0,300.0,250.0,200.0]
+        let expectedReversed = [0.0,50.0,100.0,150.0,200.0,
+                                100.0,150.0,200.0,250.0,300.0,
+                                200.0,250.0,300.0,350.0,400.0,
+                                100.0,150.0,200.0,250.0,300.0,
+                                0.0,50.0,100.0,150.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testRightMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [500.0,400.0,300.0,200.0,100.0,
+                        450.0,350.0,250.0,150.0,50.0,
+                        400.0,300.0,200.0,100.0,0.0,
+                        450.0,350.0,250.0,150.0,50.0,
+                        500.0,400.0,300.0,200.0,100.0]
+        let expectedReversed = [0.0,100.0,200.0,300.0,400.0,
+                                50.0,150.0,250.0,350.0,450.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                50.0,150.0,250.0,350.0,450.0,
+                                0.0,100.0,200.0,300.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testRightMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [600.0,500.0,400.0,300.0,200.0,
+                        500.0,400.0,300.0,200.0,100.0,
+                        400.0,300.0,200.0,100.0,0.0,
+                        500.0,400.0,300.0,200.0,100.0,
+                        600.0,500.0,400.0,300.0,200.0]
+        let expectedReversed = [0.0,100.0,200.0,300.0,400.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                200.0,300.0,400.0,500.0,600.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                0.0,100.0,200.0,300.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testRightHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [900.0,700.0,500.0,300.0,100.0,
+                        850.0,650.0,450.0,250.0,50.0,
+                        800.0,600.0,400.0,200.0,0.0,
+                        850.0,650.0,450.0,250.0,50.0,
+                        900.0,700.0,500.0,300.0,100.0]
+        let expectedReversed = [0.0,200.0,400.0,600.0,800.0,
+                                50.0,250.0,450.0,650.0,850.0,
+                                100.0,300.0,500.0,700.0,900.0,
+                                50.0,250.0,450.0,650.0,850.0,
+                                0.0,200.0,400.0,600.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testRightHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [1000.0,800.0,600.0,400.0,200.0,
+                        900.0,700.0,500.0,300.0,100.0,
+                        800.0,600.0,400.0,200.0,0.0,
+                        900.0,700.0,500.0,300.0,100.0,
+                        1000.0,800.0,600.0,400.0,200.0]
+        let expectedReversed = [0.0,200.0,400.0,600.0,800.0,
+                                100.0,300.0,500.0,700.0,900.0,
+                                200.0,400.0,600.0,800.0,1000.0,
+                                100.0,300.0,500.0,700.0,900.0,
+                                0.0,200.0,400.0,600.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testRightHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [1200.0,1000.0,800.0,600.0,400.0,
+                        1000.0,800.0,600.0,400.0,200.0,
+                        800.0,600.0,400.0,200.0,0.0,
+                        1000.0,800.0,600.0,400.0,200.0,
+                        1200.0,1000.0,800.0,600.0,400.0]
+        let expectedReversed = [0.0,200.0,400.0,600.0,800.0,
+                                200.0,400.0,600.0,800.0,1000.0,
+                                400.0,600.0,800.0,1000.0,1200.0,
+                                200.0,400.0,600.0,800.0,1000.0,
+                                0.0,200.0,400.0,600.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testRightCustomWeightsWeightedContinousSortFunction() {
+        let expected = [1760.0,1570.0,1380.0,1190.0,1000.0,
+                        1260.0,1070.0,880.0,690.0,500.0,
+                        760.0,570.0,380.0,190.0,0.0,
+                        1260.0,1070.0,880.0,690.0,500.0,
+                        1760.0,1570.0,1380.0,1190.0,1000.0]
+        let expectedReversed = [0.0,190.0,380.0,570.0,760.0,
+                                500.0,690.0,880.0,1070.0,1260.0,
+                                1000.0,1190.0,1380.0,1570.0,1760.0,
+                                500.0,690.0,880.0,1070.0,1260.0,
+                                0.0,190.0,380.0,570.0,760.0]
+        testContinuousWeightedSortFunction(withStartPosition: .right, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomLeftLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,250.0,300.0,350.0,400.0,
+                        150.0,200.0,250.0,300.0,350.0,
+                        100.0,150.0,200.0,250.0,300.0,
+                        50.0,100.0,150.0,200.0,250.0,
+                        0.0,50.0,100.0,150.0,200.0]
+        let expectedReversed = [200.0,150.0,100.0,50.0,0.0,
+                                250.0,200.0,150.0,100.0,50.0,
+                                300.0,250.0,200.0,150.0,100.0,
+                                350.0,300.0,250.0,200.0,150.0,
+                                400.0,350.0,300.0,250.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomLeftLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,450.0,500.0,550.0,600.0,
+                        300.0,350.0,400.0,450.0,500.0,
+                        200.0,250.0,300.0,350.0,400.0,
+                        100.0,150.0,200.0,250.0,300.0,
+                        0.0,50.0,100.0,150.0,200.0]
+        let expectedReversed = [200.0,150.0,100.0,50.0,0.0,
+                                300.0,250.0,200.0,150.0,100.0,
+                                400.0,350.0,300.0,250.0,200.0,
+                                500.0,450.0,400.0,350.0,300.0,
+                                600.0,550.0,500.0,450.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomLeftMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,300.0,400.0,500.0,600.0,
+                        150.0,250.0,350.0,450.0,550.0,
+                        100.0,200.0,300.0,400.0,500.0,
+                        50.0,150.0,250.0,350.0,450.0,
+                        0.0,100.0,200.0,300.0,400.0]
+        let expectedReversed = [400.0,300.0,200.0,100.0,0.0,
+                                450.0,350.0,250.0,150.0,50.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                550.0,450.0,350.0,250.0,150.0,
+                                600.0,500.0,400.0,300.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomLeftMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,500.0,600.0,700.0,800.0,
+                        300.0,400.0,500.0,600.0,700.0,
+                        200.0,300.0,400.0,500.0,600.0,
+                        100.0,200.0,300.0,400.0,500.0,
+                        0.0,100.0,200.0,300.0,400.0]
+        let expectedReversed = [400.0,300.0,200.0,100.0,0.0,
+                                500.0,400.0,300.0,200.0,100.0,
+                                600.0,500.0,400.0,300.0,200.0,
+                                700.0,600.0,500.0,400.0,300.0,
+                                800.0,700.0,600.0,500.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomLeftHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [200.0,400.0,600.0,800.0,1000.0,
+                        150.0,350.0,550.0,750.0,950.0,
+                        100.0,300.0,500.0,700.0,900.0,
+                        50.0,250.0,450.0,650.0,850.0,
+                        0.0,200.0,400.0,600.0,800.0]
+        let expectedReversed = [800.0,600.0,400.0,200.0,0.0,
+                                850.0,650.0,450.0,250.0,50.0,
+                                900.0,700.0,500.0,300.0,100.0,
+                                950.0,750.0,550.0,350.0,150.0,
+                                1000.0,800.0,600.0,400.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomLeftHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,600.0,800.0,1000.0,1200.0,
+                        300.0,500.0,700.0,900.0,1100.0,
+                        200.0,400.0,600.0,800.0,1000.0,
+                        100.0,300.0,500.0,700.0,900.0,
+                        0.0,200.0,400.0,600.0,800.0]
+        let expectedReversed = [800.0,600.0,400.0,200.0,0.0,
+                                900.0,700.0,500.0,300.0,100.0,
+                                1000.0,800.0,600.0,400.0,200.0,
+                                1100.0,900.0,700.0,500.0,300.0,
+                                1200.0,1000.0,800.0,600.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomLeftHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [800.0,1000.0,1200.0,1400.0,1600.0,
+                        600.0,800.0,1000.0,1200.0,1400.0,
+                        400.0,600.0,800.0,1000.0,1200.0,
+                        200.0,400.0,600.0,800.0,1000.0,
+                        0.0,200.0,400.0,600.0,800.0]
+        let expectedReversed = [800.0,600.0,400.0,200.0,0.0,
+                                1000.0,800.0,600.0,400.0,200.0,
+                                1200.0,1000.0,800.0,600.0,400.0,
+                                1400.0,1200.0,1000.0,800.0,600.0,
+                                1600.0,1400.0,1200.0,1000.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomLeftCustomWeightsWeightedContinousSortFunction() {
+        let expected = [2000.0,2190.0,2380.0,2570.0,2760.0,
+                        1500.0,1690.0,1880.0,2070.0,2260.0,
+                        1000.0,1190.0,1380.0,1570.0,1760.0,
+                        500.0,690.0,880.0,1070.0,1260.0,
+                        0.0,190.0,380.0,570.0,760.0]
+        let expectedReversed = [760.0,570.0,380.0,190.0,0.0,
+                                1260.0,1070.0,880.0,690.0,500.0,
+                                1760.0,1570.0,1380.0,1190.0,1000.0,
+                                2260.0,2070.0,1880.0,1690.0,1500.0,
+                                2760.0,2570.0,2380.0,2190.0,2000.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomLeft, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomMiddleLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [300.0,250.0,200.0,250.0,300.0,
+                        250.0,200.0,150.0,200.0,250.0,
+                        200.0,150.0,100.0,150.0,200.0,
+                        150.0,100.0,50.0,100.0,150.0,
+                        100.0,50.0,0.0,50.0,100.0]
+        let expectedReversed = [0.0,50.0,100.0,50.0,0.0,
+                                50.0,100.0,150.0,100.0,50.0,
+                                100.0,150.0,200.0,150.0,100.0,
+                                150.0,200.0,250.0,200.0,150.0,
+                                200.0,250.0,300.0,250.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomMiddleLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [500.0,450.0,400.0,450.0,500.0,
+                        400.0,350.0,300.0,350.0,400.0,
+                        300.0,250.0,200.0,250.0,300.0,
+                        200.0,150.0,100.0,150.0,200.0,
+                        100.0,50.0,0.0,50.0,100.0]
+        let expectedReversed = [0.0,50.0,100.0,50.0,0.0,
+                                100.0,150.0,200.0,150.0,100.0,
+                                200.0,250.0,300.0,250.0,200.0,
+                                300.0,350.0,400.0,350.0,300.0,
+                                400.0,450.0,500.0,450.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomMiddleMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,300.0,200.0,300.0,400.0,
+                        350.0,250.0,150.0,250.0,350.0,
+                        300.0,200.0,100.0,200.0,300.0,
+                        250.0,150.0,50.0,150.0,250.0,
+                        200.0,100.0,0.0,100.0,200.0]
+        let expectedReversed = [0.0,100.0,200.0,100.0,0.0,
+                                50.0,150.0,250.0,150.0,50.0,
+                                100.0,200.0,300.0,200.0,100.0,
+                                150.0,250.0,350.0,250.0,150.0,
+                                200.0,300.0,400.0,300.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomMiddleMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [600.0,500.0,400.0,500.0,600.0,
+                        500.0,400.0,300.0,400.0,500.0,
+                        400.0,300.0,200.0,300.0,400.0,
+                        300.0,200.0,100.0,200.0,300.0,
+                        200.0,100.0,0.0,100.0,200.0]
+        let expectedReversed = [0.0,100.0,200.0,100.0,0.0,
+                                100.0,200.0,300.0,200.0,100.0,
+                                200.0,300.0,400.0,300.0,200.0,
+                                300.0,400.0,500.0,400.0,300.0,
+                                400.0,500.0,600.0,500.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomMiddleHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [600.0,400.0,200.0,400.0,600.0,
+                        550.0,350.0,150.0,350.0,550.0,
+                        500.0,300.0,100.0,300.0,500.0,
+                        450.0,250.0,50.0,250.0,450.0,
+                        400.0,200.0,0.0,200.0,400.0]
+        let expectedReversed = [0.0,200.0,400.0,200.0,0.0,
+                                50.0,250.0,450.0,250.0,50.0,
+                                100.0,300.0,500.0,300.0,100.0,
+                                150.0,350.0,550.0,350.0,150.0,
+                                200.0,400.0,600.0,400.0,200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomMiddleHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [800.0,600.0,400.0,600.0,800.0,
+                        700.0,500.0,300.0,500.0,700.0,
+                        600.0,400.0,200.0,400.0,600.0,
+                        500.0,300.0,100.0,300.0,500.0,
+                        400.0,200.0,0.0,200.0,400.0]
+        let expectedReversed = [0.0,200.0,400.0,200.0,0.0,
+                                100.0,300.0,500.0,300.0,100.0,
+                                200.0,400.0,600.0,400.0,200.0,
+                                300.0,500.0,700.0,500.0,300.0,
+                                400.0,600.0,800.0,600.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomMiddleHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [1200.0,1000.0,800.0,1000.0,1200.0,
+                        1000.0,800.0,600.0,800.0,1000.0,
+                        800.0,600.0,400.0,600.0,800.0,
+                        600.0,400.0,200.0,400.0,600.0,
+                        400.0,200.0,0.0,200.0,400.0]
+        let expectedReversed = [0.0,200.0,400.0,200.0,0.0,
+                                200.0,400.0,600.0,400.0,200.0,
+                                400.0,600.0,800.0,600.0,400.0,
+                                600.0,800.0,1000.0,800.0,600.0,
+                                800.0,1000.0,1200.0,1000.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomMiddleCustomWeightsWeightedContinousSortFunction() {
+        let expected = [2380.0,2190.0,2000.0,2190.0,2380.0,
+                        1880.0,1690.0,1500.0,1690.0,1880.0,
+                        1380.0,1190.0,1000.0,1190.0,1380.0,
+                        880.0,690.0,500.0,690.0,880.0,
+                        380.0,190.0,0.0,190.0,380.0]
+        let expectedReversed = [0.0,190.0,380.0,190.0,0.0,
+                                500.0,690.0,880.0,690.0,500.0,
+                                1000.0,1190.0,1380.0,1190.0,1000.0,
+                                1500.0,1690.0,1880.0,1690.0,1500.0,
+                                2000.0,2190.0,2380.0,2190.0,2000.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomMiddle, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomRightLightHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [400.0,350.0,300.0,250.0,200.0,
+                        350.0,300.0,250.0,200.0,150.0,
+                        300.0,250.0,200.0,150.0,100.0,
+                        250.0,200.0,150.0,100.0,50.0,
+                        200.0,150.0,100.0,50.0,0.0]
+        let expectedReversed = [0.0,50.0,100.0,150.0,200.0,
+                                50.0,100.0,150.0,200.0,250.0,
+                                100.0,150.0,200.0,250.0,300.0,
+                                150.0,200.0,250.0,300.0,350.0,
+                                200.0,250.0,300.0,350.0,400.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .light, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomRightLightHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [600.0,550.0,500.0,450.0,400.0,
+                        500.0,450.0,400.0,350.0,300.0,
+                        400.0,350.0,300.0,250.0,200.0,
+                        300.0,250.0,200.0,150.0,100.0,
+                        200.0,150.0,100.0,50.0,0.0]
+        let expectedReversed = [0.0,50.0,100.0,150.0,200.0,
+                                100.0,150.0,200.0,250.0,300.0,
+                                200.0,250.0,300.0,350.0,400.0,
+                                300.0,350.0,400.0,450.0,500.0,
+                                400.0,450.0,500.0,550.0,600.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .light, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomRightMediumHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [600.0,500.0,400.0,300.0,200.0,
+                        550.0,450.0,350.0,250.0,150.0,
+                        500.0,400.0,300.0,200.0,100.0,
+                        450.0,350.0,250.0,150.0,50.0,
+                        400.0,300.0,200.0,100.0,0.0]
+        let expectedReversed = [0.0,100.0,200.0,300.0,400.0,
+                                50.0,150.0,250.0,350.0,450.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                150.0,250.0,350.0,450.0,550.0,
+                                200.0,300.0,400.0,500.0,600.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .medium, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomRightMediumHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [800.0,700.0,600.0,500.0,400.0,
+                        700.0,600.0,500.0,400.0,300.0,
+                        600.0,500.0,400.0,300.0,200.0,
+                        500.0,400.0,300.0,200.0,100.0,
+                        400.0,300.0,200.0,100.0,0.0]
+        let expectedReversed = [0.0,100.0,200.0,300.0,400.0,
+                                100.0,200.0,300.0,400.0,500.0,
+                                200.0,300.0,400.0,500.0,600.0,
+                                300.0,400.0,500.0,600.0,700.0,
+                                400.0,500.0,600.0,700.0,800.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .medium, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomRightHeavyHorizontalLightVerticalWeightedContinousSortFunction() {
+        let expected = [1000.0,800.0,600.0,400.0,200.0,
+                        950.0,750.0,550.0,350.0,150.0,
+                        900.0,700.0,500.0,300.0,100.0,
+                        850.0,650.0,450.0,250.0,50.0,
+                        800.0,600.0,400.0,200.0,0.0]
+        let expectedReversed = [0.0,200.0,400.0,600.0,800.0,
+                                50.0,250.0,450.0,650.0,850.0,
+                                100.0,300.0,500.0,700.0,900.0,
+                                150.0,350.0,550.0,750.0,950.0,
+                                200.0,400.0,600.0,800.0,1000.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .heavy, verticalWeight: .light, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomRightHeavyHorizontalMediumVerticalWeightedContinousSortFunction() {
+        let expected = [1200.0,1000.0,800.0,600.0,400.0,
+                        1100.0,900.0,700.0,500.0,300.0,
+                        1000.0,800.0,600.0,400.0,200.0,
+                        900.0,700.0,500.0,300.0,100.0,
+                        800.0,600.0,400.0,200.0,0.0]
+        let expectedReversed = [0.0,200.0,400.0,600.0,800.0,
+                                100.0,300.0,500.0,700.0,900.0,
+                                200.0,400.0,600.0,800.0,1000.0,
+                                300.0,500.0,700.0,900.0,1100.0,
+                                400.0,600.0,800.0,1000.0,1200.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .heavy, verticalWeight: .medium, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomRightHeavyHorizontalHeavyVerticalWeightedContinousSortFunction() {
+        let expected = [1600.0,1400.0,1200.0,1000.0,800.0,
+                        1400.0,1200.0,1000.0,800.0,600.0,
+                        1200.0,1000.0,800.0,600.0,400.0,
+                        1000.0,800.0,600.0,400.0,200.0,
+                        800.0,600.0,400.0,200.0,0.0]
+        let expectedReversed = [0.0,200.0,400.0,600.0,800.0,
+                                200.0,400.0,600.0,800.0,1000.0,
+                                400.0,600.0,800.0,1000.0,1200.0,
+                                600.0,800.0,1000.0,1200.0,1400.0,
+                                800.0,1000.0,1200.0,1400.0,1600.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .heavy, verticalWeight: .heavy, expected: expected, expectedReversed: expectedReversed)
+    }
+    
+    func testBottomRightCustomWeightsWeightedContinousSortFunction() {
+        let expected = [2760.0,2570.0,2380.0,2190.0,2000.0,
+                        2260.0,2070.0,1880.0,1690.0,1500.0,
+                        1760.0,1570.0,1380.0,1190.0,1000.0,
+                        1260.0,1070.0,880.0,690.0,500.0,
+                        760.0,570.0,380.0,190.0,0.0]
+        let expectedReversed = [0.0,190.0,380.0,570.0,760.0,
+                                500.0,690.0,880.0,1070.0,1260.0,
+                                1000.0,1190.0,1380.0,1570.0,1760.0,
+                                1500.0,1690.0,1880.0,2070.0,2260.0,
+                                2000.0,2190.0,2380.0,2570.0,2760.0]
+        testContinuousWeightedSortFunction(withStartPosition: .bottomRight, horizontalWeight: .custom(1.9), verticalWeight: .custom(5.0), expected: expected, expectedReversed: expectedReversed)
+    }
+}
+