wip

Author: nicolasstucki

tests/run-with-compiler/shonan-hmm.check

@@ -230,3 +230,27 @@ List(25, 30, 20, 43, 44)
     vout.update(4, v.apply(2).*(3).+(v.apply(4).*(7)))
   })
 }
+
+
+
+((vout: scala.Array[scala.Int], v: scala.Array[scala.Int]) => {
+  if (5.!=(vout.length)) throw new scala.IndexOutOfBoundsException("5") else ()
+  if (5.!=(v.length)) throw new scala.IndexOutOfBoundsException("5") else ()
+  vout.update(0, v.apply(0).*(5).+(v.apply(3).*(5)))
+  vout.update(1, v.apply(2).*(10))
+  vout.update(2, v.apply(1).*(10))
+  vout.update(3, {
+    var sum: scala.Int = 0
+    scala.Predef.intWrapper(0).until(5).foreach[scala.Unit](((i: scala.Int) => sum = sum.+(v.apply(i).*({
+      val array: scala.Array[scala.Int] = new scala.Array[scala.Int](5)
+      array.update(0, 0)
+      array.update(1, 0)
+      array.update(2, 2)
+      array.update(3, 3)
+      array.update(4, 5)
+      array
+    }.apply(i)))))
+    (sum: scala.Int)
+  })
+  vout.update(4, v.apply(2).*(3).+(v.apply(4).*(7)))
+})

tests/run-with-compiler/shonan-hmm/MVmult.scala

