made api more swift3 friendly

Author: davecom

Sources/Backtrack.swift

@@ -32,22 +32,22 @@
 /// - parameter lcv: SHould it use the lcv heuristic to try to improve performance (default false) NOT IMPLEMENTED YET
 /// - parameter mac3: SHould it use the mac3 heuristic to try to improve performance (default false) NOT IMPLEMENTED YET
 /// - returns: the assignment (solution), or nil if none can be found
-public func backtrackingSearch<V, D>(_ csp: CSP<V, D>, assignment: Dictionary<V, D> = Dictionary<V, D>(), mrv: Bool = false, lcv: Bool = false, mac3: Bool = false) -> Dictionary<V, D>?
+public func backtrackingSearch<V, D>(csp: CSP<V, D>, assignment: Dictionary<V, D> = Dictionary<V, D>(), mrv: Bool = false, lcv: Bool = false, mac3: Bool = false) -> Dictionary<V, D>?
 {
  // assignment is complete if it has as many assignments as there are variables
  if assignment.count == csp.variables.count { return assignment }
 
  // get a var to assign
- let variable = selectUnassignedVariable(csp, assignment: assignment, mrv: mrv)
+ let variable = selectUnassignedVariable(csp: csp, assignment: assignment, mrv: mrv)
 
  // get the domain of it and try each value in the domain
- for value in orderDomainValues(variable, assignment: assignment, csp: csp, lcv: lcv) {
+ for value in orderDomainValues(variable: variable, assignment: assignment, csp: csp, lcv: lcv) {
 
  // if the value is consistent with the current assignment we continue
  var localAssignment = assignment
  localAssignment[variable] = value
  //println(assignment)
- if isConsistent(variable, value: value, assignment: localAssignment, csp: csp) {
+ if isConsistent(variable: variable, value: value, assignment: localAssignment, csp: csp) {
  //println("Found \(variable) with value \(value) and other assignment \(assignment) consistent")
 
  // do inferencing if we have that turned on
@@ -62,7 +62,7 @@ public func backtrackingSearch<V, D>(_ csp: CSP<V, D>, assignment: Dictionary<V,
 
  if (result != False) return result; */
  } else {
- if let result = backtrackingSearch(csp, assignment: localAssignment, mrv: mrv, mac3: mac3, lcv: lcv) {
+ if let result = backtrackingSearch(csp: csp, assignment: localAssignment, mrv: mrv, mac3: mac3, lcv: lcv) {
  return result
  }
  }
@@ -75,9 +75,9 @@ public func backtrackingSearch<V, D>(_ csp: CSP<V, D>, assignment: Dictionary<V,
 }
 
 /// check if the value assignment is consistent by checking all constraints of the variable
-func isConsistent<V, D>(_ variable: V, value: D, assignment: Dictionary<V, D>, csp: CSP<V,D>) -> Bool {
+func isConsistent<V, D>(variable: V, value: D, assignment: Dictionary<V, D>, csp: CSP<V,D>) -> Bool {
  for constraint in csp.constraints[variable]! { //assume there are constraints for every variable
- if !constraint.isSatisfied(assignment) {
+ if !constraint.isSatisfied(assignment: assignment) {
  return false
  }
  }
@@ -86,7 +86,7 @@ func isConsistent<V, D>(_ variable: V, value: D, assignment: Dictionary<V, D>, c
 
 /// Return an unassigned variable - we may want to use some logic here to return the
 /// minimum-remaining values
-func selectUnassignedVariable<V, D>(_ csp: CSP<V, D>, assignment: Dictionary<V, D>, mrv: Bool) -> V {
+func selectUnassignedVariable<V, D>(csp: CSP<V, D>, assignment: Dictionary<V, D>, mrv: Bool) -> V {
  // do we want to use the mrv heuristic
  if (mrv) {
  //get the one with the biggest domain
@@ -109,7 +109,7 @@ func selectUnassignedVariable<V, D>(_ csp: CSP<V, D>, assignment: Dictionary<V,
 }
 
 /// get the domain variables in a good order
-func orderDomainValues<V, D>(_ variable: V, assignment: Dictionary<V,D>, csp: CSP<V,D>, lcv: Bool) -> [D] {
+func orderDomainValues<V, D>(variable: V, assignment: Dictionary<V,D>, csp: CSP<V,D>, lcv: Bool) -> [D] {
  return csp.domains[variable]! //asume there is a domain for every variable
  /*if lcv { //not implemented yet
  /*// currently works only for binary constraints

Sources/CSP.swift

@@ -48,7 +48,7 @@ public struct CSP <V: Hashable, D> {
  /// Add a constraint to the CSP. It will automatically be applied to all the variables it includes. It should only include variables actually in the CSP.
  ///
  /// - parameter constraint: The constraint to add.
- public mutating func addConstraint(_ constraint: Constraint<V, D>) {
+ public mutating func addConstraint(constraint: Constraint<V, D>) {
  for variable in constraint.vars {
  if !variables.contains(variable) {
  print("Error: Could not find variable \(variable) from constraint \(constraint) in CSP.", terminator: "")

Sources/Constraint.swift

@@ -32,7 +32,7 @@ public class Constraint <V: Hashable, D> {
  ///
  /// - parameter assignment: Potential domain selections for variables that are part of the constraint.
  /// - returns: Whether the constraint is satisfied.
- public func isSatisfied(_ assignment: Dictionary<V, D>) -> Bool {
+ public func isSatisfied(assignment: Dictionary<V, D>) -> Bool {
  return true
  }
  /// The variables that make up the constraint.

SwiftCSP/SwiftCSP/AppDelegate.swift

@@ -47,7 +47,7 @@ class AppDelegate: NSObject, NSApplicationDelegate {
  var variables = circuitBoards
  var domains: Dictionary<CircuitBoard, [(Int, Int)]> = Dictionary<CircuitBoard, [(Int, Int)]>()
  for variable in variables {
- domains[variable] = variable.generateDomain(boardWidth, boardHeight: boardHeight)
+ domains[variable] = variable.generateDomain(boardWidth: boardWidth, boardHeight: boardHeight)
  }
 
  var cb_csp: CSP<CircuitBoard, (Int, Int)> = CSP<CircuitBoard, (Int, Int)>(variables: variables, domains: domains)
@@ -56,14 +56,14 @@ class AppDelegate: NSObject, NSApplicationDelegate {
  for i in 0..<variables.count {
  for j in (i+1)..<variables.count {
  let cbconst = CircuitBoardConstraint(variable1: variables[i], variable2: variables[j])
- cb_csp.addConstraint(cbconst)
+ cb_csp.addConstraint(constraint: cbconst)
  //println(cbconst.variable1.width)
  //println(cbconst.variable2.width)
  }
  }
 
  //run the solution and calculate the time it took
- if let solution = backtrackingSearch(cb_csp, mrv: true) {
+ if let solution = backtrackingSearch(csp: cb_csp, mrv: true) {
  for (variable, location) in solution {
  variable.location = location
  }

SwiftCSP/SwiftCSP/CircuitBoard.swift

@@ -33,7 +33,7 @@ class CircuitBoard: NSObject { //get hashable for free and dynamic access
  var location: (Int, Int)?
 
  //generate the domain as a list of tuples of bottom left corners
- func generateDomain(_ boardWidth: Int, boardHeight: Int) -> [(Int, Int)] {
+ func generateDomain(boardWidth: Int, boardHeight: Int) -> [(Int, Int)] {
  var domain: [(Int, Int)] = []
  for x in 0..<(boardWidth - width + 1) {
  for y in 0..<(boardHeight - height + 1) {

SwiftCSP/SwiftCSP/CircuitBoardConstraint.swift

@@ -35,7 +35,7 @@ class CircuitBoardConstraint: BinaryConstraint<CircuitBoard, (Int, Int)> {
  //println(self.variable2.width)
  }
 
- override func isSatisfied(_ assignment: Dictionary<CircuitBoard, (Int, Int)>) -> Bool {
+ override func isSatisfied(assignment: Dictionary<CircuitBoard, (Int, Int)>) -> Bool {
  //if either variable is not in the assignment then it must be consistent
  //since they still have their domain
  if assignment[variable1] == nil || assignment[variable2] == nil {

SwiftCSP/SwiftCSPTests/AustralianMapColoringTest.swift

@@ -33,7 +33,7 @@ final class MapColoringConstraint: BinaryConstraint <String, String> {
  super.init(variable1: place1, variable2: place2)
  }
 
- override func isSatisfied(_ assignment: Dictionary<String, String>) -> Bool {
+ override func isSatisfied(assignment: Dictionary<String, String>) -> Bool {
  // if either variable is not in the assignment then it must be consistent
  // since they still have their domain
  if assignment[variable1] == nil || assignment[variable2] == nil {
@@ -58,16 +58,16 @@ class AustralianMapColoringTest: XCTestCase {
  }
 
  csp = CSP<String, String>(variables: variables, domains: domains)
- csp?.addConstraint(MapColoringConstraint(place1: "Western Australia", place2: "Northern Territory"));
- csp?.addConstraint( MapColoringConstraint(place1: "Western Australia", place2: "South Australia"));
- csp?.addConstraint( MapColoringConstraint(place1: "South Australia", place2: "Northern Territory"));
- csp?.addConstraint( MapColoringConstraint(place1: "Queensland", place2: "Northern Territory"));
- csp?.addConstraint( MapColoringConstraint(place1: "Queensland",
+ csp?.addConstraint(constraint: MapColoringConstraint(place1: "Western Australia", place2: "Northern Territory"));
+ csp?.addConstraint(constraint: MapColoringConstraint(place1: "Western Australia", place2: "South Australia"));
+ csp?.addConstraint(constraint: MapColoringConstraint(place1: "South Australia", place2: "Northern Territory"));
+ csp?.addConstraint(constraint: MapColoringConstraint(place1: "Queensland", place2: "Northern Territory"));
+ csp?.addConstraint(constraint: MapColoringConstraint(place1: "Queensland",
  place2: "South Australia"));
- csp?.addConstraint(MapColoringConstraint(place1: "Queensland", place2: "New South Wales"));
- csp?.addConstraint( MapColoringConstraint(place1: "New South Wales", place2: "South Australia"));
- csp?.addConstraint( MapColoringConstraint(place1: "Victoria", place2: "South Australia"));
- csp?.addConstraint( MapColoringConstraint(place1: "Victoria",place2: "New South Wales"));
+ csp?.addConstraint(constraint:MapColoringConstraint(place1: "Queensland", place2: "New South Wales"));
+ csp?.addConstraint(constraint: MapColoringConstraint(place1: "New South Wales", place2: "South Australia"));
+ csp?.addConstraint(constraint: MapColoringConstraint(place1: "Victoria", place2: "South Australia"));
+ csp?.addConstraint(constraint: MapColoringConstraint(place1: "Victoria",place2: "New South Wales"));
  }
 
  override func tearDown() {
@@ -82,7 +82,7 @@ class AustralianMapColoringTest: XCTestCase {
  return
  }
 
- if let solution = backtrackingSearch(cs, mrv: false) {
+ if let solution = backtrackingSearch(csp: cs, mrv: false) {
  print(solution, terminator: "")
  XCTAssertEqual(solution, ["South Australia": "b", "New South Wales": "g", "Western Australia": "r", "Northern Territory": "g", "Victoria": "r", "Tasmania": "r", "Queensland": "r"], "Pass")
  } else {

SwiftCSP/SwiftCSPTests/EightQueensTest.swift

@@ -33,7 +33,7 @@ final class EightQueensConstraint: ListConstraint <Int, Int> {
  super.init(variables: variables)
  }
 
- override func isSatisfied(_ assignment: Dictionary<Int, Int>) -> Bool {
+ override func isSatisfied(assignment: Dictionary<Int, Int>) -> Bool {
  // not the most efficient check for attacking each other...
  // better to subtract one from the other and go from there
  for q in assignment.values {
@@ -78,7 +78,7 @@ final class EightQueensConstraint: ListConstraint <Int, Int> {
  }
 }
 
-func drawQueens(_ solution: Dictionary<Int, Int>) {
+func drawQueens(solution: Dictionary<Int, Int>) {
  var output = "\n"
  for i in 0..<64 {
  if (solution.values.index(of: i) != nil) {
@@ -110,7 +110,7 @@ class EightQueensTest: XCTestCase {
 
  csp = CSP<Int, Int>(variables: variables, domains: domains)
  let smmc = EightQueensConstraint(variables: variables)
- csp?.addConstraint(smmc)
+ csp?.addConstraint(constraint: smmc)
 
  }
 
@@ -122,9 +122,9 @@ class EightQueensTest: XCTestCase {
  func testSolution() {
  // This is an example of a functional test case.
  if let cs: CSP<Int, Int> = csp {
- if let solution = backtrackingSearch(cs, mrv: true) {
+ if let solution = backtrackingSearch(csp: cs, mrv: true) {
  print(solution, terminator: "")
- drawQueens(solution)
+ drawQueens(solution: solution)
  XCTAssertEqual(solution, [2: 58, 4: 20, 5: 53, 6: 14, 7: 31, 0: 0, 1: 33, 3: 43], "Pass")
  } else {
  XCTFail("Fail")

SwiftCSP/SwiftCSPTests/SendMoreMoneyTest.swift

@@ -33,7 +33,7 @@ final class SendMoreMoneyConstraint: ListConstraint <String, Int> {
  super.init(variables: variables)
  }
 
- override func isSatisfied(_ assignment: Dictionary<String, Int>) -> Bool {
+ override func isSatisfied(assignment: Dictionary<String, Int>) -> Bool {
  // if there are duplicate values then it's not correct
  let d = Set<Int>(assignment.values)
  if d.count < assignment.count {
@@ -77,7 +77,7 @@ class SendMoreMoneyTest: XCTestCase {
 
  csp = CSP<String, Int>(variables: variables, domains: domains)
  let smmc = SendMoreMoneyConstraint(variables: variables)
- csp?.addConstraint(smmc)
+ csp?.addConstraint(constraint: smmc)
 
  }
 
@@ -89,7 +89,7 @@ class SendMoreMoneyTest: XCTestCase {
  func testSolution() {
  // This is an example of a functional test case.
  if let cs: CSP<String, Int> = csp {
- if let solution = backtrackingSearch(cs, mrv: true) {
+ if let solution = backtrackingSearch(csp: cs, mrv: true) {
  print(solution, terminator: "")
 
  if let s = solution["S"], e = solution["E"], n = solution["N"], d = solution["D"], m = solution["M"], o = solution["O"], r = solution["R"], y = solution["Y"] {