Present

src/main/clojure/clj/bridge.clj

@@ -44,7 +44,7 @@
 )
 
 (defn -search [n1 n2 box callable]
-  (println (str "Max generations: " (* n1 n2)))
+;;  (println (str "Max generations: " (* n1 n2)))
   (let [fitness (fn [tree]
                    (.set box 0 (to-java tree))
                    (.call callable))

src/main/scala/org/allenai/iqclid/Demo.scala

@@ -0,0 +1,23 @@
+package org.allenai.iqclid
+
+import org.allenai.iqclid.api.{AccuracyFirstFitness, Ensemble, Evaluator, MultipleRunSolver}
+
+object Demo {
+
+
+  def main(args: Array[String]): Unit = {
+    val fitness = new AccuracyFirstFitness(0.5)
+    val gpSolver = new MultipleRunSolver(new GPSolver(fitness), 10)
+    val smtSolver = new Z3Solver
+    val search = new BaselineSearch(0.01, 100, 30)
+    val ensemble = new Ensemble(Seq(gpSolver, smtSolver, search))
+
+    val numberSequence = new NumberSequence(Seq(7, 3, 84))
+
+    val tree = ensemble.solve(numberSequence).head.tree
+    println(tree)
+    println(Evaluator.evaluate(tree, numberSequence.baseCases(tree), 10))
+    System.exit(0)
+  }
+
+}

src/main/scala/org/allenai/iqclid/Evaluator.scala

@@ -1,6 +1,6 @@
 package org.allenai.iqclid
 
-import org.allenai.iqclid.api.{ Evaluator, Solver, Tree }
+import org.allenai.iqclid.api.{Evaluator, I, Solver, Tree}
 
 case class Info(
     baseCases: Seq[Int],
@@ -44,21 +44,41 @@ class Evaluator {
     seqs.toStream.map {
       seq =>
         val results = solver.solve(seq.numberSequence)
-        val tree = results.head.tree
-        val actual = Info(seq.numberSequence.baseCases(tree), tree, results.head.fitness, seq.numberSequence.length, 1)
-        val answer = seq.answer
-        val expected = Info(seq.numberSequence.baseCases(answer), answer, 0, seq.numberSequence.length, 1)
-        Evaluation(actual, expected)
+        results match {
+          case Seq() =>
+            val actual = Info(seq.numberSequence.baseCases(I()), I(), Double.MaxValue, seq
+                .numberSequence.length, 1)
+            val answer = seq.answer
+            val expected = Info(seq.numberSequence.baseCases(answer), answer, 0, seq.numberSequence.length, 1)
+            Evaluation(actual, expected)
+          case _ =>
+            val tree =  results.head.tree
+            val actual = Info(seq.numberSequence.baseCases(tree), tree, results.head.fitness, seq.numberSequence.length, 1)
+            val answer = seq.answer
+            val expected = Info(seq.numberSequence.baseCases(answer), answer, 0, seq.numberSequence.length, 1)
+            Evaluation(actual, expected)
+        }
+
+
     }
   }
 
-  def report(evals: Stream[Evaluation]) = {
+  def report(evals: Stream[Evaluation], datasetName: String, solver: String) = {
     evals.foreach {
       eval =>
-        println(eval)
-        println
+//        println(eval)
+//        println
     }
-    val score = evals.count(_.isCorrect).toDouble / evals.size * 100
-    println(f"Score: $score%1.2f %%")
+    val correct = evals.count(_.isCorrect)
+    val total = evals.size
+    val incorrect = total - correct
+    val score = correct.toDouble / total * 100
+    println(
+      f"SOLVER: $solver\n" +
+      f"DATASET: $datasetName\n" +
+        f"CORRECT: $correct\n" +
+        f"INCORRECT: $incorrect\n" +
+        f"TOTAL: $total\n" +
+        f"SCORE: $score%1.2f %%\n\n")
   }
 }

src/main/scala/org/allenai/iqclid/GPSolver.scala

@@ -18,7 +18,7 @@ object GPSolver {
       //    val sequence = NumberSequence(Seq(1, 2, 3, 4, 5), 1)
       val evaluator = new Evaluator
       val evals = evaluator.eval(IqTest.easy ++ IqTest.medium, solver)
-      evaluator.report(evals)
+      evaluator.report(evals, "Easy and Med", "GP SOLVER")
     } catch {
       case ex: Exception =>
         println(ex)

src/main/scala/org/allenai/iqclid/Main.scala

@@ -1,15 +1,58 @@
 package org.allenai.iqclid
 
+import org.allenai.iqclid.api.{ AccuracyFirstFitness, Ensemble, MultipleRunSolver }
+import org.allenai.iqclid.dataset.IqTest
+import org.allenai.iqclid.z3.RonanSmtSolver
+
 object Main {
 
   def main(args: Array[String]): Unit = {
 
-    val s = NumberSequence(Seq(2, 3, 4, 5, 6, 7, 8, 9, 10))
+    try {
+      println("Hello world from Scala!")
+      println(clj.Bridge.greet)
+      //    clj.Bridge.tutorial(15, 15)
+      val fitness = new AccuracyFirstFitness(0.5)
+      //      val fitness = new SmallFirstFitness(0.1)
+      //      val gpSolver = new MultipleRunSolver(new GPSolver(fitness), 3)
+      //      val smtSolver = new Z3Solver
+      //      val search = new MultipleRunSolver(new BaselineSearch(0.01, 100, 30), 3)
+      //      val ensemble = new Ensemble(Seq(gpSolver, smtSolver, search))
+      val ronan = new RonanSmtSolver
+      val evaluator = new Evaluator
+
+      evaluator.report(evaluator.eval(IqTest.euclid, ronan), "euclid", "Ronan")
+      evaluator.report(evaluator.eval(IqTest.easy, ronan), "IQ easy", "Ronan")
+      evaluator.report(evaluator.eval(IqTest.medium, ronan), "IQ medium", "Ronan")
+      evaluator.report(evaluator.eval(IqTest.agiPaper, ronan), "agi", "Ronan")
+
+      //      evaluator.report(evaluator.eval(IqTest.euclid, gpSolver), "euclid", "GPSolver")
+      //      evaluator.report(evaluator.eval(IqTest.easy, gpSolver), "IQ easy", "GPSolver")
+      //      evaluator.report(evaluator.eval(IqTest.medium, gpSolver), "IQ medium", "GPSolver")
+      //      evaluator.report(evaluator.eval(IqTest.agiPaper, gpSolver), "agi", "GPSolver")
+      //
+      //      evaluator.report(evaluator.eval(IqTest.euclid, smtSolver), "euclid", "SMT")
+      //      evaluator.report(evaluator.eval(IqTest.easy, smtSolver), "IQ easy", "SMT")
+      //      evaluator.report(evaluator.eval(IqTest.medium, smtSolver), "IQ medium", "SMT")
+      //      evaluator.report(evaluator.eval(IqTest.agiPaper, smtSolver), "agi", "SMT")
+      //
+      //      evaluator.report(evaluator.eval(IqTest.euclid, search), "euclid", "Local Search")
+      //      evaluator.report(evaluator.eval(IqTest.easy, search), "IQ easy", "Local Search")
+      //      evaluator.report(evaluator.eval(IqTest.medium, search), "IQ medium", "Local Search")
+      //      evaluator.report(evaluator.eval(IqTest.agiPaper, search), "agi", "Local Search")
+      //
+      //      evaluator.report(evaluator.eval(IqTest.euclid, ensemble), "euclid", "Ensemble")
+      //      evaluator.report(evaluator.eval(IqTest.easy, ensemble), "IQ easy", "Ensemble")
+      //      evaluator.report(evaluator.eval(IqTest.medium, ensemble), "IQ medium", "Ensemble")
+      //      evaluator.report(evaluator.eval(IqTest.agiPaper, ensemble), "agi", "Ensemble")
 
-    val search = new BaselineSearch(0.01, 100, 30)
-    val best = search.best(s)
+    } catch {
+      case ex: Exception =>
+        println(ex)
+    } finally {
+      sys.exit(0)
+    }
 
-    println(best)
   }
 
 }

src/main/scala/org/allenai/iqclid/NumberSequence.scala

@@ -15,10 +15,10 @@ trait Dataset {
         generated == s.numberSequence.seq :+ s.nextTerm
     }
   }
-
 }
 
-case class DatasetSequence(numberSequence: NumberSequence, nextTerm: Int, answer: Tree)
+case class DatasetSequence(numberSequence: NumberSequence, nextTerm: Int, answer: Tree,
+    numBaseCases: Int)
 
 /** Class representing a number sequence. numBaseCases represents the number of terms that need
   * to be fixed to generate the sequence. Ex: For Fibonacci, numBaseCases is 2.

src/main/scala/org/allenai/iqclid/Search.scala

@@ -19,7 +19,7 @@ abstract class BeamSearch(maxSteps: Int, bestk: Int) extends Search {
   override def solve(target: NumberSequence): Seq[Solution] = {
     (0 until maxSteps).foldLeft(Seq[Solution]()) {
       case (accSols, step) =>
-        println(s"STEP: $step")
+//        println(s"STEP: $step")
         val accTrees = accSols.map(_.tree)
         val p = proposals(accTrees)
         val candidates = (accTrees ++ proposals(accTrees))

src/main/scala/org/allenai/iqclid/Z3Solver.scala

@@ -7,16 +7,13 @@ import org.allenai.iqclid.z3._
 class Z3Solver extends Solver {
 
   def getFunctionTree(depth: Int, nSeq: NumberSequence, numBaseCases: Int): Seq[Tree] = {
-    var upper = 0
+    var upper = 100
     var lower = 0
 
     var result: Seq[Tree] = Seq()
     var counter = 0
 
     do {
-      println("UPPER: " + upper)
-      println("LOWER: " + lower)
-      println("RESULT " + result)
       val newBound = (upper + lower) / 2
       counter += 1
       try {

src/main/scala/org/allenai/iqclid/api/Solver.scala

@@ -16,7 +16,19 @@ trait Solver {
 class Ensemble(solvers: Seq[Solver]) extends Solver {
   override def solve(s: NumberSequence): Seq[Solution] = {
     val solutions = solvers.flatMap(_.solve(s))
-    val maxScore = solutions.maxBy(x => x.fitness).fitness
+    val maxScore = solutions.minBy(x => x.fitness).fitness
     solutions.filter { x => x.fitness == maxScore }
   }
 }
+
+class MultipleRunSolver(solver: Solver, iterations: Int) extends Solver {
+  override def solve(s: NumberSequence): Seq[Solution] = {
+    val solutions = (0 until iterations).foldLeft(Seq[Solution]()) {
+      case (acc, _) =>
+        acc ++ solver.solve(s)
+    }
+    val maxScore = solutions.minBy(x => x.fitness).fitness
+    solutions.filter { x => x.fitness == maxScore }
+  }
+
+}

src/main/scala/org/allenai/iqclid/api/TreeApi.scala

@@ -28,7 +28,7 @@ object Tree {
           case Pow() => 10
         }
         thisNode + subTrees
-      case Number(i) => i
+      case Number(i) => Math.abs(i)
       case I() => 1
       case T(i) => 2*i
     }