@@ -55,56 +55,84 @@ object MVmult {
   }
 
   def mvmult_ac(a: Array[Array[Int]]): Expr[(Array[Int], Array[Int]) => Unit] = {
-    val n = a.length
-    val m = a(0).length
     import Lifters._
     '{
       val arr = ~a.toExpr
       ~{
-        val a2: Vec[PV[Int], Vec[PV[Int], PV[Int]]] = Vec(Sta(n), i => Vec(Sta(m), j => (i, j) match {
-          case (Sta(i), Sta(j)) => Sta(a(i)(j))
-          case (Sta(i), Dyn(j)) => Dyn('(arr(~i.toExpr)(~j)))
-          case (i, j) => Dyn( '{ arr(~(Dyns.dyni(i)))(~(Dyns.dyni(j))) })
-        }))
-        mvmult_abs0(new RingIntPExpr, new VecRStaDyn(new RingIntPExpr))(a.length, a(0).length, a2)
+        val (n, m, a2) = amat1(a, '(arr))
+        mvmult_abs0(new RingIntPExpr, new VecRStaDyn(new RingIntPExpr))(n, m, a2)
       }
     }
   }
 
   def mvmult_opt(a: Array[Array[Int]]): Expr[(Array[Int], Array[Int]) => Unit] = {
-    val n = a.length
-    val m = a(0).length
     import Lifters._
     '{
       val arr = ~a.toExpr
       ~{
-        val a2: Vec[PV[Int], Vec[PV[Int], PV[Int]]] = Vec(Sta(n), i => Vec(Sta(m), j => (i, j) match {
-          case (Sta(i), Sta(j)) => Sta(a(i)(j))
-          case (Sta(i), Dyn(j)) => Dyn('(arr(~i.toExpr)(~j)))
-          case (i, j) => Dyn( '{ arr(~(Dyns.dyni(i)))(~(Dyns.dyni(j))) })
-        }))
-        mvmult_abs0(new RingIntOPExpr, new VecRStaDyn(new RingIntPExpr))(a.length, a(0).length, a2)
+        val (n, m, a2) = amat1(a, '(arr))
+        mvmult_abs0(new RingIntOPExpr, new VecRStaDyn(new RingIntPExpr))(n, m, a2)
       }
     }
   }
 
   def mvmult_roll(a: Array[Array[Int]]): Expr[(Array[Int], Array[Int]) => Unit] = {
-    val n = a.length
-    val m = a(0).length
     import Lifters._
     '{
       val arr = ~a.toExpr
       ~{
-        val a2: Vec[PV[Int], Vec[PV[Int], PV[Int]]] = Vec(Sta(n), i => Vec(Sta(m), j => (i, j) match {
-          case (Sta(i), Sta(j)) => Sta(a(i)(j))
-          case (Sta(i), Dyn(j)) => Dyn('(arr(~i.toExpr)(~j)))
-          case (i, j) => Dyn( '{ arr(~(Dyns.dyni(i)))(~(Dyns.dyni(j))) })
-        }))
-        mvmult_abs0(new RingIntOPExpr, new VecRStaOptDynInt(new RingIntPExpr))(a.length, a(0).length, a2)
+        val (n, m, a2) = amat1(a, '(arr))
+        mvmult_abs0(new RingIntOPExpr, new VecRStaOptDynInt(new RingIntPExpr))(n, m, a2)
       }
     }
   }
 
+  def mvmult_let1(a: Array[Array[Int]]): Expr[(Array[Int], Array[Int]) => Unit] = {
+    val (n, m, a2) = amatCopy(a, copy_row1)
+    mvmult_abs0(new RingIntOPExpr, new VecRStaOptDynInt(new RingIntPExpr))(n, m, a2)
+  }
+
+  def mvmult_let(a: Array[Array[Int]]): Expr[(Array[Int], Array[Int]) => Unit] = {
+    val (n, m, a2) = amatCopy(a, copy_row_let)
+    mvmult_abs0(new RingIntOPExpr, new VecRStaOptDynInt(new RingIntPExpr))(n, m, a2)
+  }
+
+  def amat1(a: Array[Array[Int]], aa: Expr[Array[Array[Int]]]): (Int, Int, Vec[PV[Int], Vec[PV[Int], PV[Int]]]) = {
+    val n = a.length
+    val m = a(0).length
+    val vec: Vec[PV[Int], Vec[PV[Int], PV[Int]]] = Vec(Sta(n), i => Vec(Sta(m), j => (i, j) match {
+      case (Sta(i), Sta(j)) => Sta(a(i)(j))
+      case (Sta(i), Dyn(j)) => Dyn('((~aa)(~i.toExpr)(~j)))
+      case (i, j) => Dyn('{ (~aa)(~(Dyns.dyni(i)))(~(Dyns.dyni(j))) })
+    }))
+    (n, m, vec)
+  }
+
+  def amatCopy(a: Array[Array[Int]], copyRow: Array[Int] => (Expr[Int] => Expr[Int])): (Int, Int, Vec[PV[Int], Vec[PV[Int], PV[Int]]]) = {
+    val n = a.length
+    val m = a(0).length
+    val vec: Vec[PV[Int], Vec[PV[Int], PV[Int]]] = Vec(Sta(n), i => Vec(Sta(m), j => (i, j) match {
+      case (Sta(i), Sta(j)) => Sta(a(i)(j))
+      case (Sta(i), Dyn(j)) =>
+        val defrec = copyRow(a(i))
+        Dyn(defrec(j))
+      case (i, j) => ???
+    }))
+    (n, m, vec)
+  }
+
+  def copy_row1: Array[Int] => (Expr[Int] => Expr[Int]) = v => {
+    import Lifters._
+    val arr = v.toExpr
+    i => '{ (~arr).apply(~i) }
+  }
+
+  def copy_row_let: Array[Int] => (Expr[Int] => Expr[Int]) = v => {
+    import Lifters._
+    val arr: Expr[Array[Int]] = ??? // FIXME used genlet v.toExpr
+    i => '{ (~arr).apply(~i) }
+  }
+
   private def mvmult_abs0(ring: Ring[PV[Int]], vecOp: VecROp[PV[Int], PV[Int], Expr[Unit]])(n: Int, m: Int, a: Vec[PV[Int], Vec[PV[Int], PV[Int]]]): Expr[(Array[Int], Array[Int]) => Unit] = {
     '{
       (vout, v) => {
@@ -120,5 +148,4 @@ object MVmult {
     }
   }
 
-
 }

tests/run-with-compiler/shonan-hmm/Test.scala

@@ -75,7 +75,16 @@ object Test {
     println()
 
     println(MVmult.mvmult_roll(a).show)
+    println()
+    println()
+    println()
+
+    println(MVmult.mvmult_let1(a).show)
+//    println()
+//    println()
+//    println()
 
+//    println(MVmult.mvmult_let(a).show)
   }
 }