adding functions to generate random functions and outputs.

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

@@ -26,17 +26,7 @@ case class DatasetSequence(numberSequence: NumberSequence, nextTerm: Int, answer
 case class NumberSequence(seq: Seq[Int]) {
   val length = seq.length
   def baseCases(tree: Tree): Seq[Int] = {
-    seq.take(baseCount(tree))
+    seq.take(tree.baseCount(tree))
   }
 
-  private def baseCount(tree: Tree): Int = {
-    tree match {
-      case T(i) =>
-        i
-      case Apply(_, args) =>
-        args.map(baseCount).max
-      case _ =>
-        0
-    }
-  }
 }

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

@@ -2,6 +2,8 @@ package org.allenai.iqclid
 
 import org.allenai.iqclid.api._
 
+import scala.util.Random
+
 object RandUtil {
 
   def randInt(range: Int): Int = {
@@ -73,4 +75,62 @@ object RandUtil {
     }
     replaceRandomNodeHelper(tree, 0)._1
   }
+
+  def randomSimpleTree(): Tree = {
+    // random operation
+    val operations = Seq(Plus(), Times(), Minus(), Div(), Mod(), Pow() )
+    val randomOp = operations(Random.nextInt(operations.size))
+
+    // leaves
+    val number = (0 until 10).map(Number(_))
+    val leaves: Seq[Leaf] = number ++ Seq(I(), T(1), T(2), T(3))
+    val leaf1 = leaves(Random.nextInt(leaves.length))
+    val leaf2 = leaves(Random.nextInt(leaves.length))
+    Apply(randomOp, Seq(leaf1, leaf2))
+  }
+
+  def addToTree(tree: Tree): Tree = {
+    val r = scala.util.Random
+    tree match {
+      case Apply(op, Seq(arg1, arg2)) =>
+        if(r.nextBoolean()) {
+          Apply(op, Seq(addToTree(arg1), arg2))
+        } else {
+          Apply(op, Seq(arg1, addToTree(arg2)))
+        }
+      case l: Leaf =>
+        randomSimpleTree()
+    }
+  }
+
+  def randomTreeOfDepthk(k: Int) : Tree = {
+    k match {
+      case 0 => randomSimpleTree()
+      case _ => addToTree(randomTreeOfDepthk(k-1))
+    }
+  }
+
+  def main(args: Array[String]): Unit = {
+    import java.io._
+    val pw = new PrintWriter(new File("data.txt"))
+    (0 to 5000000).foreach { _ =>
+      try {
+        // depth of the tree
+        val k = Random.nextInt(5)
+        val t = addToTree(randomTreeOfDepthk(k))
+        //println(t)
+        //println(t.baseCount(t))
+        val baseCases = (0 until t.baseCount(t)).map(_ => Random.nextInt(10) + 1)
+        //println(baseCases)
+        val generated = Evaluator.evaluate(t, baseCases, 10)
+        //println(generated)
+        if(generated.count(a => math.abs(a) > 10) == 0) {
+          pw.write(s"${k+1}\t${generated.mkString(" ")}\t${t.prefix(t)}\t${t.baseCount(t)}\n")
+        }
+      } catch {
+        case _: Throwable => //println("skipping ... ")
+      }
+    }
+    pw.close
+  }
 }

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

@@ -42,7 +42,8 @@ class BaselineSearch(alpha: Double, maxSteps: Int, bestk: Int) extends BeamSearc
     }
     val createLeaves = (0 until 5).map(Number(_)) ++ Seq(T(1), T(2), I())
     val replaceSubtrees = trees.map(replaceRandomNode)
-    mergeTrees ++ createLeaves ++ replaceSubtrees
+    val addToSubtree = trees.map(addToTree)
+    mergeTrees ++ createLeaves ++ replaceSubtrees ++ addToSubtree
 
   }