Starting to fill in code generators. Have basic correctness test several.

Author: Ichoran

benchmark/src/main/scala/bench/CodeGen.scala

@@ -4,7 +4,9 @@ import scala.util._
 import scala.util.control.NonFatal
 
 object Generator {
-  val names = "arr ish lst ils que stm trs vec arb ars ast mhs lhs prq muq wra jix jln".split(' ')
+  val annotated = "arr ish lst* ils* que* stm* trs* vec arb ars ast* mhs lhs* prq* muq* wra jix jln".split(' ')
+  val names = annotated.map(_.takeWhile(_.isLetter))
+  val nojnames = names.filterNot(_ startsWith "j")
 
   def writeTo(f: java.io.File)(pr: (String => Unit) => Unit): Either[Throwable, Unit] = {
     try {
@@ -20,15 +22,39 @@ object Generator {
   def sayArrayI(oa: Option[Array[Int]]) = oa match { case Some(a) => a.mkString("Array(", ",", ")"); case _ => "" }
 
   def agreement(target: java.io.File, sizes: Option[Array[Int]] = None) {
+    val q = "\""
     if (target.exists) throw new java.io.IOException("Generator will not write to existing file: " + target.getPath)
     writeTo(target){ pr =>
       pr("""package bench.test""")
       pr("""""")
+      pr("""import bench.generate._, bench.operate._, bench.generate.EnableIterators._""")
+      pr("""import scala.compat.java8.StreamConverters._""")
+      pr("""""")
       pr("""object Agreement {""")
       pr("""  def run() {""")
       pr("""    val wrong = new collection.mutable.ArrayBuffer[String]""")
-      pr("""    def check[A](a1: A, a2: A, msg: String) = if (a1 != a2) wrong += msg""")
+      pr("""    def check[A](a1: A, a2: => A, msg: String) {""")
+      pr("""      var t = System.nanoTime""")
+      pr("""      if (!CloseEnough(a1, { val ans = a2; t = System.nanoTime - t; ans})) wrong += msg""")
+      pr("""      if (t > 2000000000) wrong += "Slow " + msg""")
+      pr("""    }""")
       pr( s"    val x = new bench.generate.Things(${sayArrayI(sizes)})" )
+      pr("""    for (i <- 0 until x.N) {""")
+      pr("""      val si = OnInt.sum(x.arr.cI(i))""")
+      nojnames.tail.foreach{ n =>
+      pr( s"      check(si, OnInt.sum(x.$n.cI(i)), ${q}cI sum $n ${q}+i.toString)")
+      }
+      nojnames.foreach{ n => 
+      pr( s"      check(si, OnInt.sum(x.$n.iI(i)), ${q}iI sum $n ${q}+i.toString)")
+      }
+      annotated.foreach{ m =>
+      val n = m.takeWhile(_.isLetter)
+      val c = if (m contains "*") "ssI" else "spI"
+      pr( s"      check(si, OnInt.sum(x.$n.$c(i)), ${q}$c sum $n ${q}+i.toString)")
+      }
+      pr( s"    }")
+      pr("""    wrong.foreach(println)""")
+      pr("""    if (wrong.nonEmpty) sys.exit(1) """)
       pr("""  }""")
       pr("""}""")
     } match {

benchmark/src/main/scala/bench/CollectionSource.scala

@@ -214,6 +214,17 @@ package object generate {
     }
   }
 
+  object EnableIterators {
+    implicit val iterableIntToIterator: (Iterable[Int] => Iterator[Int]) = _.iterator
+    implicit val iterableStringToIterator: (Iterable[String] => Iterator[String]) = _.iterator
+    implicit val arrayIntToIterator: (Array[Int] => Iterator[Int]) = (a: Array[Int]) => new Iterator[Int] {
+      private[this] var i = 0
+      def hasNext = i < a.length
+      def next = if (hasNext) { var ans = a(i); i += 1; ans } else throw new NoSuchElementException(i.toString)
+    }
+    implicit val arrayStringToIterator: (Array[String] => Iterator[String]) = _.iterator
+  }
+
   class ArrThings(val sizes: Array[Int]) extends AbstractThings[Array]("Array") {}
 
   class IshThings(val sizes: Array[Int]) extends AbstractThings[collection.immutable.HashSet]("immutable.HashSet") {}
@@ -250,7 +261,8 @@ package object generate {
 
   class JlnThings(val sizes: Array[Int]) extends AbstractThings[java.util.LinkedList]("java.util.LinkedList") {}
 
-  class Things(sizes: Array[Int] = Array(0, 1, 2, 5, 7, 15, 16, 32, 33, 64, 129, 256, 1023, 2914, 7151, 50000, 200000, 1000000)) {
+  class Things(sizes: Array[Int] = Array(0, 1, 2, 5, 7, 15, 16, 32, 33, 64, 129, 256, 1023, 2914, 7151, 20000, 50000, 200000)) {
+    def N = sizes.length
     lazy val arr = new ArrThings(sizes)
     lazy val ish = new IshThings(sizes)
     lazy val lst = new LstThings(sizes)