Generator for correctness almost complete.

Still some differences between algorithms for different methods, so results aren't actually identical yet.  (May need to intercept sets differently also.)

Author: Ichoran

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

@@ -1,12 +1,17 @@
 package bench.codegen
 
 import scala.util._
-import scala.util.control.NonFatal
+import control.NonFatal
 
 object Generator {
   val annotated = "arr ish lst* ils* que* stm* trs* vec arb ars ast* mhs lhs* prq* muq* wra jix jln".split(' ')
+  val allops = Seq(("OnInt", "I", "sum/psum trig/ptrig fmc/pfmc mdtc"), ("OnString", "S", "nbr/pnbr htrg/phtrg fmc/pfmc mdtc"))
+  def parsefs(fs: String) = fs.split(' ').map(_.split('/') match { case Array(x) => (x, None); case Array(x,y) => (x, Some(y)) })
+
   val names = annotated.map(_.takeWhile(_.isLetter))
-  val nojnames = names.filterNot(_ startsWith "j")
+  val nojname = names.filterNot(_ startsWith "j").toSet
+  val parname = annotated.filter(_.forall(_.isLetter)).toSet
+  val sqnname = names.filterNot(parname).toSet union names.filterNot(nojname).toSet
 
   def writeTo(f: java.io.File)(pr: (String => Unit) => Unit): Either[Throwable, Unit] = {
     try {
@@ -35,24 +40,39 @@ object Generator {
       pr("""    val wrong = new collection.mutable.ArrayBuffer[String]""")
       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 (!CloseEnough(a1, { val ans = a2; t = System.nanoTime - t; ans}))""")
+      pr("""        wrong += msg""")
       pr("""      if (t > 2000000000) wrong += "Slow " + msg""")
       pr("""    }""")
+      pr( s"    val m = (new bench.generate.Things(${sayArrayI(sizes)})).N;" )
+      allops.foreach{ case (o, t, fs) =>
+        names.foreach{ n =>
+      pr( s"    {  // Scope for operations $o collection $n")
       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)")
-      }
+          parsefs(fs).foreach{ case (f, pf) =>
+      pr("""    for (i <- 0 until m) {""")
+      pr( s"      val z = $o.$f(x.arr.c$t(i))")
+            if (nojname(n)) {
+      pr( s"      check(z, $o.$f(x.$n.c$t(i)), ${q}c$t $f $n ${q}+i.toString)");
+      pr( s"      check(z, $o.$f(x.$n.i$t(i)), ${q}i$t $f $n ${q}+i.toString)")
+            }
+            if (sqnname(n)) {
+      pr( s"      check(z, $o.$f(x.$n.ss$t(i)), ${q}ss$t $f $n ${q}+i.toString)")
+              if (nojname(n)) {  
+      pr( s"      check(z, $o.$f(x.$n.zs$t(i)), ${q}zs$t $f $n ${q}+i.toString)")     
+              }
+            }
+            if (parname(n)) {
+      pr( s"      check(z, $o.$f(x.$n.sp$t(i)), ${q}sp$t $f $n ${q}+i.toString)")
+             if (nojname(n)) {
+      pr( s"      check(z, $o.$f(x.$n.zp$t(i)), ${q}zp$t $f $n ${q}+i.toString)")     
+              }
+            }
       pr( s"    }")
+          }
+      pr( s"    }  // End scope for operations $o collection $n")
+        }
+      }
       pr("""    wrong.foreach(println)""")
       pr("""    if (wrong.nonEmpty) sys.exit(1) """)
       pr("""  }""")

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

@@ -261,7 +261,7 @@ 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, 20000, 50000, 200000)) {
+  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)